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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ab8813b62baa17cfdcc86ee9dc9afe2113f1d849 | 3209e19673c35df242085882015083674ba8c08e | /labs/lab06/DateCrash/main.cpp | 5d90acc26256430c28b47f5596e8f97d0b5961e8 | [] | no_license | goelsaksham/umn_csci_3081W_robot_game_simulator | 531df759dfb1e14e52c3ba8a4da7118861316672 | aa209aba1a2336e6fd523bf76b9eda5f55bcf4fb | refs/heads/master | 2020-03-29T01:21:18.295260 | 2018-09-19T03:08:56 | 2018-09-19T03:08:56 | 149,384,940 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,251 | cpp | #include "Date.h"
#include <iostream>
#include <string>
using namespace std ;
void doInterestingThing(int yr) {
//variables used in this method
int* array_len;
Date d1;
Date d2;
Date d3;
Date* birthday_list;
cout << " ... A set of Dates ... " << endl;
array_len = NULL;
d2 = Date(yr,4,19);
d3 = d2.copy();
int x = 4;
array_len = &x;
cout << "default date is: " << d1.show() << endl ;
cout << "date d2 is: " << d2.show() << endl ;
cout << "date d3 is: " << d3.show() << endl;
cout << " ... Now print out 4 dates in reverse time order ... " << endl;
birthday_list = new Date[*array_len];
//accumulate the all dates January 1, from 1990 to 1990+array_len
for (int i=0; i<*array_len; i++) {
birthday_list[i] = Date(1990+i,1,1);
}
// now show the dates accumulated in reverse order
for (int i=*array_len-1; i>-1; --i) {
cout << "date is: " << birthday_list[i].show() << endl;
}
// now set the dates to January 2
for (int i=0; i<*array_len; i++) {
birthday_list[i] = Date(1990+i,1,2);
}
cout << "the first date is: " << birthday_list[0].show() << endl;
}
int main() {
doInterestingThing(1998);
doInterestingThing(1999);
cout << endl << "... Goodbye ..." << endl ;
}
| [
"goelx029@umn.edu"
] | goelx029@umn.edu |
8d6b2ccce62e67e7434f5e7d6dc078765351a1e7 | a4e3f58154c349f951066c61db4c2e23ddb095ce | /OpenFoam_Cases/Channel_13350_M2/processor0/18000/nut | c7b91e4a78693399f69f4d66fdc72200e9d207af | [] | no_license | dikshant96/Thesis_OF1 | a53d1b01b19e9bf95f4b03fc3787298b8244c1c5 | 2c6ed256347a2e32611a93e117022d9aa1ff3317 | refs/heads/master | 2020-09-11T01:59:25.606585 | 2019-11-15T11:04:11 | 2019-11-15T11:04:11 | 221,902,054 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 51,246 | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 7
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "18000";
object nut;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField nonuniform List<scalar>
4037
(
0.00027343
0.000273436
0.000273441
0.000273445
0.000273449
0.000273451
0.000273454
0.000273456
0.000273458
0.00027346
0.000273462
0.000273463
0.000273465
0.000273467
0.000273468
0.000273469
0.00027347
0.000273472
0.000273473
0.000273474
0.000273476
0.000273477
0.000273477
0.000273479
0.00027348
0.000273481
0.000273482
0.000273483
0.000273484
0.000273485
0.000273486
0.000273487
0.000273489
0.000273489
0.000273491
0.000273492
0.000273492
0.000273494
0.000273494
0.000273496
0.000273497
0.000273498
0.000273499
0.000273499
0.000273501
0.000273501
0.000273502
0.000273503
0.000273504
0.000273505
0.000273506
0.000273507
0.000273508
0.000273508
0.000273509
0.00027351
0.00027351
0.000273511
0.000273512
0.000273513
0.000273513
0.000273514
0.000273514
0.000273515
0.000273515
0.000273516
0.000273516
0.000273516
0.000273516
0.000273517
0.000273517
0.000273517
0.000273517
0.000273518
0.000273518
0.000273517
0.000273519
0.000259477
0.000259469
0.000259466
0.000259465
0.000259465
0.000259465
0.000259465
0.000259464
0.000259464
0.000259464
0.000259464
0.000259464
0.000259464
0.000259465
0.000259465
0.000259465
0.000259466
0.000259466
0.000259466
0.000259466
0.000259467
0.000259467
0.000259467
0.000259466
0.00025948
0.00025949
0.000259495
0.0002595
0.000259504
0.000259507
0.000259509
0.000259512
0.000259514
0.000259516
0.000259518
0.000259519
0.000259521
0.000259523
0.000259524
0.000259526
0.000259527
0.000259528
0.000259529
0.00025953
0.000259532
0.000259533
0.000259534
0.000259535
0.000259536
0.000259537
0.000259538
0.000259539
0.000259541
0.000259541
0.000259542
0.000259544
0.000259544
0.000259546
0.000259546
0.000259548
0.000259548
0.00025955
0.000259551
0.000259552
0.000259553
0.000259553
0.000259555
0.000259555
0.000259556
0.000259557
0.000259558
0.000259559
0.00025956
0.000259561
0.000259562
0.000259562
0.000259563
0.000259564
0.000259565
0.000259565
0.000259566
0.000259567
0.000259567
0.000259568
0.000259568
0.000259569
0.00025957
0.00025957
0.000259571
0.000259571
0.000259571
0.000259571
0.000259572
0.000259572
0.000259572
0.000259572
0.000259573
0.000259573
0.000259573
0.000259572
0.000259575
0.00025955
0.00025954
0.000259535
0.000259532
0.000259529
0.000259527
0.000259524
0.000259522
0.00025952
0.000259517
0.000259516
0.000259514
0.000259512
0.000259509
0.000259508
0.000259506
0.000259504
0.000259501
0.000259504
0.000245925
0.000245916
0.000245913
0.000245912
0.000245911
0.000245911
0.00024591
0.00024591
0.00024591
0.00024591
0.00024591
0.00024591
0.00024591
0.00024591
0.000245911
0.000245911
0.000245911
0.000245912
0.000245912
0.000245912
0.000245913
0.000245913
0.000245913
0.000245912
0.000245919
0.000245926
0.000245932
0.000245936
0.00024594
0.000245943
0.000245946
0.000245948
0.00024595
0.000245952
0.000245954
0.000245955
0.000245957
0.000245959
0.00024596
0.000245962
0.000245963
0.000245964
0.000245965
0.000245967
0.000245968
0.000245969
0.00024597
0.000245971
0.000245972
0.000245973
0.000245974
0.000245975
0.000245976
0.000245977
0.000245978
0.000245979
0.00024598
0.000245981
0.000245982
0.000245983
0.000245984
0.000245985
0.000245986
0.000245987
0.000245988
0.000245989
0.00024599
0.000245991
0.000245992
0.000245993
0.000245993
0.000245994
0.000245995
0.000245996
0.000245997
0.000245997
0.000245998
0.000245999
0.000245999
0.000246
0.000246001
0.000246002
0.000246002
0.000246003
0.000246003
0.000246004
0.000246004
0.000246005
0.000246005
0.000246006
0.000246006
0.000246006
0.000246007
0.000246007
0.000246007
0.000246007
0.000246007
0.000246007
0.000246007
0.000246007
0.000246009
0.000245998
0.000245988
0.000245982
0.000245978
0.000245975
0.000245973
0.00024597
0.000245968
0.000245966
0.000245964
0.000245962
0.00024596
0.000245958
0.000245956
0.000245954
0.000245952
0.000245951
0.000245948
0.000245951
0.000232728
0.00023272
0.000232716
0.000232715
0.000232714
0.000232713
0.000232713
0.000232713
0.000232712
0.000232713
0.000232712
0.000232712
0.000232713
0.000232713
0.000232713
0.000232714
0.000232714
0.000232714
0.000232715
0.000232715
0.000232715
0.000232715
0.000232715
0.000232715
0.000232718
0.000232723
0.000232727
0.000232731
0.000232734
0.000232737
0.00023274
0.000232742
0.000232744
0.000232746
0.000232748
0.00023275
0.000232751
0.000232753
0.000232754
0.000232755
0.000232757
0.000232758
0.000232759
0.000232761
0.000232762
0.000232763
0.000232764
0.000232765
0.000232766
0.000232767
0.000232768
0.000232769
0.00023277
0.000232771
0.000232772
0.000232773
0.000232774
0.000232775
0.000232776
0.000232776
0.000232777
0.000232778
0.000232779
0.00023278
0.000232781
0.000232782
0.000232783
0.000232784
0.000232785
0.000232786
0.000232786
0.000232787
0.000232788
0.000232788
0.000232789
0.00023279
0.000232791
0.000232791
0.000232792
0.000232793
0.000232793
0.000232794
0.000232794
0.000232795
0.000232796
0.000232796
0.000232796
0.000232797
0.000232797
0.000232798
0.000232798
0.000232798
0.000232799
0.000232799
0.000232799
0.000232799
0.0002328
0.0002328
0.0002328
0.000232799
0.000232801
0.000232796
0.00023279
0.000232784
0.00023278
0.000232777
0.000232774
0.000232772
0.00023277
0.000232768
0.000232765
0.000232764
0.000232762
0.00023276
0.000232758
0.000232757
0.000232755
0.000232754
0.000232751
0.000232754
0.000219868
0.00021986
0.000219856
0.000219855
0.000219853
0.000219853
0.000219852
0.000219852
0.000219852
0.000219852
0.000219852
0.000219852
0.000219852
0.000219852
0.000219852
0.000219852
0.000219853
0.000219853
0.000219854
0.000219854
0.000219854
0.000219854
0.000219855
0.000219854
0.000219856
0.000219858
0.000219862
0.000219865
0.000219868
0.00021987
0.000219873
0.000219875
0.000219877
0.000219878
0.00021988
0.000219882
0.000219883
0.000219885
0.000219886
0.000219888
0.000219889
0.00021989
0.000219891
0.000219893
0.000219893
0.000219895
0.000219896
0.000219897
0.000219898
0.000219899
0.0002199
0.0002199
0.000219901
0.000219903
0.000219903
0.000219904
0.000219905
0.000219906
0.000219907
0.000219908
0.000219909
0.00021991
0.000219911
0.000219911
0.000219912
0.000219913
0.000219914
0.000219915
0.000219915
0.000219916
0.000219917
0.000219918
0.000219918
0.000219919
0.00021992
0.000219921
0.000219921
0.000219922
0.000219923
0.000219923
0.000219924
0.000219924
0.000219925
0.000219925
0.000219926
0.000219926
0.000219927
0.000219927
0.000219928
0.000219928
0.000219928
0.000219928
0.000219929
0.000219929
0.000219929
0.000219929
0.00021993
0.00021993
0.00021993
0.000219929
0.00021993
0.000219928
0.000219925
0.000219921
0.000219917
0.000219914
0.000219912
0.000219909
0.000219907
0.000219905
0.000219903
0.000219902
0.0002199
0.000219898
0.000219897
0.000219895
0.000219894
0.000219893
0.00021989
0.000219894
0.000207327
0.000207318
0.000207315
0.000207313
0.000207312
0.000207311
0.00020731
0.00020731
0.00020731
0.00020731
0.00020731
0.00020731
0.00020731
0.00020731
0.00020731
0.000207311
0.000207311
0.000207311
0.000207311
0.000207312
0.000207312
0.000207312
0.000207313
0.000207313
0.000207313
0.000207315
0.000207317
0.000207319
0.000207322
0.000207324
0.000207326
0.000207328
0.00020733
0.000207331
0.000207333
0.000207334
0.000207336
0.000207337
0.000207338
0.00020734
0.000207341
0.000207342
0.000207343
0.000207344
0.000207345
0.000207347
0.000207347
0.000207348
0.000207349
0.00020735
0.000207351
0.000207352
0.000207353
0.000207354
0.000207355
0.000207356
0.000207356
0.000207357
0.000207358
0.000207359
0.00020736
0.000207361
0.000207361
0.000207362
0.000207363
0.000207364
0.000207365
0.000207365
0.000207366
0.000207367
0.000207367
0.000207368
0.000207369
0.00020737
0.00020737
0.000207371
0.000207371
0.000207372
0.000207373
0.000207373
0.000207374
0.000207374
0.000207375
0.000207375
0.000207376
0.000207376
0.000207377
0.000207377
0.000207377
0.000207378
0.000207378
0.000207378
0.000207378
0.000207379
0.000207379
0.000207379
0.000207379
0.000207379
0.00020738
0.000207379
0.00020738
0.000207379
0.000207377
0.000207374
0.000207372
0.000207369
0.000207367
0.000207365
0.000207363
0.000207361
0.000207359
0.000207358
0.000207356
0.000207355
0.000207353
0.000207352
0.000207351
0.00020735
0.000207347
0.000207351
0.000195087
0.000195079
0.000195076
0.000195074
0.000195073
0.000195072
0.000195071
0.000195071
0.000195071
0.000195071
0.00019507
0.00019507
0.00019507
0.000195071
0.000195071
0.000195071
0.000195072
0.000195072
0.000195072
0.000195073
0.000195073
0.000195073
0.000195073
0.000195073
0.000195074
0.000195074
0.000195076
0.000195078
0.000195079
0.000195081
0.000195083
0.000195085
0.000195086
0.000195088
0.000195089
0.000195091
0.000195092
0.000195093
0.000195094
0.000195096
0.000195097
0.000195098
0.000195099
0.0001951
0.000195101
0.000195102
0.000195103
0.000195104
0.000195105
0.000195106
0.000195107
0.000195107
0.000195108
0.000195109
0.00019511
0.000195111
0.000195112
0.000195112
0.000195113
0.000195114
0.000195115
0.000195115
0.000195116
0.000195117
0.000195118
0.000195118
0.000195119
0.00019512
0.00019512
0.000195121
0.000195122
0.000195122
0.000195123
0.000195124
0.000195124
0.000195125
0.000195126
0.000195126
0.000195126
0.000195127
0.000195128
0.000195128
0.000195128
0.000195129
0.000195129
0.00019513
0.00019513
0.000195131
0.000195131
0.000195131
0.000195131
0.000195132
0.000195132
0.000195132
0.000195132
0.000195132
0.000195133
0.000195133
0.000195133
0.000195133
0.000195133
0.000195133
0.000195132
0.00019513
0.000195128
0.000195126
0.000195124
0.000195122
0.000195121
0.000195119
0.000195118
0.000195117
0.000195115
0.000195114
0.000195113
0.000195111
0.00019511
0.000195109
0.000195107
0.00019511
0.000183136
0.000183129
0.000183125
0.000183123
0.000183122
0.000183121
0.000183121
0.00018312
0.00018312
0.00018312
0.00018312
0.000183119
0.00018312
0.00018312
0.00018312
0.00018312
0.000183121
0.000183121
0.000183121
0.000183121
0.000183122
0.000183122
0.000183122
0.000183122
0.000183123
0.000183123
0.000183124
0.000183125
0.000183126
0.000183128
0.000183129
0.000183131
0.000183132
0.000183134
0.000183135
0.000183136
0.000183137
0.000183138
0.00018314
0.000183141
0.000183142
0.000183143
0.000183144
0.000183145
0.000183146
0.000183147
0.000183148
0.000183149
0.000183149
0.00018315
0.000183151
0.000183152
0.000183153
0.000183153
0.000183154
0.000183155
0.000183156
0.000183157
0.000183157
0.000183158
0.000183159
0.000183159
0.00018316
0.000183161
0.000183162
0.000183162
0.000183163
0.000183163
0.000183164
0.000183165
0.000183165
0.000183166
0.000183166
0.000183167
0.000183168
0.000183168
0.000183168
0.000183169
0.000183169
0.00018317
0.000183171
0.000183171
0.000183171
0.000183172
0.000183172
0.000183172
0.000183173
0.000183173
0.000183173
0.000183174
0.000183174
0.000183174
0.000183174
0.000183175
0.000183175
0.000183175
0.000183175
0.000183175
0.000183175
0.000183175
0.000183175
0.000183175
0.000183175
0.000183174
0.000183173
0.000183171
0.00018317
0.000183168
0.000183167
0.000183166
0.000183164
0.000183163
0.000183162
0.000183161
0.00018316
0.000183158
0.000183157
0.000183156
0.000183154
0.000183158
0.000171461
0.000171454
0.000171451
0.000171449
0.000171447
0.000171446
0.000171446
0.000171445
0.000171445
0.000171445
0.000171445
0.000171445
0.000171444
0.000171445
0.000171445
0.000171445
0.000171445
0.000171445
0.000171446
0.000171446
0.000171446
0.000171446
0.000171447
0.000171447
0.000171447
0.000171447
0.000171448
0.000171449
0.00017145
0.000171451
0.000171452
0.000171453
0.000171455
0.000171456
0.000171457
0.000171458
0.000171459
0.00017146
0.000171461
0.000171462
0.000171463
0.000171464
0.000171465
0.000171466
0.000171467
0.000171468
0.000171469
0.00017147
0.000171471
0.000171471
0.000171472
0.000171473
0.000171474
0.000171474
0.000171475
0.000171476
0.000171476
0.000171477
0.000171478
0.000171478
0.000171479
0.00017148
0.00017148
0.000171481
0.000171482
0.000171482
0.000171483
0.000171483
0.000171484
0.000171485
0.000171485
0.000171486
0.000171486
0.000171487
0.000171487
0.000171488
0.000171488
0.000171489
0.000171489
0.00017149
0.00017149
0.00017149
0.000171491
0.000171491
0.000171491
0.000171492
0.000171492
0.000171492
0.000171493
0.000171493
0.000171493
0.000171493
0.000171493
0.000171494
0.000171494
0.000171494
0.000171494
0.000171494
0.000171494
0.000171494
0.000171494
0.000171494
0.000171494
0.000171494
0.000171493
0.000171492
0.000171491
0.00017149
0.000171488
0.000171487
0.000171486
0.000171485
0.000171484
0.000171483
0.000171482
0.000171481
0.00017148
0.000171479
0.000171477
0.00017148
0.00016005
0.000160044
0.00016004
0.000160038
0.000160038
0.000160037
0.000160035
0.000160036
0.000160035
0.000160035
0.000160034
0.000160035
0.000160035
0.000160034
0.000160035
0.000160035
0.000160034
0.000160036
0.000160036
0.000160036
0.000160036
0.000160036
0.000160036
0.000160036
0.000160038
0.000160038
0.000160038
0.000160038
0.000160039
0.000160039
0.000160041
0.000160042
0.000160042
0.000160045
0.000160045
0.000160046
0.000160046
0.000160049
0.000160049
0.00016005
0.00016005
0.000160051
0.000160053
0.000160054
0.000160054
0.000160055
0.000160055
0.000160057
0.000160058
0.000160058
0.000160059
0.000160059
0.00016006
0.000160062
0.000160062
0.000160062
0.000160063
0.000160063
0.000160064
0.000160064
0.000160066
0.000160066
0.000160067
0.000160067
0.000160067
0.000160068
0.000160068
0.000160069
0.00016007
0.000160071
0.000160071
0.000160071
0.000160072
0.000160072
0.000160072
0.000160073
0.000160073
0.000160073
0.000160075
0.000160075
0.000160075
0.000160076
0.000160076
0.000160076
0.000160076
0.000160076
0.000160077
0.000160077
0.000160077
0.000160077
0.000160077
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160079
0.000160077
0.000160077
0.000160076
0.000160074
0.000160074
0.000160073
0.000160073
0.000160071
0.00016007
0.00016007
0.000160069
0.000160068
0.000160066
0.000160066
0.000160068
0.000148897
0.00014889
0.000148888
0.000148886
0.000148884
0.000148883
0.000148883
0.000148882
0.000148882
0.000148881
0.000148882
0.000148881
0.00014888
0.000148881
0.000148881
0.00014888
0.000148881
0.000148881
0.000148881
0.000148881
0.000148881
0.000148883
0.000148883
0.000148883
0.000148883
0.000148883
0.000148884
0.000148884
0.000148884
0.000148885
0.000148887
0.000148887
0.000148888
0.000148888
0.00014889
0.000148891
0.000148891
0.000148892
0.000148892
0.000148894
0.000148895
0.000148895
0.000148896
0.000148897
0.000148898
0.000148899
0.000148899
0.0001489
0.0001489
0.000148902
0.000148903
0.000148903
0.000148903
0.000148904
0.000148904
0.000148906
0.000148906
0.000148907
0.000148907
0.000148907
0.000148908
0.000148908
0.00014891
0.00014891
0.00014891
0.000148911
0.000148911
0.000148911
0.000148912
0.000148912
0.000148914
0.000148914
0.000148914
0.000148914
0.000148915
0.000148915
0.000148915
0.000148915
0.000148916
0.000148916
0.000148917
0.000148918
0.000148918
0.000148918
0.000148918
0.000148918
0.000148919
0.000148919
0.000148919
0.000148919
0.000148919
0.000148919
0.000148919
0.000148919
0.000148919
0.000148921
0.000148921
0.000148921
0.000148921
0.000148921
0.000148921
0.000148921
0.000148921
0.000148921
0.000148921
0.000148919
0.000148919
0.000148918
0.000148918
0.000148917
0.000148916
0.000148915
0.000148915
0.000148914
0.000148914
0.000148912
0.000148911
0.000148911
0.000148909
0.000148912
0.000137991
0.000137986
0.000137983
0.000137981
0.00013798
0.000137978
0.000137978
0.000137977
0.000137977
0.000137977
0.000137977
0.000137976
0.000137977
0.000137976
0.000137976
0.000137977
0.000137977
0.000137976
0.000137976
0.000137976
0.000137977
0.000137978
0.000137978
0.000137978
0.000137978
0.000137978
0.000137979
0.000137979
0.000137979
0.00013798
0.00013798
0.000137982
0.000137982
0.000137983
0.000137983
0.000137984
0.000137986
0.000137986
0.000137987
0.000137987
0.000137988
0.00013799
0.00013799
0.000137991
0.000137991
0.000137992
0.000137993
0.000137994
0.000137994
0.000137994
0.000137995
0.000137995
0.000137997
0.000137997
0.000137998
0.000137998
0.000137998
0.000138
0.000138
0.000138
0.000138001
0.000138001
0.000138001
0.000138002
0.000138003
0.000138003
0.000138004
0.000138004
0.000138004
0.000138004
0.000138005
0.000138005
0.000138006
0.000138007
0.000138007
0.000138007
0.000138007
0.000138007
0.000138008
0.000138008
0.000138008
0.000138008
0.000138008
0.00013801
0.00013801
0.00013801
0.00013801
0.00013801
0.00013801
0.00013801
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.000138011
0.00013801
0.00013801
0.00013801
0.000138009
0.000138009
0.000138007
0.000138007
0.000138006
0.000138006
0.000138005
0.000138005
0.000138004
0.000138003
0.000138005
0.00012733
0.000127326
0.000127323
0.000127322
0.00012732
0.000127319
0.000127319
0.000127318
0.000127318
0.000127317
0.000127317
0.000127316
0.000127316
0.000127316
0.000127316
0.000127316
0.000127317
0.000127316
0.000127316
0.000127316
0.000127316
0.000127316
0.000127317
0.000127317
0.000127318
0.000127318
0.000127319
0.000127319
0.000127319
0.00012732
0.00012732
0.00012732
0.000127321
0.000127321
0.000127323
0.000127324
0.000127324
0.000127325
0.000127325
0.000127326
0.000127327
0.000127328
0.000127328
0.000127329
0.000127329
0.00012733
0.000127331
0.000127331
0.000127332
0.000127332
0.000127333
0.000127334
0.000127334
0.000127334
0.000127335
0.000127335
0.000127336
0.000127337
0.000127337
0.000127337
0.000127338
0.000127338
0.000127339
0.000127339
0.00012734
0.00012734
0.00012734
0.00012734
0.000127341
0.000127342
0.000127342
0.000127342
0.000127342
0.000127343
0.000127343
0.000127343
0.000127343
0.000127343
0.000127344
0.000127345
0.000127345
0.000127345
0.000127345
0.000127345
0.000127346
0.000127346
0.000127346
0.000127346
0.000127346
0.000127346
0.000127346
0.000127346
0.000127346
0.000127346
0.000127348
0.000127348
0.000127348
0.000127348
0.000127348
0.000127348
0.000127348
0.000127348
0.000127348
0.000127348
0.000127348
0.000127347
0.000127347
0.000127347
0.000127346
0.000127345
0.000127345
0.000127344
0.000127344
0.000127344
0.000127343
0.000127343
0.000127342
0.000127342
0.00012734
0.000127342
0.000116911
0.000116907
0.000116905
0.000116904
0.000116902
0.000116901
0.0001169
0.0001169
0.000116899
0.000116899
0.000116898
0.000116899
0.000116898
0.000116898
0.000116898
0.000116898
0.000116898
0.000116897
0.000116897
0.000116898
0.000116898
0.000116898
0.000116899
0.000116899
0.000116899
0.000116899
0.0001169
0.0001169
0.0001169
0.000116901
0.000116901
0.000116901
0.000116902
0.000116903
0.000116904
0.000116904
0.000116905
0.000116905
0.000116906
0.000116907
0.000116907
0.000116908
0.000116908
0.000116909
0.000116909
0.00011691
0.000116911
0.000116911
0.000116912
0.000116912
0.000116913
0.000116913
0.000116914
0.000116914
0.000116914
0.000116915
0.000116916
0.000116916
0.000116916
0.000116916
0.000116917
0.000116918
0.000116918
0.000116918
0.000116918
0.000116919
0.000116919
0.000116919
0.00011692
0.00011692
0.000116921
0.000116921
0.000116921
0.000116921
0.000116921
0.000116921
0.000116922
0.000116923
0.000116923
0.000116923
0.000116923
0.000116923
0.000116923
0.000116924
0.000116924
0.000116924
0.000116924
0.000116924
0.000116924
0.000116924
0.000116924
0.000116925
0.000116925
0.000116925
0.000116925
0.000116925
0.000116926
0.000116926
0.000116926
0.000116926
0.000116926
0.000116926
0.000116926
0.000116926
0.000116925
0.000116925
0.000116925
0.000116925
0.000116925
0.000116924
0.000116924
0.000116924
0.000116923
0.000116922
0.000116922
0.000116921
0.000116921
0.00011692
0.00011692
0.000116921
0.000106734
0.00010673
0.000106729
0.000106727
0.000106725
0.000106725
0.000106724
0.000106723
0.000106723
0.000106722
0.000106722
0.000106721
0.000106721
0.000106721
0.000106721
0.000106721
0.00010672
0.00010672
0.000106721
0.000106721
0.000106721
0.000106721
0.000106721
0.000106722
0.000106722
0.000106722
0.000106722
0.000106723
0.000106723
0.000106723
0.000106724
0.000106724
0.000106724
0.000106726
0.000106726
0.000106727
0.000106727
0.000106727
0.000106728
0.000106728
0.000106729
0.00010673
0.00010673
0.000106731
0.000106731
0.000106732
0.000106732
0.000106733
0.000106733
0.000106733
0.000106735
0.000106735
0.000106735
0.000106735
0.000106736
0.000106737
0.000106737
0.000106737
0.000106737
0.000106737
0.000106738
0.000106739
0.000106739
0.000106739
0.000106739
0.000106739
0.00010674
0.00010674
0.000106741
0.000106741
0.000106741
0.000106741
0.000106741
0.000106741
0.000106742
0.000106742
0.000106742
0.000106743
0.000106743
0.000106743
0.000106743
0.000106743
0.000106743
0.000106744
0.000106744
0.000106744
0.000106744
0.000106744
0.000106744
0.000106744
0.000106744
0.000106744
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106745
0.000106744
0.000106744
0.000106744
0.000106743
0.000106743
0.000106743
0.000106742
0.000106741
0.000106741
0.00010674
0.000106742
9.68006e-05
9.67978e-05
9.67956e-05
9.67945e-05
9.67934e-05
9.67924e-05
9.67914e-05
9.67905e-05
9.67903e-05
9.67895e-05
9.67888e-05
9.67889e-05
9.67884e-05
9.6788e-05
9.67876e-05
9.67874e-05
9.67879e-05
9.67878e-05
9.67878e-05
9.67878e-05
9.67879e-05
9.6788e-05
9.67882e-05
9.67884e-05
9.67886e-05
9.67888e-05
9.67891e-05
9.67893e-05
9.67896e-05
9.67899e-05
9.67908e-05
9.67912e-05
9.67916e-05
9.67919e-05
9.67924e-05
9.67928e-05
9.67932e-05
9.67936e-05
9.67946e-05
9.67949e-05
9.67954e-05
9.67957e-05
9.67961e-05
9.67964e-05
9.67974e-05
9.67977e-05
9.67981e-05
9.67984e-05
9.67987e-05
9.67995e-05
9.67998e-05
9.68001e-05
9.68003e-05
9.68006e-05
9.68014e-05
9.68016e-05
9.68018e-05
9.68021e-05
9.68022e-05
9.6803e-05
9.68032e-05
9.68034e-05
9.68036e-05
9.68037e-05
9.68039e-05
9.68041e-05
9.68048e-05
9.6805e-05
9.68051e-05
9.68053e-05
9.68054e-05
9.68056e-05
9.68057e-05
9.68058e-05
9.68066e-05
9.68067e-05
9.68068e-05
9.68069e-05
9.68071e-05
9.68072e-05
9.68073e-05
9.68074e-05
9.68076e-05
9.68077e-05
9.68078e-05
9.68079e-05
9.68079e-05
9.6808e-05
9.68081e-05
9.68088e-05
9.68088e-05
9.68089e-05
9.6809e-05
9.6809e-05
9.68091e-05
9.68091e-05
9.68092e-05
9.68092e-05
9.68093e-05
9.68093e-05
9.68093e-05
9.68093e-05
9.68093e-05
9.68092e-05
9.68092e-05
9.68091e-05
9.6809e-05
9.68088e-05
9.68086e-05
9.68084e-05
9.68082e-05
9.68079e-05
9.68076e-05
9.68073e-05
9.6807e-05
9.68067e-05
9.68063e-05
9.6806e-05
9.6805e-05
9.6806e-05
8.71162e-05
8.71139e-05
8.71125e-05
8.71111e-05
8.71097e-05
8.71087e-05
8.71083e-05
8.71074e-05
8.71066e-05
8.71059e-05
8.71057e-05
8.71052e-05
8.71047e-05
8.71043e-05
8.7104e-05
8.71043e-05
8.71042e-05
8.71041e-05
8.71041e-05
8.71041e-05
8.71042e-05
8.71044e-05
8.71045e-05
8.71047e-05
8.71049e-05
8.71051e-05
8.71054e-05
8.71056e-05
8.71059e-05
8.71061e-05
8.71069e-05
8.71072e-05
8.71076e-05
8.71079e-05
8.71083e-05
8.71086e-05
8.7109e-05
8.71093e-05
8.71102e-05
8.71105e-05
8.71109e-05
8.71112e-05
8.71116e-05
8.71119e-05
8.71127e-05
8.7113e-05
8.71133e-05
8.71136e-05
8.71143e-05
8.71146e-05
8.71148e-05
8.71151e-05
8.71153e-05
8.7116e-05
8.71162e-05
8.71164e-05
8.71166e-05
8.71167e-05
8.71169e-05
8.71176e-05
8.71177e-05
8.71179e-05
8.7118e-05
8.71182e-05
8.71183e-05
8.71189e-05
8.71191e-05
8.71192e-05
8.71193e-05
8.71195e-05
8.71196e-05
8.71197e-05
8.71198e-05
8.71199e-05
8.71206e-05
8.71207e-05
8.71208e-05
8.71209e-05
8.7121e-05
8.71211e-05
8.71212e-05
8.71213e-05
8.71214e-05
8.71215e-05
8.71216e-05
8.71217e-05
8.71218e-05
8.71218e-05
8.71219e-05
8.7122e-05
8.7122e-05
8.71226e-05
8.71227e-05
8.71227e-05
8.71228e-05
8.71228e-05
8.71229e-05
8.71229e-05
8.71229e-05
8.71229e-05
8.7123e-05
8.7123e-05
8.71229e-05
8.71229e-05
8.71229e-05
8.71228e-05
8.71227e-05
8.71226e-05
8.71225e-05
8.71223e-05
8.71221e-05
8.71219e-05
8.71216e-05
8.71214e-05
8.71211e-05
8.71208e-05
8.71205e-05
8.71202e-05
8.71193e-05
8.71202e-05
7.76906e-05
7.76888e-05
7.76873e-05
7.76861e-05
7.76848e-05
7.76839e-05
7.76831e-05
7.76822e-05
7.76814e-05
7.76811e-05
7.76805e-05
7.768e-05
7.76796e-05
7.76792e-05
7.7679e-05
7.76788e-05
7.76787e-05
7.76786e-05
7.76786e-05
7.76787e-05
7.76792e-05
7.76793e-05
7.76794e-05
7.76796e-05
7.76798e-05
7.768e-05
7.76802e-05
7.76804e-05
7.76807e-05
7.76809e-05
7.76812e-05
7.76814e-05
7.76821e-05
7.76824e-05
7.76827e-05
7.76831e-05
7.76834e-05
7.76837e-05
7.7684e-05
7.76847e-05
7.7685e-05
7.76853e-05
7.76856e-05
7.76859e-05
7.76865e-05
7.76868e-05
7.76871e-05
7.76873e-05
7.76875e-05
7.76882e-05
7.76884e-05
7.76886e-05
7.76888e-05
7.7689e-05
7.76895e-05
7.76897e-05
7.76899e-05
7.769e-05
7.76902e-05
7.76907e-05
7.76909e-05
7.7691e-05
7.76911e-05
7.76913e-05
7.76914e-05
7.76915e-05
7.7692e-05
7.76921e-05
7.76922e-05
7.76923e-05
7.76925e-05
7.76926e-05
7.76927e-05
7.76928e-05
7.76929e-05
7.7693e-05
7.76931e-05
7.76936e-05
7.76937e-05
7.76938e-05
7.76939e-05
7.76939e-05
7.7694e-05
7.76941e-05
7.76942e-05
7.76943e-05
7.76943e-05
7.76944e-05
7.76944e-05
7.76945e-05
7.76946e-05
7.76946e-05
7.76947e-05
7.76947e-05
7.76948e-05
7.76948e-05
7.76949e-05
7.76949e-05
7.76949e-05
7.76949e-05
7.7695e-05
7.7695e-05
7.7695e-05
7.76949e-05
7.76949e-05
7.76949e-05
7.76948e-05
7.76947e-05
7.76946e-05
7.76944e-05
7.76947e-05
7.76945e-05
7.76943e-05
7.76941e-05
7.76938e-05
7.76936e-05
7.76933e-05
7.76931e-05
7.76924e-05
7.7693e-05
6.85363e-05
6.85347e-05
6.85335e-05
6.85325e-05
6.85314e-05
6.85306e-05
6.85298e-05
6.8529e-05
6.85282e-05
6.85276e-05
6.8527e-05
6.85265e-05
6.85261e-05
6.85258e-05
6.85255e-05
6.85254e-05
6.85253e-05
6.85252e-05
6.85252e-05
6.85253e-05
6.85254e-05
6.85255e-05
6.85256e-05
6.85258e-05
6.8526e-05
6.85262e-05
6.85264e-05
6.85269e-05
6.85271e-05
6.85273e-05
6.85275e-05
6.85278e-05
6.8528e-05
6.85283e-05
6.85289e-05
6.85291e-05
6.85294e-05
6.85297e-05
6.85299e-05
6.85302e-05
6.85308e-05
6.8531e-05
6.85313e-05
6.85315e-05
6.85318e-05
6.85323e-05
6.85326e-05
6.85328e-05
6.8533e-05
6.85332e-05
6.85337e-05
6.85339e-05
6.8534e-05
6.85342e-05
6.85343e-05
6.85348e-05
6.85349e-05
6.85351e-05
6.85352e-05
6.85353e-05
6.85354e-05
6.85359e-05
6.8536e-05
6.85361e-05
6.85362e-05
6.85363e-05
6.85364e-05
6.85365e-05
6.85366e-05
6.8537e-05
6.85371e-05
6.85372e-05
6.85373e-05
6.85373e-05
6.85374e-05
6.85375e-05
6.85376e-05
6.85377e-05
6.85378e-05
6.85379e-05
6.8538e-05
6.8538e-05
6.85381e-05
6.85382e-05
6.85383e-05
6.85383e-05
6.85384e-05
6.85384e-05
6.85385e-05
6.85389e-05
6.85389e-05
6.8539e-05
6.8539e-05
6.85391e-05
6.85391e-05
6.85391e-05
6.85392e-05
6.85392e-05
6.85392e-05
6.85393e-05
6.85393e-05
6.85393e-05
6.85393e-05
6.85393e-05
6.85392e-05
6.85392e-05
6.85392e-05
6.85391e-05
6.8539e-05
6.85389e-05
6.85388e-05
6.85386e-05
6.85384e-05
6.85383e-05
6.85381e-05
6.85378e-05
6.85376e-05
6.85374e-05
6.85371e-05
6.85373e-05
5.9672e-05
5.96711e-05
5.96699e-05
5.96689e-05
5.96679e-05
5.96669e-05
5.96661e-05
5.96653e-05
5.96647e-05
5.9664e-05
5.96633e-05
5.96628e-05
5.96624e-05
5.96622e-05
5.96619e-05
5.96618e-05
5.96617e-05
5.96617e-05
5.96617e-05
5.96617e-05
5.96618e-05
5.96619e-05
5.9662e-05
5.96622e-05
5.96626e-05
5.96628e-05
5.96629e-05
5.96631e-05
5.96633e-05
5.96635e-05
5.96639e-05
5.96641e-05
5.96643e-05
5.96645e-05
5.96648e-05
5.9665e-05
5.96655e-05
5.96657e-05
5.96659e-05
5.96662e-05
5.96664e-05
5.96666e-05
5.96671e-05
5.96673e-05
5.96675e-05
5.96677e-05
5.96679e-05
5.96683e-05
5.96685e-05
5.96686e-05
5.96688e-05
5.9669e-05
5.96694e-05
5.96695e-05
5.96696e-05
5.96698e-05
5.96699e-05
5.96702e-05
5.96703e-05
5.96704e-05
5.96706e-05
5.96707e-05
5.96708e-05
5.96708e-05
5.96712e-05
5.96713e-05
5.96713e-05
5.96714e-05
5.96715e-05
5.96716e-05
5.96717e-05
5.96717e-05
5.96718e-05
5.96719e-05
5.9672e-05
5.9672e-05
5.96721e-05
5.96722e-05
5.96723e-05
5.96726e-05
5.96727e-05
5.96727e-05
5.96728e-05
5.96729e-05
5.96729e-05
5.9673e-05
5.9673e-05
5.96731e-05
5.96731e-05
5.96732e-05
5.96732e-05
5.96733e-05
5.96733e-05
5.96734e-05
5.96734e-05
5.96734e-05
5.96735e-05
5.96735e-05
5.96735e-05
5.96735e-05
5.96736e-05
5.96736e-05
5.96736e-05
5.96736e-05
5.96735e-05
5.96735e-05
5.96735e-05
5.96734e-05
5.96734e-05
5.96733e-05
5.96732e-05
5.96731e-05
5.96729e-05
5.96728e-05
5.96726e-05
5.96724e-05
5.96722e-05
5.96721e-05
5.96718e-05
5.96716e-05
5.11227e-05
5.11221e-05
5.11213e-05
5.11202e-05
5.11192e-05
5.11183e-05
5.11175e-05
5.11168e-05
5.1116e-05
5.11154e-05
5.11149e-05
5.11145e-05
5.11142e-05
5.11138e-05
5.11136e-05
5.11134e-05
5.11134e-05
5.11133e-05
5.11134e-05
5.11134e-05
5.11135e-05
5.11136e-05
5.11137e-05
5.1114e-05
5.11141e-05
5.11143e-05
5.11144e-05
5.11146e-05
5.11149e-05
5.11151e-05
5.11153e-05
5.11154e-05
5.11156e-05
5.1116e-05
5.11161e-05
5.11163e-05
5.11165e-05
5.11167e-05
5.11169e-05
5.11173e-05
5.11175e-05
5.11176e-05
5.11178e-05
5.1118e-05
5.11184e-05
5.11185e-05
5.11187e-05
5.11189e-05
5.1119e-05
5.11193e-05
5.11195e-05
5.11196e-05
5.11197e-05
5.11198e-05
5.11201e-05
5.11203e-05
5.11204e-05
5.11205e-05
5.11205e-05
5.11206e-05
5.11209e-05
5.1121e-05
5.11211e-05
5.11212e-05
5.11212e-05
5.11213e-05
5.11214e-05
5.11214e-05
5.11215e-05
5.11216e-05
5.11216e-05
5.11217e-05
5.11218e-05
5.1122e-05
5.11221e-05
5.11222e-05
5.11222e-05
5.11223e-05
5.11223e-05
5.11224e-05
5.11225e-05
5.11225e-05
5.11226e-05
5.11227e-05
5.11227e-05
5.11228e-05
5.11228e-05
5.11228e-05
5.11229e-05
5.11229e-05
5.1123e-05
5.1123e-05
5.1123e-05
5.11231e-05
5.11231e-05
5.11232e-05
5.11232e-05
5.11232e-05
5.11232e-05
5.11233e-05
5.11233e-05
5.11233e-05
5.11233e-05
5.11231e-05
5.11231e-05
5.11231e-05
5.1123e-05
5.1123e-05
5.11232e-05
5.11231e-05
5.1123e-05
5.11229e-05
5.11228e-05
5.11227e-05
5.11226e-05
5.11224e-05
5.11222e-05
5.11221e-05
5.11219e-05
5.11215e-05
4.29226e-05
4.29221e-05
4.29214e-05
4.29206e-05
4.29197e-05
4.29188e-05
4.29179e-05
4.29173e-05
4.29167e-05
4.29161e-05
4.29156e-05
4.29153e-05
4.29149e-05
4.29146e-05
4.29145e-05
4.29143e-05
4.29143e-05
4.29143e-05
4.29143e-05
4.29143e-05
4.29144e-05
4.29144e-05
4.29145e-05
4.29146e-05
4.29149e-05
4.2915e-05
4.29152e-05
4.29153e-05
4.29154e-05
4.29157e-05
4.29158e-05
4.2916e-05
4.29161e-05
4.29164e-05
4.29165e-05
4.29167e-05
4.29168e-05
4.2917e-05
4.29173e-05
4.29174e-05
4.29176e-05
4.29177e-05
4.29179e-05
4.29182e-05
4.29183e-05
4.29185e-05
4.29186e-05
4.29187e-05
4.2919e-05
4.29191e-05
4.29192e-05
4.29194e-05
4.29194e-05
4.29197e-05
4.29198e-05
4.29199e-05
4.292e-05
4.292e-05
4.29201e-05
4.29202e-05
4.29204e-05
4.29205e-05
4.29206e-05
4.29206e-05
4.29207e-05
4.29207e-05
4.29208e-05
4.29209e-05
4.29209e-05
4.2921e-05
4.2921e-05
4.29211e-05
4.29211e-05
4.29212e-05
4.29212e-05
4.29213e-05
4.29213e-05
4.29214e-05
4.29215e-05
4.29215e-05
4.29216e-05
4.29216e-05
4.29217e-05
4.29217e-05
4.29218e-05
4.29218e-05
4.29219e-05
4.29219e-05
4.29219e-05
4.2922e-05
4.2922e-05
4.2922e-05
4.29221e-05
4.29221e-05
4.29221e-05
4.29222e-05
4.29222e-05
4.29222e-05
4.29222e-05
4.29223e-05
4.29223e-05
4.29223e-05
4.29223e-05
4.29223e-05
4.29223e-05
4.29223e-05
4.29223e-05
4.29222e-05
4.29222e-05
4.29222e-05
4.29221e-05
4.2922e-05
4.29219e-05
4.29219e-05
4.29217e-05
4.29216e-05
4.29215e-05
4.29214e-05
4.29212e-05
4.29208e-05
3.51178e-05
3.51177e-05
3.5117e-05
3.51163e-05
3.51154e-05
3.51146e-05
3.51139e-05
3.51133e-05
3.51127e-05
3.51122e-05
3.51118e-05
3.51115e-05
3.51111e-05
3.51109e-05
3.51108e-05
3.51107e-05
3.51106e-05
3.51106e-05
3.51106e-05
3.51106e-05
3.51107e-05
3.51107e-05
3.51108e-05
3.5111e-05
3.51111e-05
3.51112e-05
3.51114e-05
3.51115e-05
3.51116e-05
3.51117e-05
3.51119e-05
3.5112e-05
3.51121e-05
3.51122e-05
3.51125e-05
3.51126e-05
3.51127e-05
3.51128e-05
3.51131e-05
3.51132e-05
3.51133e-05
3.51134e-05
3.51136e-05
3.51137e-05
3.51139e-05
3.5114e-05
3.51141e-05
3.51142e-05
3.51143e-05
3.51145e-05
3.51146e-05
3.51147e-05
3.51148e-05
3.51149e-05
3.5115e-05
3.51151e-05
3.51152e-05
3.51153e-05
3.51153e-05
3.51154e-05
3.51155e-05
3.51155e-05
3.51156e-05
3.51156e-05
3.51157e-05
3.51157e-05
3.51158e-05
3.51158e-05
3.51159e-05
3.51159e-05
3.5116e-05
3.5116e-05
3.51161e-05
3.51161e-05
3.51162e-05
3.51162e-05
3.51162e-05
3.51163e-05
3.51163e-05
3.51164e-05
3.51164e-05
3.51165e-05
3.51165e-05
3.51166e-05
3.51166e-05
3.51166e-05
3.51167e-05
3.51167e-05
3.51167e-05
3.51168e-05
3.51168e-05
3.51168e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.5117e-05
3.5117e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.5117e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.51169e-05
3.51168e-05
3.51168e-05
3.51167e-05
3.51166e-05
3.51166e-05
3.51165e-05
3.51164e-05
3.51163e-05
3.51162e-05
3.51158e-05
2.77725e-05
2.77725e-05
2.77719e-05
2.77712e-05
2.77706e-05
2.77699e-05
2.77693e-05
2.77687e-05
2.77682e-05
2.77678e-05
2.77674e-05
2.77672e-05
2.77669e-05
2.77667e-05
2.77666e-05
2.77665e-05
2.77664e-05
2.77664e-05
2.77664e-05
2.77664e-05
2.77665e-05
2.77666e-05
2.77666e-05
2.77667e-05
2.77668e-05
2.7767e-05
2.7767e-05
2.77671e-05
2.77673e-05
2.77674e-05
2.77674e-05
2.77676e-05
2.77677e-05
2.77678e-05
2.77678e-05
2.7768e-05
2.77681e-05
2.77682e-05
2.77683e-05
2.77684e-05
2.77686e-05
2.77687e-05
2.77688e-05
2.77689e-05
2.77689e-05
2.77691e-05
2.77692e-05
2.77693e-05
2.77694e-05
2.77695e-05
2.77695e-05
2.77696e-05
2.77697e-05
2.77698e-05
2.77699e-05
2.77699e-05
2.777e-05
2.777e-05
2.77701e-05
2.77701e-05
2.77702e-05
2.77702e-05
2.77703e-05
2.77703e-05
2.77704e-05
2.77704e-05
2.77705e-05
2.77705e-05
2.77705e-05
2.77706e-05
2.77706e-05
2.77707e-05
2.77707e-05
2.77707e-05
2.77708e-05
2.77708e-05
2.77708e-05
2.77709e-05
2.77709e-05
2.7771e-05
2.7771e-05
2.7771e-05
2.7771e-05
2.7771e-05
2.77711e-05
2.77711e-05
2.77711e-05
2.77712e-05
2.77712e-05
2.77712e-05
2.77712e-05
2.77713e-05
2.77713e-05
2.77713e-05
2.77713e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77713e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77714e-05
2.77713e-05
2.77713e-05
2.77713e-05
2.77712e-05
2.77712e-05
2.77711e-05
2.7771e-05
2.7771e-05
2.77709e-05
2.77708e-05
2.77704e-05
2.09767e-05
2.09767e-05
2.09762e-05
2.09757e-05
2.09751e-05
2.09746e-05
2.0974e-05
2.09736e-05
2.09732e-05
2.09729e-05
2.09726e-05
2.09723e-05
2.09722e-05
2.0972e-05
2.09719e-05
2.09718e-05
2.09718e-05
2.09718e-05
2.09718e-05
2.09718e-05
2.09718e-05
2.09719e-05
2.09719e-05
2.0972e-05
2.09721e-05
2.09722e-05
2.09723e-05
2.09723e-05
2.09724e-05
2.09725e-05
2.09725e-05
2.09727e-05
2.09727e-05
2.09728e-05
2.09728e-05
2.0973e-05
2.0973e-05
2.09731e-05
2.09732e-05
2.09733e-05
2.09733e-05
2.09735e-05
2.09735e-05
2.09736e-05
2.09737e-05
2.09737e-05
2.09738e-05
2.09739e-05
2.0974e-05
2.09741e-05
2.09741e-05
2.09742e-05
2.09742e-05
2.09743e-05
2.09743e-05
2.09744e-05
2.09744e-05
2.09745e-05
2.09745e-05
2.09745e-05
2.09746e-05
2.09746e-05
2.09747e-05
2.09747e-05
2.09747e-05
2.09748e-05
2.09748e-05
2.09748e-05
2.09749e-05
2.09749e-05
2.09749e-05
2.0975e-05
2.09749e-05
2.0975e-05
2.0975e-05
2.0975e-05
2.09751e-05
2.09751e-05
2.09751e-05
2.09752e-05
2.09752e-05
2.09752e-05
2.09752e-05
2.09752e-05
2.09753e-05
2.09753e-05
2.09753e-05
2.09753e-05
2.09753e-05
2.09754e-05
2.09754e-05
2.09754e-05
2.09754e-05
2.09754e-05
2.09755e-05
2.09754e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09755e-05
2.09754e-05
2.09754e-05
2.09754e-05
2.09753e-05
2.09752e-05
2.09752e-05
2.09751e-05
2.09747e-05
1.48582e-05
1.48582e-05
1.48579e-05
1.48574e-05
1.4857e-05
1.48566e-05
1.48562e-05
1.48559e-05
1.48556e-05
1.48553e-05
1.48551e-05
1.48549e-05
1.48548e-05
1.48547e-05
1.48546e-05
1.48546e-05
1.48545e-05
1.48545e-05
1.48545e-05
1.48545e-05
1.48545e-05
1.48546e-05
1.48546e-05
1.48547e-05
1.48547e-05
1.48548e-05
1.48548e-05
1.48549e-05
1.48549e-05
1.4855e-05
1.4855e-05
1.48551e-05
1.48552e-05
1.48552e-05
1.48552e-05
1.48553e-05
1.48553e-05
1.48554e-05
1.48555e-05
1.48555e-05
1.48556e-05
1.48556e-05
1.48557e-05
1.48558e-05
1.48558e-05
1.48559e-05
1.48559e-05
1.4856e-05
1.4856e-05
1.48561e-05
1.48561e-05
1.48562e-05
1.48562e-05
1.48563e-05
1.48563e-05
1.48563e-05
1.48564e-05
1.48564e-05
1.48564e-05
1.48565e-05
1.48565e-05
1.48565e-05
1.48565e-05
1.48565e-05
1.48566e-05
1.48566e-05
1.48566e-05
1.48567e-05
1.48567e-05
1.48567e-05
1.48567e-05
1.48567e-05
1.48567e-05
1.48568e-05
1.48568e-05
1.48568e-05
1.48568e-05
1.48568e-05
1.48569e-05
1.48569e-05
1.48569e-05
1.48569e-05
1.4857e-05
1.4857e-05
1.4857e-05
1.4857e-05
1.4857e-05
1.4857e-05
1.4857e-05
1.4857e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48572e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.48571e-05
1.4857e-05
1.4857e-05
1.48569e-05
1.48569e-05
1.48566e-05
9.59507e-06
9.59507e-06
9.59485e-06
9.59457e-06
9.59429e-06
9.59402e-06
9.59375e-06
9.59352e-06
9.5933e-06
9.59312e-06
9.59297e-06
9.59285e-06
9.59275e-06
9.59269e-06
9.59263e-06
9.59258e-06
9.59256e-06
9.59254e-06
9.59255e-06
9.59255e-06
9.59257e-06
9.59258e-06
9.5926e-06
9.59264e-06
9.59267e-06
9.59271e-06
9.59275e-06
9.59277e-06
9.59282e-06
9.59285e-06
9.59288e-06
9.59292e-06
9.59296e-06
9.59298e-06
9.59301e-06
9.59305e-06
9.59308e-06
9.59313e-06
9.59317e-06
9.59321e-06
9.59324e-06
9.59328e-06
9.59332e-06
9.59336e-06
9.59339e-06
9.59343e-06
9.59347e-06
9.59351e-06
9.59354e-06
9.59357e-06
9.5936e-06
9.59363e-06
9.59364e-06
9.59367e-06
9.59369e-06
9.59372e-06
9.59374e-06
9.59377e-06
9.5938e-06
9.59382e-06
9.59384e-06
9.59384e-06
9.59386e-06
9.59388e-06
9.5939e-06
9.59392e-06
9.59394e-06
9.59394e-06
9.59396e-06
9.59398e-06
9.59399e-06
9.59401e-06
9.59401e-06
9.59402e-06
9.59404e-06
9.59406e-06
9.59408e-06
9.59409e-06
9.59409e-06
9.59411e-06
9.59413e-06
9.59415e-06
9.59416e-06
9.59418e-06
9.59418e-06
9.59419e-06
9.5942e-06
9.59421e-06
9.59422e-06
9.59423e-06
9.59424e-06
9.59424e-06
9.59425e-06
9.59426e-06
9.59428e-06
9.59429e-06
9.5943e-06
9.59431e-06
9.5943e-06
9.59431e-06
9.59431e-06
9.59432e-06
9.59433e-06
9.59434e-06
9.59434e-06
9.59434e-06
9.59434e-06
9.59433e-06
9.59433e-06
9.59432e-06
9.59432e-06
9.59431e-06
9.5943e-06
9.59428e-06
9.59426e-06
9.59424e-06
9.59421e-06
9.59418e-06
9.59417e-06
9.59394e-06
5.41042e-06
5.41043e-06
5.41032e-06
5.41018e-06
5.41001e-06
5.40986e-06
5.4097e-06
5.40955e-06
5.40942e-06
5.40931e-06
5.40922e-06
5.40915e-06
5.40909e-06
5.40904e-06
5.40901e-06
5.40898e-06
5.40896e-06
5.40894e-06
5.40894e-06
5.40895e-06
5.40895e-06
5.40897e-06
5.40897e-06
5.409e-06
5.40901e-06
5.40903e-06
5.40906e-06
5.40907e-06
5.40909e-06
5.40911e-06
5.40913e-06
5.40915e-06
5.40917e-06
5.40919e-06
5.4092e-06
5.40922e-06
5.40924e-06
5.40927e-06
5.40929e-06
5.40931e-06
5.40933e-06
5.40936e-06
5.40938e-06
5.4094e-06
5.40943e-06
5.40945e-06
5.40947e-06
5.4095e-06
5.40951e-06
5.40952e-06
5.40954e-06
5.40956e-06
5.40957e-06
5.40959e-06
5.4096e-06
5.40962e-06
5.40963e-06
5.40965e-06
5.40967e-06
5.40967e-06
5.40968e-06
5.4097e-06
5.40971e-06
5.40971e-06
5.40973e-06
5.40974e-06
5.40975e-06
5.40976e-06
5.40977e-06
5.40978e-06
5.40979e-06
5.4098e-06
5.4098e-06
5.40981e-06
5.40982e-06
5.40983e-06
5.40984e-06
5.40985e-06
5.40986e-06
5.40987e-06
5.40988e-06
5.40988e-06
5.4099e-06
5.40991e-06
5.40992e-06
5.40992e-06
5.40992e-06
5.40993e-06
5.40993e-06
5.40994e-06
5.40994e-06
5.40995e-06
5.40995e-06
5.40996e-06
5.40997e-06
5.40997e-06
5.40998e-06
5.40998e-06
5.40999e-06
5.40999e-06
5.41e-06
5.41e-06
5.41001e-06
5.41001e-06
5.41001e-06
5.41001e-06
5.41001e-06
5.41001e-06
5.41001e-06
5.41001e-06
5.41001e-06
5.41e-06
5.41e-06
5.40999e-06
5.40998e-06
5.40997e-06
5.40995e-06
5.40993e-06
5.40993e-06
5.40979e-06
2.50226e-06
2.50227e-06
2.50225e-06
2.50217e-06
2.5021e-06
2.50202e-06
2.50194e-06
2.50187e-06
2.5018e-06
2.50177e-06
2.50173e-06
2.50169e-06
2.50165e-06
2.50163e-06
2.5016e-06
2.50159e-06
2.50157e-06
2.50156e-06
2.50156e-06
2.50156e-06
2.50156e-06
2.50156e-06
2.50156e-06
2.5016e-06
2.50161e-06
2.50162e-06
2.50163e-06
2.50163e-06
2.50164e-06
2.50165e-06
2.50166e-06
2.50167e-06
2.50168e-06
2.50169e-06
2.50169e-06
2.5017e-06
2.50171e-06
2.50172e-06
2.50173e-06
2.50175e-06
2.50176e-06
2.50177e-06
2.50178e-06
2.50179e-06
2.5018e-06
2.50182e-06
2.50183e-06
2.50184e-06
2.50182e-06
2.50183e-06
2.50183e-06
2.50184e-06
2.50185e-06
2.50186e-06
2.50187e-06
2.50188e-06
2.50189e-06
2.50189e-06
2.5019e-06
2.50191e-06
2.50192e-06
2.50192e-06
2.50193e-06
2.50194e-06
2.50194e-06
2.50195e-06
2.50196e-06
2.50196e-06
2.50197e-06
2.50197e-06
2.50198e-06
2.50198e-06
2.50199e-06
2.50199e-06
2.502e-06
2.502e-06
2.50201e-06
2.50202e-06
2.50202e-06
2.50203e-06
2.50203e-06
2.50204e-06
2.50204e-06
2.50205e-06
2.50205e-06
2.50206e-06
2.50206e-06
2.50204e-06
2.50204e-06
2.50204e-06
2.50204e-06
2.50205e-06
2.50205e-06
2.50205e-06
2.50206e-06
2.50206e-06
2.50207e-06
2.50207e-06
2.50207e-06
2.50208e-06
2.50208e-06
2.50208e-06
2.50208e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50209e-06
2.50208e-06
2.50208e-06
2.50207e-06
2.50206e-06
2.50206e-06
2.50205e-06
2.502e-06
8.72923e-07
8.72936e-07
8.72933e-07
8.72915e-07
8.72889e-07
8.7286e-07
8.7283e-07
8.72802e-07
8.72785e-07
8.72766e-07
8.72748e-07
8.72733e-07
8.7272e-07
8.72709e-07
8.72701e-07
8.72694e-07
8.72689e-07
8.72685e-07
8.72683e-07
8.72682e-07
8.72689e-07
8.7269e-07
8.72691e-07
8.72695e-07
8.72699e-07
8.72702e-07
8.72705e-07
8.72708e-07
8.72711e-07
8.72714e-07
8.72717e-07
8.7272e-07
8.72723e-07
8.72727e-07
8.7273e-07
8.72733e-07
8.72736e-07
8.7274e-07
8.72744e-07
8.72748e-07
8.72752e-07
8.72757e-07
8.72761e-07
8.72766e-07
8.7277e-07
8.72774e-07
8.72778e-07
8.72783e-07
8.72785e-07
8.72779e-07
8.72782e-07
8.72786e-07
8.72789e-07
8.72793e-07
8.72796e-07
8.72799e-07
8.72802e-07
8.72805e-07
8.72808e-07
8.72811e-07
8.72813e-07
8.72816e-07
8.72818e-07
8.7282e-07
8.72823e-07
8.72825e-07
8.72828e-07
8.7283e-07
8.72832e-07
8.72834e-07
8.72837e-07
8.72839e-07
8.72841e-07
8.72843e-07
8.72844e-07
8.72847e-07
8.72849e-07
8.72851e-07
8.72853e-07
8.72855e-07
8.72857e-07
8.7286e-07
8.72862e-07
8.72864e-07
8.72866e-07
8.72867e-07
8.72869e-07
8.72861e-07
8.7286e-07
8.72861e-07
8.72863e-07
8.72864e-07
8.72866e-07
8.72867e-07
8.72869e-07
8.7287e-07
8.72872e-07
8.72873e-07
8.72874e-07
8.72875e-07
8.72876e-07
8.72877e-07
8.72878e-07
8.7288e-07
8.7288e-07
8.72881e-07
8.72881e-07
8.72882e-07
8.72882e-07
8.72882e-07
8.72882e-07
8.72881e-07
8.72881e-07
8.72879e-07
8.72878e-07
8.72876e-07
8.72873e-07
8.7287e-07
8.72869e-07
8.72851e-07
2.05141e-07
2.05146e-07
2.05148e-07
2.05144e-07
2.05137e-07
2.0513e-07
2.05123e-07
2.05116e-07
2.05111e-07
2.05106e-07
2.05102e-07
2.05098e-07
2.05095e-07
2.05092e-07
2.0509e-07
2.05089e-07
2.05088e-07
2.05087e-07
2.05087e-07
2.05086e-07
2.05087e-07
2.05087e-07
2.05087e-07
2.05088e-07
2.05089e-07
2.0509e-07
2.05091e-07
2.05091e-07
2.05092e-07
2.05093e-07
2.05093e-07
2.05094e-07
2.05095e-07
2.05096e-07
2.05096e-07
2.05097e-07
2.05098e-07
2.05099e-07
2.051e-07
2.05101e-07
2.05102e-07
2.05103e-07
2.05104e-07
2.05105e-07
2.05106e-07
2.05107e-07
2.05108e-07
2.05109e-07
2.0511e-07
2.0511e-07
2.0511e-07
2.05111e-07
2.05112e-07
2.05113e-07
2.05114e-07
2.05114e-07
2.05115e-07
2.05115e-07
2.05116e-07
2.05116e-07
2.05117e-07
2.05117e-07
2.05118e-07
2.05119e-07
2.05119e-07
2.0512e-07
2.0512e-07
2.05121e-07
2.05122e-07
2.05122e-07
2.05123e-07
2.05123e-07
2.05124e-07
2.05124e-07
2.05125e-07
2.05125e-07
2.05126e-07
2.05126e-07
2.05127e-07
2.05127e-07
2.05128e-07
2.05128e-07
2.05129e-07
2.05129e-07
2.0513e-07
2.0513e-07
2.05131e-07
2.0513e-07
2.0513e-07
2.0513e-07
2.0513e-07
2.05131e-07
2.05131e-07
2.05131e-07
2.05132e-07
2.05132e-07
2.05133e-07
2.05133e-07
2.05133e-07
2.05133e-07
2.05134e-07
2.05134e-07
2.05134e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05135e-07
2.05134e-07
2.05134e-07
2.05133e-07
2.05132e-07
2.05132e-07
2.05128e-07
2.67914e-08
2.67923e-08
2.67925e-08
2.6792e-08
2.67912e-08
2.67903e-08
2.67893e-08
2.67884e-08
2.67878e-08
2.67871e-08
2.67866e-08
2.67861e-08
2.67857e-08
2.67853e-08
2.6785e-08
2.67848e-08
2.67847e-08
2.67846e-08
2.67845e-08
2.67844e-08
2.67845e-08
2.67845e-08
2.67845e-08
2.67846e-08
2.67848e-08
2.67849e-08
2.6785e-08
2.67851e-08
2.67851e-08
2.67852e-08
2.67853e-08
2.67854e-08
2.67855e-08
2.67856e-08
2.67857e-08
2.67858e-08
2.67859e-08
2.67861e-08
2.67862e-08
2.67863e-08
2.67864e-08
2.67866e-08
2.67867e-08
2.67869e-08
2.6787e-08
2.67871e-08
2.67873e-08
2.67874e-08
2.67875e-08
2.67875e-08
2.67876e-08
2.67877e-08
2.67878e-08
2.67879e-08
2.6788e-08
2.67881e-08
2.67882e-08
2.67883e-08
2.67884e-08
2.67885e-08
2.67885e-08
2.67886e-08
2.67887e-08
2.67888e-08
2.67888e-08
2.67889e-08
2.6789e-08
2.67891e-08
2.67891e-08
2.67892e-08
2.67893e-08
2.67894e-08
2.67894e-08
2.67895e-08
2.67896e-08
2.67896e-08
2.67897e-08
2.67898e-08
2.67898e-08
2.67899e-08
2.679e-08
2.679e-08
2.67901e-08
2.67902e-08
2.67902e-08
2.67902e-08
2.67903e-08
2.67902e-08
2.67902e-08
2.67902e-08
2.67902e-08
2.67903e-08
2.67903e-08
2.67904e-08
2.67904e-08
2.67905e-08
2.67905e-08
2.67906e-08
2.67906e-08
2.67907e-08
2.67907e-08
2.67907e-08
2.67908e-08
2.67908e-08
2.67908e-08
2.67908e-08
2.67909e-08
2.67909e-08
2.67909e-08
2.67909e-08
2.67909e-08
2.67909e-08
2.67909e-08
2.67908e-08
2.67908e-08
2.67907e-08
2.67906e-08
2.67905e-08
2.67905e-08
2.67899e-08
1.25311e-09
1.25315e-09
1.25316e-09
1.25314e-09
1.2531e-09
1.25306e-09
1.25301e-09
1.25297e-09
1.25294e-09
1.25291e-09
1.25288e-09
1.25286e-09
1.25284e-09
1.25282e-09
1.25281e-09
1.2528e-09
1.25279e-09
1.25279e-09
1.25278e-09
1.25278e-09
1.25278e-09
1.25279e-09
1.25279e-09
1.25279e-09
1.2528e-09
1.2528e-09
1.25281e-09
1.25281e-09
1.25282e-09
1.25282e-09
1.25282e-09
1.25283e-09
1.25283e-09
1.25284e-09
1.25284e-09
1.25285e-09
1.25285e-09
1.25286e-09
1.25286e-09
1.25287e-09
1.25288e-09
1.25288e-09
1.25289e-09
1.2529e-09
1.2529e-09
1.25291e-09
1.25291e-09
1.25292e-09
1.25292e-09
1.25293e-09
1.25293e-09
1.25293e-09
1.25294e-09
1.25294e-09
1.25295e-09
1.25295e-09
1.25296e-09
1.25296e-09
1.25297e-09
1.25297e-09
1.25297e-09
1.25298e-09
1.25298e-09
1.25298e-09
1.25299e-09
1.25299e-09
1.253e-09
1.253e-09
1.253e-09
1.25301e-09
1.25301e-09
1.25301e-09
1.25302e-09
1.25302e-09
1.25302e-09
1.25303e-09
1.25303e-09
1.25303e-09
1.25303e-09
1.25304e-09
1.25304e-09
1.25304e-09
1.25305e-09
1.25305e-09
1.25305e-09
1.25306e-09
1.25306e-09
1.25305e-09
1.25305e-09
1.25305e-09
1.25306e-09
1.25306e-09
1.25306e-09
1.25306e-09
1.25307e-09
1.25307e-09
1.25307e-09
1.25307e-09
1.25307e-09
1.25308e-09
1.25308e-09
1.25308e-09
1.25308e-09
1.25308e-09
1.25308e-09
1.25308e-09
1.25309e-09
1.25309e-09
1.25309e-09
1.25309e-09
1.25309e-09
1.25309e-09
1.25308e-09
1.25308e-09
1.25308e-09
1.25308e-09
1.25307e-09
1.25307e-09
1.25307e-09
1.25304e-09
7.20642e-12
7.20669e-12
7.20674e-12
7.2066e-12
7.20638e-12
7.20613e-12
7.20588e-12
7.20564e-12
7.20544e-12
7.20528e-12
7.20513e-12
7.20499e-12
7.20488e-12
7.20478e-12
7.2047e-12
7.20465e-12
7.20461e-12
7.20458e-12
7.20455e-12
7.20454e-12
7.20455e-12
7.20456e-12
7.20457e-12
7.2046e-12
7.20463e-12
7.20466e-12
7.20469e-12
7.20471e-12
7.20474e-12
7.20476e-12
7.20478e-12
7.20481e-12
7.20484e-12
7.20487e-12
7.20489e-12
7.20492e-12
7.20495e-12
7.20498e-12
7.20502e-12
7.20505e-12
7.20509e-12
7.20512e-12
7.20516e-12
7.2052e-12
7.20523e-12
7.20527e-12
7.20531e-12
7.20535e-12
7.20537e-12
7.20537e-12
7.20539e-12
7.20542e-12
7.20545e-12
7.20548e-12
7.20551e-12
7.20553e-12
7.20556e-12
7.20558e-12
7.2056e-12
7.20563e-12
7.20565e-12
7.20567e-12
7.20569e-12
7.20571e-12
7.20573e-12
7.20575e-12
7.20578e-12
7.2058e-12
7.20581e-12
7.20583e-12
7.20585e-12
7.20587e-12
7.20589e-12
7.20591e-12
7.20592e-12
7.20594e-12
7.20596e-12
7.20598e-12
7.206e-12
7.20602e-12
7.20603e-12
7.20605e-12
7.20607e-12
7.20609e-12
7.2061e-12
7.20612e-12
7.20613e-12
7.20611e-12
7.2061e-12
7.20611e-12
7.20612e-12
7.20614e-12
7.20615e-12
7.20616e-12
7.20618e-12
7.20619e-12
7.2062e-12
7.20622e-12
7.20623e-12
7.20623e-12
7.20624e-12
7.20625e-12
7.20626e-12
7.20627e-12
7.20628e-12
7.20628e-12
7.20629e-12
7.20629e-12
7.20629e-12
7.2063e-12
7.2063e-12
7.20629e-12
7.20629e-12
7.20628e-12
7.20626e-12
7.20625e-12
7.20623e-12
7.2062e-12
7.20619e-12
7.20604e-12
)
;
boundaryField
{
bottomWall
{
type nutUWallFunction;
Cmu 0.09;
kappa 0.41;
E 9.8;
value nonuniform 0();
}
topWall
{
type nutUWallFunction;
Cmu 0.09;
kappa 0.41;
E 9.8;
value uniform 0;
}
sides1_half0
{
type cyclic;
}
sides1_half1
{
type cyclic;
}
sides2_half0
{
type cyclic;
}
sides2_half1
{
type cyclic;
}
inout1_half0
{
type cyclic;
}
inout1_half1
{
type cyclic;
}
inout2_half0
{
type cyclic;
}
inout2_half1
{
type cyclic;
}
procBoundary0to1
{
type processor;
value nonuniform List<scalar>
122
(
0.000287827
0.000287824
0.000287826
0.000287828
0.000287831
0.000287833
0.000287835
0.000287837
0.000287839
0.000287841
0.000287842
0.000287844
0.000287846
0.000287847
0.000287849
0.00028785
0.000287851
0.000287852
0.000287853
0.000287855
0.000287856
0.000287857
0.000287858
0.000287859
0.00028786
0.000287861
0.000287862
0.000287863
0.000287864
0.000287865
0.000287867
0.000287868
0.000287868
0.00028787
0.000287871
0.000287872
0.000287873
0.000287874
0.000287875
0.000287876
0.000287877
0.000287878
0.000287879
0.00028788
0.000287881
0.000287882
0.000287883
0.000287884
0.000287885
0.000287886
0.000287887
0.000287887
0.000287888
0.000287889
0.00028789
0.000287891
0.000287891
0.000287892
0.000287893
0.000287893
0.000287894
0.000287895
0.000287895
0.000287895
0.000287896
0.000287897
0.000287897
0.000287897
0.000287897
0.000287898
0.000287898
0.000287898
0.000287898
0.000287898
0.000287898
0.000287898
0.000287898
0.000273442
0.000273436
0.000273434
0.000273433
0.000273433
0.000273433
0.000273433
0.000273433
0.000273433
0.000273433
0.000273432
0.000273433
0.000273433
0.000273433
0.000273433
0.000273433
0.000273434
0.000273434
0.000273435
0.000273435
0.000273435
0.000273435
0.000273435
0.000273435
0.000273435
0.000273503
0.000273503
0.000273503
0.000273501
0.000273499
0.000273496
0.000273494
0.000273492
0.000273489
0.000273487
0.000273485
0.000273483
0.000273481
0.000273479
0.000273476
0.000273475
0.000273473
0.000273471
0.000273468
0.000273471
)
;
}
}
// ************************************************************************* //
| [
"dikshant.sud@gmail.com"
] | dikshant.sud@gmail.com | |
a84ea2c71a6be742f5eaca8d7d16357b2cc7d812 | b7dd7ddf80a2468244bf9479ee0916d3298629ed | /course_work/me537/project/simulation/ros_packages/pr2_teleop_hack/src/teleop_pr2_keyboard.cpp | 49defba444296f5701e0fc7a8ddc1cb490df00c2 | [] | no_license | kckemper/kemper | 5550e3a0ce1814bd8963ca97cb4d7bacbb3fdbe8 | a1c33d19363fa2a60f61a69d21b3dec6a2bddbad | refs/heads/master | 2021-01-10T08:49:26.918463 | 2012-09-21T18:30:50 | 2012-09-21T18:30:50 | 52,307,308 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,764 | cpp | #include <termios.h>
#include <signal.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#define KEYCODE_A 0x61
#define KEYCODE_S 0x73
#define KEYCODE_D 0x64
#define KEYCODE_F 0x66
#define KEYCODE_J 0x6A
#define KEYCODE_K 0x6B
#define KEYCODE_L 0x6C
#define KEYCODE_SEMI 0x3B
class TeleopPR2Keyboard
{
private:
double walk_vel, run_vel, yaw_rate, yaw_rate_run;
geometry_msgs::Twist cmd;
ros::NodeHandle n_;
ros::Publisher vel_pub_;
public:
void init()
{
cmd.linear.x = cmd.linear.y = cmd.angular.z = 0;
vel_pub_ = n_.advertise<geometry_msgs::Twist>("cmd_vel", 1);
ros::NodeHandle n_private("~");
n_private.param("walk_vel", walk_vel, 0.5);
n_private.param("run_vel", run_vel, 1.0);
n_private.param("yaw_rate", yaw_rate, 1.0);
n_private.param("yaw_run_rate", yaw_rate_run, 1.5);
}
~TeleopPR2Keyboard() { }
void keyboardLoop();
};
int kfd = 0;
struct termios cooked, raw;
void quit(int sig)
{
tcsetattr(kfd, TCSANOW, &cooked);
exit(0);
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "pr2_base_keyboard");
TeleopPR2Keyboard tpk;
tpk.init();
signal(SIGINT,quit);
tpk.keyboardLoop();
return(0);
}
void TeleopPR2Keyboard::keyboardLoop()
{
char c;
bool dirty=false;
// get the console in raw mode
tcgetattr(kfd, &cooked);
memcpy(&raw, &cooked, sizeof(struct termios));
raw.c_lflag &=~ (ICANON | ECHO);
// Setting a new line, then end of file
raw.c_cc[VEOL] = 1;
raw.c_cc[VEOF] = 2;
tcsetattr(kfd, TCSANOW, &raw);
puts("Reading from keyboard");
puts("---------------------------");
puts("Use 'WASD' to translate");
puts("Use 'QE' to yaw");
puts("Press 'Shift' to run");
cmd.linear.x = walk_vel;
cmd.linear.y = cmd.angular.z = 0;
for(;;)
{
// get the next event from the keyboard
if(read(kfd, &c, 1) < 0)
{
perror("read():");
exit(-1);
}
switch(c)
{
case KEYCODE_A:
cmd.angular.z = 2.;
dirty = true;
break;
case KEYCODE_S:
cmd.angular.z = 1.;
dirty = true;
break;
case KEYCODE_D:
cmd.angular.z = 0.5;
dirty = true;
break;
case KEYCODE_F:
cmd.angular.z = 0.;
dirty = true;
break;
case KEYCODE_J:
cmd.angular.z = 0.;
dirty = true;
break;
case KEYCODE_K:
cmd.angular.z = -0.5;
dirty = true;
break;
case KEYCODE_L:
cmd.angular.z = -1.0;
dirty = true;
break;
case KEYCODE_SEMI:
cmd.angular.z = -2.0;
dirty = true;
break;
}
// cmd.angular.z = min(3., max(-3., cmd.angular.z));
if (dirty == true)
{
vel_pub_.publish(cmd);
}
}
}
| [
"kkemper@f5c5be9c-040c-f34b-f993-a0493b5d6c12"
] | kkemper@f5c5be9c-040c-f34b-f993-a0493b5d6c12 |
e9e870a9837726a942297729ef547d76ce46d542 | 4c0b65ce5a4de999b5fded57a5334637bb80d4c3 | /src/util.cpp | d0dab44bfd3afdf165a8d94c1857d64f19ac2cb7 | [] | no_license | RrunkXu/affine-patch-matching | a906d1f6478ad1c2b7bb79ae4c48fc5e5f771627 | b393cf73c95c8cd7f4cd3e0e88feecd9c7189715 | refs/heads/master | 2020-09-16T19:18:06.275351 | 2015-11-21T14:25:34 | 2015-11-21T14:25:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,664 | cpp | #include "util.hpp"
void Util::ComputeHomographyFromCameraPose(const Matx33d& int_mat,
const Pose& pose,
Matx33d& homography) {
auto p = int_mat * pose.mat();
homography = Matx33d::zeros();
Mat(p, false).colRange(0, 2).copyTo(Mat(homography, false).colRange(0, 2));
Mat(p, false).colRange(3, 4).copyTo(Mat(homography, false).colRange(2, 3));
homography *= (1.0 / homography(2, 2));
}
void Util::SynthesizeCameraImage(const Matx33d& int_mat, const Mat& obj_img,
const Size& cam_img_size, float inter_coeff,
Mat& cam_img, Pose& pose) {
Vec3d begin_tv = Vec3f(0, 0, 1);
Vec3d end_tv = Vec3f(0.2, 0.2, 2);
Vec3d tvec = begin_tv + (end_tv - begin_tv) * inter_coeff;
Vec3d rvec = normalize(Vec3d(inter_coeff - 1, inter_coeff, 0)) *
((70 * inter_coeff) * M_PI / 180);
pose.set_rvec(rvec);
pose.set_tvec(tvec);
SynthesizeCameraImage(int_mat, obj_img, cam_img_size, pose, cam_img);
}
void Util::SynthesizeCameraImage(const Matx33d& int_mat, const Mat& obj_img,
const Size& cam_img_size, const Pose pose,
Mat& cam_img) {
Matx33d homo;
ComputeHomographyFromCameraPose(int_mat, pose, homo);
Matx33d register_mat(1.0 / obj_img.cols, 0, -0.5, 0, 1.0 / obj_img.rows,
-0.5, 0, 0, 1);
warpPerspective(obj_img, cam_img, homo * register_mat, cam_img_size,
INTER_LINEAR, BORDER_CONSTANT, Scalar(80, 80, 80));
}
void Util::ExtractPointsFromKeyPoints(const vector<KeyPoint>& kps,
vector<Point2f>& ps) {
ps.clear();
ps.reserve(kps.size());
for (auto kp : kps) {
ps.push_back(kp.pt);
}
}
void Util::FindExtrema(const Mat& surface, Point2f& extrema) {
Mat A(surface.rows * surface.cols, 5, CV_32FC1);
Mat b(surface.rows * surface.cols, 1, CV_32FC1);
for (auto y = 0; y < surface.rows; ++y) {
for (auto x = 0; x < surface.cols; ++x) {
auto i = y * surface.rows + x;
A.at<float>(i, 0) = x * x;
A.at<float>(i, 1) = y * y;
A.at<float>(i, 2) = x;
A.at<float>(i, 3) = y;
A.at<float>(i, 4) = 1;
b.at<float>(i, 0) = surface.at<float>(y, x);
}
}
Mat x = (A.t() * A).inv() * A.t() * b;
auto aa = 1.0f / x.at<float>(0, 0);
auto bb = 1.0f / x.at<float>(1, 0);
extrema.x = -aa / 2 * x.at<float>(2, 0);
extrema.y = -bb / 2 * x.at<float>(3, 0);
}
| [
"khorisawa0@gmail.com"
] | khorisawa0@gmail.com |
1df1503323ce750e3fa4075a79a2cf0e4f9306b7 | 0c9c751411ef9260686f5651c4461f897c00b7d3 | /w5-4_vectorFieldOfLife_noiseCurve/src/testApp.cpp | 6fb64d3fae7a850dda1de2cc713836c53ec4ef21 | [] | no_license | firmread/firm_algo2012 | 0418c562f48036e543c9152da932188dc366199b | a523a561f106d23641a28a8c987521ebe21368f3 | refs/heads/master | 2020-04-18T16:24:08.059888 | 2012-12-18T02:36:19 | 2012-12-18T02:36:19 | 5,781,577 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,582 | cpp | #include "testApp.h"
//--------------------------------------------------------------
void testApp::setup(){
ofSetVerticalSync(true);
ofSetFrameRate(60);
// ofEnableSmoothing();
ofEnableAlphaBlending();
for (int i = 0; i < 1000; i++){
particle myParticle;
myParticle.setInitialCondition(ofRandom(0,ofGetWidth()),ofRandom(0,ofGetHeight()),0,0);
particles.push_back(myParticle);
}
VF.setupField(200,200,ofGetWidth(), ofGetHeight());
// VF.randomizeField(2.0);
drawingStyle = 0;
bFade = false;
ofBackground(30);
}
//--------------------------------------------------------------
void testApp::update(){
// on every frame
// we reset the forces
// add in any forces on the particle
// perfom damping and
// then update
for (int i = 0; i < particles.size(); i++){
particles[i].resetForce();
// get the force from the vector field:
ofVec2f frc;
frc = VF.getForceFromPos(particles[i].pos.x, particles[i].pos.y);
particles[i].addForce(frc.x, frc.y);
particles[i].addDampingForce();
particles[i].bounceOffWalls();
particles[i].update();
}
if (bFade == true) VF.fadeField(0.99f);
VF.noiseField(0.8, 100.0, 5, true);
ofSetWindowTitle("framerate :" + ofToString(int(ofGetFrameRate())));
}
//--------------------------------------------------------------
void testApp::draw(){
ofEnableAlphaBlending();
// ofSetColor(0,130,130, 50);
ofSetColor(150,70);
VF.draw();
ofSetColor(0,0,0);
for (int i = 0; i < particles.size(); i++){
particles[i].draw();
}
// ofSetColor(0,130,130, 200);
// ofRect(30,30,300,75);
// ofSetColor(255,255,255);
// ofDrawBitmapString("space to clear\nchange drawing mode 'a'\ntoggle fade 'f'", 50, 50);
//
//
// ofSetColor(255,255,130);
// switch (drawingStyle){
// case 0: ofDrawBitmapString("drawing mode: inward", 50, 90);
// break;
// case 1: ofDrawBitmapString("drawing mode: outward", 50, 90);
// break;
// case 2: ofDrawBitmapString("drawing mode: clockwise", 50, 90);
// break;
// case 3: ofDrawBitmapString("drawing mode: counter-clockwise", 50, 90);
// break;
// }
}
//--------------------------------------------------------------
void testApp::keyPressed (int key){
if (key == ' '){
VF.clear();
} else if (key == 'a'){
drawingStyle ++;
drawingStyle %= 4;
} else if (key == 'f'){
bFade = !bFade;
} else if (key == 'r'){
VF.randomizeField(4.0);
}
}
//--------------------------------------------------------------
void testApp::keyReleased (int key){
}
//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){
VF.addClockwiseCircle((float)x, (float)y, 100, 0.9f);
}
//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){
if (button == 0) {
switch (drawingStyle){
case 0: VF.addInwardCircle((float)x, (float)y, 200, 0.3f);
break;
case 1: VF.addOutwardCircle((float)x, (float)y, 100, 0.3f);
break;
case 2: VF.addClockwiseCircle((float)x, (float)y, 100, 0.3f);
break;
case 3: VF.addCounterClockwiseCircle((float)x, (float)y, 100, 0.3f);
break;
}
} else {
particles.erase(particles.begin());
particle myParticle;
myParticle.setInitialCondition(x,y,0,0);
particles.push_back(myParticle);
}
}
//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){
}
//--------------------------------------------------------------
void testApp::mouseReleased(){
}
| [
"litchirhythm@gmail.com"
] | litchirhythm@gmail.com |
bbd50869cfce6fe2bcc0560ac49ea2d38f2764c9 | 3190a9606fdb6a32b68b4012869c1074a5933ca4 | /c++/20140722/pure/1.cpp | 0fb42861ecc8420317d0af6abb6ada4666f5d07d | [] | no_license | lvchao0428/ultrapp | caa5971eddc98226bb62d8269b7be2537c442ca3 | 614c85e88dce932663389a434297f516ea3c979b | refs/heads/master | 2021-01-23T17:31:10.722025 | 2015-09-22T03:30:57 | 2015-09-22T03:30:57 | 21,064,395 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 220 | cpp |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Animal
{
public:
virtual void run() = 0;
};
int main(int argc, const char *argv[])
{
Animal a;
return 0;
}
| [
"lvchao0428@163.com"
] | lvchao0428@163.com |
da8e0a183fce0c50d8dfb9e1d39a2e723ef0925a | 04251e142abab46720229970dab4f7060456d361 | /lib/rosetta/source/src/protocols/simple_filters/PoseInfoFilter.cc | ce295709c8945c559606a9b41cc3bfc286a37f91 | [] | no_license | sailfish009/binding_affinity_calculator | 216257449a627d196709f9743ca58d8764043f12 | 7af9ce221519e373aa823dadc2005de7a377670d | refs/heads/master | 2022-12-29T11:15:45.164881 | 2020-10-22T09:35:32 | 2020-10-22T09:35:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,599 | cc | // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
// vi: set ts=2 noet:
//
// (c) Copyright Rosetta Commons Member Institutions.
// (c) This file is part of the Rosetta software suite and is made available under license.
// (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
// (c) For more information, see http://www.rosettacommons.org. Questions about this can be
// (c) addressed to University of Washington CoMotion, email: license@uw.edu.
/// @file protocols/filters/PoseInfoFilter.cc
/// @brief Filter for looking at specific atom distances
/// @author Rocco Moretti (rmoretti@uw.edu)
#include <protocols/simple_filters/PoseInfoFilter.hh>
#include <protocols/simple_filters/PoseInfoFilterCreator.hh>
// Project Headers
#include <core/types.hh>
#include <core/pose/Pose.hh>
#include <core/pose/PDBInfo.hh>
#include <core/kinematics/FoldTree.hh>
#include <core/pose/datacache/CacheableDataType.hh>
#include <core/scoring/constraints/ConstraintSet.hh>
#include <basic/datacache/BasicDataCache.hh>
#include <utility/tag/Tag.hh>
#include <basic/Tracer.hh>
// XSD XRW Includes
#include <utility/tag/XMLSchemaGeneration.hh>
#include <protocols/filters/filter_schemas.hh>
namespace protocols {
namespace simple_filters {
static basic::Tracer TR( "protocols.filters.PoseInfoFilter" );
/// @brief default ctor
PoseInfoFilter::PoseInfoFilter() :
parent( "PoseInfo" )
{}
/// @return Print pose information and return true
bool PoseInfoFilter::apply(core::pose::Pose const & pose ) const
{
compute( pose );
return true;
}
core::Real
PoseInfoFilter::compute( core::pose::Pose const & pose ) const
{
report(TR, pose);
return 1.0;
}
/// @return Print pose information and return true
core::Real
PoseInfoFilter::report_sm( core::pose::Pose const & pose ) const
{
compute( pose );
return( 1 );
}
void PoseInfoFilter::report( std::ostream & out, core::pose::Pose const & pose ) const
{
out << "Pose Information: " << pose.size() << " residues " << std::endl;
out << "Sequence: " << pose.annotated_sequence() << std::endl;
if ( pose.pdb_info() != nullptr ) {
pose.pdb_info()->show( out );
} else {
out << "<No PDB Info>" << std::endl;
}
out << pose.fold_tree(); // Has implicit internal std::endl;
pose.fold_tree().show( out );
{
using core::pose::datacache::CacheableDataType;
out << "Cached Data: ";
core::pose::Pose::BasicDataCache const & datacache( pose.data() );
for ( core::Size ii(1); ii <= CacheableDataType::num_cacheable_data_types; ++ii ) {
if ( datacache.has( ii ) ) {
// Just output name here, as each datatype needs to be treated differently
// (Do it below, if necessary.)
out << CacheableDataType::get_name( static_cast<CacheableDataType::Enum>( ii ) ) << " ";
}
}
out << std::endl; // To flush the Cached data list.
}
// Feel free to add additional pose-related information.
// The main reason I stopped where I did was I didn't necessarily know how to access relevant others.
out << "Constraints: ";
pose.constraint_set()->show(out);
pose.constraint_set()->show_definition(out,pose);
pose.constraint_set()->show_numbers(out);
}
void PoseInfoFilter::parse_my_tag( utility::tag::TagCOP const,
basic::datacache::DataMap &
)
{
// Right now we don't have any options to control, so don't bother doing anything.
}
std::string PoseInfoFilter::name() const {
return class_name();
}
std::string PoseInfoFilter::class_name() {
return "PoseInfo";
}
void PoseInfoFilter::provide_xml_schema( utility::tag::XMLSchemaDefinition & xsd )
{
using namespace utility::tag;
AttributeList attlist;
protocols::filters::xsd_type_definition_w_attributes(
xsd, class_name(),
"Primarily intended for debugging purposes. When invoked, it will print "
"basic information about the pose (e.g. PDB numbering and FoldTree layout) "
"to the standard/tracer output. This filter *always* returns true, therefore "
"it's not recommended to use it with the standard \"confidence\" option, as that "
"may result in the filter not being applied when you want it to be "
"(and consequently not getting the tracer output).",
attlist );
}
std::string PoseInfoFilterCreator::keyname() const {
return PoseInfoFilter::class_name();
}
protocols::filters::FilterOP
PoseInfoFilterCreator::create_filter() const {
return utility::pointer::make_shared< PoseInfoFilter >();
}
void PoseInfoFilterCreator::provide_xml_schema( utility::tag::XMLSchemaDefinition & xsd ) const
{
PoseInfoFilter::provide_xml_schema( xsd );
}
} // filters
} // protocols
| [
"lzhangbk@connect.ust.hk"
] | lzhangbk@connect.ust.hk |
fbf5535eb61f6d173d8572251a90431704b7cafd | 98077229886057f632984e03cf2721546a5c0631 | /CAFAna/Prediction/PredictionExtrap.h | 6ad967d4bbc492f24aa7166ebc4d64898521ad25 | [] | no_license | CiaranH1997/CAFAna_DUNE_PRISM | 940305cb7e98faa83dfb5ca01c7cbe7d849d7011 | 63e080e6a5d5dcfef824b5d597dc983d6975cf53 | refs/heads/PRISM_NewCode_branch | 2021-02-05T04:25:04.530157 | 2020-09-03T16:09:25 | 2020-09-03T16:09:25 | 243,744,736 | 0 | 0 | null | 2020-06-06T11:04:57 | 2020-02-28T11:15:30 | C++ | UTF-8 | C++ | false | false | 1,041 | h | #pragma once
#include "CAFAna/Prediction/IPrediction.h"
namespace ana
{
class IExtrap;
/// Take the output of an extrapolation and oscillate it as required
class PredictionExtrap: public IPrediction
{
public:
/// Takes ownership of \a extrap
PredictionExtrap(IExtrap* extrap);
virtual ~PredictionExtrap();
virtual Spectrum Predict(osc::IOscCalculator* calc) const override;
virtual Spectrum PredictComponent(osc::IOscCalculator* calc,
Flavors::Flavors_t flav,
Current::Current_t curr,
Sign::Sign_t sign) const override;
OscillatableSpectrum ComponentCC(int from, int to) const override;
Spectrum ComponentNC() const override;
virtual void SaveTo(TDirectory* dir) const override;
static std::unique_ptr<PredictionExtrap> LoadFrom(TDirectory* dir);
PredictionExtrap() = delete;
IExtrap* GetExtrap() const {return fExtrap;}
protected:
IExtrap* fExtrap;
};
}
| [
"bckhouse@fnal.gov"
] | bckhouse@fnal.gov |
0bf0fb5af8ebecafc9e2ff2c64acd95918497717 | dfa92d0a97f6f10a67b13da7ea49641c30e60d29 | /Modules/Havana/Source/Widgets/AssetBrowser.cpp | 2fa8197af9c7c8584338d893e77b00033ace3feb | [
"MIT"
] | permissive | wobbier/MitchEngine | 78a49f4f730fc03db1a9d122fb4cea849be2d850 | 7de012e3a5e926f1ffe6e6fa1c35ab8be63809b2 | refs/heads/master | 2023-07-20T12:33:04.584972 | 2023-03-26T23:20:41 | 2023-03-26T23:20:41 | 35,710,842 | 28 | 4 | MIT | 2023-03-27T00:06:58 | 2015-05-16T05:11:11 | C | UTF-8 | C++ | false | false | 30,472 | cpp | #include "AssetBrowser.h"
#include <filesystem>
#include "imgui.h"
#include "misc/cpp/imgui_stdlib.h"
#include <stack>
#include "Path.h"
#include "Resource/ResourceCache.h"
#include "Graphics/Texture.h"
#include "File.h"
#include "Utils/StringUtils.h"
#include "Components/Transform.h"
#include "Engine/Engine.h"
#include "Havana.h"
#include "Events/SceneEvents.h"
#include "Events/HavanaEvents.h"
#include "optick.h"
#include "Utils/ImGuiUtils.h"
#include <Utils/CommonUtils.h>
#include <Graphics/ShaderFile.h>
#include <CLog.h>
#include "Utils/PlatformUtils.h"
#include "UI/Colors.h"
#if ME_EDITOR
const ImGuiTableSortSpecs* AssetBrowserWidget::s_current_sort_specs = nullptr;
AssetBrowserWidget::AssetBrowserWidget(Havana* inEditor)
: HavanaWidget("Asset Browser", "F2")
, m_editor(inEditor)
{
// This class is used for command line asset exporting, so keep this clean.
AssetDirectory.FullPath = Path("Assets");
EngineAssetDirectory.FullPath = Path("Engine/Assets");
ReloadDirectories();
IsOpen = false;
}
void AssetBrowserWidget::ReloadDirectories()
{
AssetDirectory.Directories.clear();
AssetDirectory.Files.clear();
MasterAssetsList.clear();
for (auto& file : std::filesystem::recursive_directory_iterator(AssetDirectory.FullPath.FullPath))
{
Paths[file.path().string()] = std::filesystem::last_write_time(file);
ProccessDirectory(file, AssetDirectory);
}
EngineAssetDirectory.Directories.clear();
EngineAssetDirectory.Files.clear();
if (EngineAssetDirectory.FullPath.Exists)
{
for (auto& file : std::filesystem::recursive_directory_iterator(EngineAssetDirectory.FullPath.FullPath))
{
Paths[file.path().string()] = std::filesystem::last_write_time(file);
ProccessDirectory(file, EngineAssetDirectory);
}
}
}
AssetBrowserWidget::~AssetBrowserWidget()
{
IsRunning = false;
//fileBrowser.join();
}
//void AssetBrowserWidget::ThreadStart(const std::function<void(std::string, FileStatus)>& action)
//{
// while (IsRunning)
// {
// std::this_thread::sleep_for(Delay);
// continue;
// bool WasModified = false;
// auto it = Paths.begin();
// while (it != Paths.end())
// {
// if (!std::filesystem::exists(it->first))
// {
// action(it->first, FileStatus::Deleted);
// it = Paths.erase(it);
// WasModified = true;
// }
// else
// {
// it++;
// }
// }
//
// for (auto& file : std::filesystem::recursive_directory_iterator(PathToWatch))
// {
// auto currentFileLastWriteTime = std::filesystem::last_write_time(file);
//
// if (!Contains(file.path().string()))
// {
// Paths[file.path().string()] = currentFileLastWriteTime;
// action(file.path().string(), FileStatus::Created);
// WasModified = true;
// }
// else
// {
// if (Paths[file.path().string()] != currentFileLastWriteTime)
// {
// Paths[file.path().string()] = currentFileLastWriteTime;
// action(file.path().string(), FileStatus::Modified);
// WasModified = true;
// }
// }
// }
//
// if (WasModified)
// {
// Paths.clear();
// AssetDirectory = Directory();
// for (auto& file : std::filesystem::recursive_directory_iterator(PathToWatch))
// {
// Paths[file.path().string()] = std::filesystem::last_write_time(file);
// ProccessDirectory(file, AssetDirectory);
// }
// }
// }
//}
void AssetBrowserWidget::Init()
{
Icons["Image"] = ResourceCache::GetInstance().Get<Moonlight::Texture>(Path("Assets/Havana/UI/Image.png"));
Icons["File"] = ResourceCache::GetInstance().Get<Moonlight::Texture>(Path("Assets/Havana/UI/File.png"));
Icons["Model"] = ResourceCache::GetInstance().Get<Moonlight::Texture>(Path("Assets/Havana/UI/Model.png"));
Icons["World"] = ResourceCache::GetInstance().Get<Moonlight::Texture>(Path("Assets/Havana/UI/World.png"));
Icons["Audio"] = ResourceCache::GetInstance().Get<Moonlight::Texture>(Path("Assets/Havana/UI/Audio.png"));
Icons["Prefab"] = ResourceCache::GetInstance().Get<Moonlight::Texture>(Path("Assets/Havana/UI/Prefab.png"));
for (unsigned int i = (unsigned int)AssetType::Unknown + 1; i < (unsigned int)AssetType::Count; i++)
{
assetTypeFilters[i] = false;
}
std::vector<TypeId> events;
events.push_back(RequestAssetSelectionEvent::GetEventId());
EventManager::GetInstance().RegisterReceiver(this, events);
}
void AssetBrowserWidget::Destroy()
{
}
void AssetBrowserWidget::Render()
{
OPTICK_CATEGORY("Asset Browser", Optick::Category::Debug);
//if (false) // Old Way, might come back as a viewing setting
//{
// if (ImGui::Begin("Assets", &IsOpen))
// {
// if (m_compiledAssets.empty())
// {
// if (ImGui::Button("Build Assets"))
// {
// BuildAssets();
// }
// ImGui::SameLine(0.f, 10.f);
// if (ImGui::Button("Refresh"))
// {
// ReloadDirectories();
// }
// }
// else
// {
// if (ImGui::Button("Clear Assets"))
// {
// ClearAssets();
// }
// }
// if (ImGui::CollapsingHeader("Game", ImGuiTreeNodeFlags_DefaultOpen))
// {
// Recursive(AssetDirectory);
// }
// if (ImGui::CollapsingHeader("Engine"))
// {
// Recursive(EngineAssetDirectory);
// }
// }
// ImGui::End();
//}
if (IsOpen)
{
if (ForcedAssetFilter != AssetType::Unknown)
{
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.f);
ImGui::PushStyleColor(ImGuiCol_Border, { 0.447f, .905f, .39f, .31f });
}
ImGui::Begin("Asset Directory", &IsOpen);
if (ForcedAssetFilter != AssetType::Unknown)
{
ImGui::PopStyleVar(1);
ImGui::PopStyleColor(1);
}
{
if (m_compiledAssets.empty())
{
if (ImGui::Button("Build Assets"))
{
BuildAssets();
}
ImGui::SameLine(0.f, 10.f);
if (ImGui::Button("Refresh"))
{
pendingAssetListRefresh = true;
}
}
else
{
if (ImGui::Button("Clear Assets"))
{
ClearAssets();
}
}
}
{
static float wOffset = 350.0f;
static float hOffset = 0.f;
static float h = ImGui::GetContentRegionAvail().y;
float w = 0.f;
if (!IsMetaPanelOpen)
{
w = ImGui::GetContentRegionAvailWidth();
}
else
{
w = ImGui::GetContentRegionAvailWidth() - wOffset;
//h = ImGui::GetContentRegionAvail().y - hOffset;
}
h = ImGui::GetContentRegionAvail().y - hOffset;
//ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
ImGui::BeginChild("child1", ImVec2(w, h), true);
DrawAssetTable();
ImGui::EndChild();
if (IsMetaPanelOpen)
{
ImGui::SameLine();
ImGui::Button("vsplitter", ImVec2(4.0f, h));
if (ImGui::IsItemHovered())
{
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
}
if (ImGui::IsItemActive())
wOffset -= ImGui::GetIO().MouseDelta.x;
ImGui::SameLine();
ImGui::BeginChild("child2", ImVec2(-1.f, h), true);
if (metafile)
{
if(CurrentlyFocusedAsset && CurrentlyFocusedAssetType == AssetType::Texture)
{
const SharedPtr<Moonlight::Texture> tex = std::dynamic_pointer_cast<Moonlight::Texture>(CurrentlyFocusedAsset);
ImGui::Image(tex->TexHandle, { ImGui::GetContentRegionAvailWidth(), ImGui::GetContentRegionAvailWidth() });
}
metafile->OnEditorInspect();
if (ImGui::Button("Save"))
{
metafile->Save();
metafile->Export();
if (CurrentlyFocusedAsset)
{
CurrentlyFocusedAsset->Reload();
}
}
}
else
{
CurrentlyFocusedAsset = nullptr;
}
ImGui::EndChild();
}
else
{
TryDestroyMetaFile();
}
if (IsRequestingSave)
{
ImGui::InvisibleButton("##Spacer", {-1.f, 2.f});
hOffset = 75.f;
ImGui::Text("Name");
ImGui::SameLine();
ImGui::SetNextItemWidth(ImGui::GetContentRegionAvailWidth());
ImGui::InputText("##Name", &SavedName);
float buttonSize = ImGui::GetContentRegionAvailWidth() / 2.f;
ImGui::PushStyleColor(ImGuiCol_Button, (ImVec4)ImColor::HSV(2.f / 7.0f, 0.6f, 0.6f));
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, (ImVec4)ImColor::HSV(2.f / 7.0f, 0.7f, 0.7f));
ImGui::PushStyleColor(ImGuiCol_ButtonActive, (ImVec4)ImColor::HSV(2.f / 7.0f, 0.8f, 0.8f));
if (ImGui::Button("Save", { buttonSize - 5.f, 26.f }))
{
AssetSelectedCallback(Path(SavedName));
RequestOverlay();
}
ImGui::PopStyleColor(3);
ImGui::SameLine();
//ImGui::PushStyleColor(ImGuiCol_ButtonHovered, (ImVec4)ImColor::HSV(.0f, 0.7f, 0.7f));
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ACCENT_RED);
ImGui::PushStyleColor(ImGuiCol_ButtonActive, (ImVec4)ImColor::HSV(.0f, 0.8f, 0.8f));
if (ImGui::Button("Cancel", { buttonSize - 5.f, 26.f }))
{
RequestOverlay();
}
ImGui::PopStyleColor(2);
}
else
{
hOffset = 0.f;
}
}
ImGui::End();
}
else
{
AssetSelectedCallback = nullptr;
ForcedAssetFilter = AssetType::Unknown;
TryDestroyMetaFile();
}
}
void AssetBrowserWidget::DrawAssetTable()
{
static ImGuiTableFlags flags =
ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable
| ImGuiTableFlags_Sortable | ImGuiTableFlags_SortMulti
| ImGuiTableFlags_RowBg | ImGuiTableFlags_Borders | ImGuiTableFlags_NoBordersInBody
| ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY
| ImGuiTableFlags_SizingStretchProp;
static float row_min_height = 16.f; // Auto
static float inner_width_with_scroll = 0.0f; // Auto-extend
static bool outer_size_enabled = true;
static ImGuiTextFilter filter;
static ImVector<int> selection;
static bool items_need_sort = false;
assetTypeFilters[0] = false;
if (pendingAssetListRefresh)
{
ReloadDirectories();
items_need_filtered = true;
items_need_sort = true;
selection.clear();
SelectedAsset = nullptr;
pendingAssetListRefresh = false;
CurrentlyFocusedAssetType = AssetType::Unknown;
CurrentlyFocusedAsset = nullptr;
}
bool stringFilterChanged = filter.Draw("##AssetFilter", ImGui::GetContentRegionAvailWidth() - 100.f);
bool isAssetTypeForced = ForcedAssetFilter != AssetType::Unknown;
ImGui::SameLine();
if (ImGui::Button(IsMetaPanelOpen ? "Details >" : "< Details", {100.f, 18.f}))
{
IsMetaPanelOpen = !IsMetaPanelOpen;
if (IsMetaPanelOpen && SelectedAsset)
{
RefreshMetaPanel(SelectedAsset->FullPath);
}
}
if (isAssetTypeForced)
{
ImGui::PushStyleColor(ImGuiCol_Header, { 0.447f, .905f, .39f, .31f });
ImGui::PushStyleColor(ImGuiCol_HeaderHovered, { 0.447f, .905f, .39f, .8f });
ImGui::PushStyleColor(ImGuiCol_HeaderActive, { .06f, .34f, .2f, 1.f });
}
if (ImGui::CollapsingHeader(isAssetTypeForced ? "Forced Asset Type Filter Active" : "Filters"))
{
for (int i = 1; i < (int)AssetType::Count; ++i)
{
if (ImGui::Checkbox(AssetTypeToString((AssetType)i).c_str(), &assetTypeFilters[i]))
{
items_need_filtered = true;
}
}
}
if (isAssetTypeForced)
{
ImGui::PopStyleColor(3);
for (int i = 1; i < (int)AssetType::Count; ++i)
{
assetTypeFilters[i] = ForcedAssetFilter == (AssetType)i;
}
items_need_filtered = true;
}
bool allFiltersOff = true;
for (int i = 1; i < (int)AssetType::Count; ++i)
{
allFiltersOff = !assetTypeFilters[i];
if (!allFiltersOff)
{
break;
}
}
items_need_filtered = items_need_filtered || stringFilterChanged;
bool hasNoTypeFilter = allFiltersOff && ForcedAssetFilter == AssetType::Unknown;
ImVec2 outer_size_value = ImVec2(-1.f, ImGui::GetWindowHeight() - ImGui::GetCursorPosY());
const float inner_width_to_use = (flags & ImGuiTableFlags_ScrollX) ? inner_width_with_scroll : 0.0f;
if (ImGui::BeginTable("##table", 4, flags, outer_size_enabled ? outer_size_value : ImVec2(0, 0), inner_width_to_use))
{
ImGui::TableSetupColumn("##ID", ImGuiTableColumnFlags_DefaultSort | ImGuiTableColumnFlags_WidthFixed | ImGuiTableColumnFlags_NoHide | ImGuiTableColumnFlags_NoResize, -1.f, MyItemColumnID_ID);
ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, -1.0f, MyItemColumnID_Name);
ImGui::TableSetupColumn("Local Path", ImGuiTableColumnFlags_WidthStretch, -1.0f, MyItemColumnID_Description);
ImGui::TableSetupColumn("Last Modified", ImGuiTableColumnFlags_WidthFixed, 15.f, MyItemColumnID_LastModified);
ImGui::TableSetupScrollFreeze(1, 1);
ImGuiTableSortSpecs* sorts_specs = ImGui::TableGetSortSpecs();
if (sorts_specs && sorts_specs->SpecsDirty)
{
items_need_sort = true;
}
if (sorts_specs && items_need_sort && MasterAssetsList.size() > 1)
{
s_current_sort_specs = sorts_specs; // Store in variable accessible by the sort function.
qsort(&MasterAssetsList[0], (size_t)MasterAssetsList.size(), sizeof(MasterAssetsList[0]), CompareWithSortSpecs);
s_current_sort_specs = NULL;
sorts_specs->SpecsDirty = false;
items_need_filtered = true;
}
items_need_sort = false;
if (items_need_filtered)
{
FilteredAssetList.clear();
for (auto& it : MasterAssetsList)
{
bool passedStringFilter = filter.PassFilter(it.Name.c_str());
if (passedStringFilter && hasNoTypeFilter)
{
FilteredAssetList.push_back(&it);
}
else if (passedStringFilter && !hasNoTypeFilter)
{
for (int i = 1; i < (int)AssetType::Count; ++i)
{
if (it.Type == (AssetType)i && assetTypeFilters[i])
{
FilteredAssetList.push_back(&it);
}
}
}
}
items_need_filtered = false;
}
ImGui::TableHeadersRow();
ImGui::PushButtonRepeat(true);
ImGuiListClipper clipper;
clipper.Begin(FilteredAssetList.size());
while (clipper.Step())
{
for (int row_n = clipper.DisplayStart; row_n < clipper.DisplayEnd; row_n++)
{
AssetDescriptor* item = FilteredAssetList[row_n];
const bool item_is_selected = selection.contains(item->ID);
ImGui::PushID(item->ID);
ImGui::TableNextRow(ImGuiTableRowFlags_None, row_min_height);
if (ImGui::TableNextColumn())
{
bool openFileShortcut = false;
bool openFolderShortcut = false;
ImGuiSelectableFlags selectable_flags = ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowItemOverlap | ImGuiSelectableFlags_AllowDoubleClick;
if (ImGui::Selectable("##Entry", item_is_selected, selectable_flags, ImVec2(0, row_min_height)))
{
SelectedAsset = item;
CurrentlyFocusedAssetType = item->Type;
SavedName = SelectedAsset->FullPath.LocalPath;
if(CurrentlyFocusedAsset)
{
CurrentlyFocusedAsset = nullptr;
}
openFolderShortcut = (m_editor->GetInput().IsKeyDown(KeyCode::LeftAlt) || m_editor->GetInput().IsKeyDown(KeyCode::RightAlt));
if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) && AssetSelectedCallback && !openFolderShortcut)
{
AssetSelectedCallback(item->FullPath);
RequestOverlay();
}
else if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) && !AssetSelectedCallback && !openFolderShortcut)
{
openFileShortcut = true;
}
else if (openFolderShortcut)
{
}
else
{
if (IsMetaPanelOpen)
{
RefreshMetaPanel(item->FullPath);
}
}
if (ImGui::GetIO().KeyCtrl)
{
if (item_is_selected)
selection.find_erase_unsorted(item->ID);
else
selection.push_back(item->ID);
}
else
{
selection.clear();
selection.push_back(item->ID);
}
}
if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_None))
{
ImGui::SetDragDropPayload(AssetDescriptor::kDragAndDropPayload, item, sizeof(AssetDescriptor));
ImGui::Text(item->Name.c_str());
ImGui::EndDragDropSource();
}
bool deleteFileShortcut = m_editor->GetInput().WasKeyPressed(KeyCode::Delete) && !pendingAssetListRefresh;
if (ImGui::BeginPopupContextItem("AssetRightClickContext"))
{
if (ImGui::MenuItem("Open"))
{
openFileShortcut = true;
}
if (ImGui::MenuItem("Open Folder", "Alt + LMB"))
{
openFolderShortcut = true;
}
ImGui::Separator();
if (ImGui::MenuItem("Delete", "Del"))
{
SelectedAsset = item;
deleteFileShortcut = true;
}
ImGui::EndPopup();
}
// Shortcuts
{
if (openFolderShortcut)
{
PlatformUtils::OpenFolder(item->FullPath);
}
if (openFileShortcut)
{
PlatformUtils::OpenFile(item->FullPath);
}
if (SelectedAsset && deleteFileShortcut && !pendingAssetListRefresh)
{
PlatformUtils::DeleteFile(SelectedAsset->FullPath);
pendingAssetListRefresh = true;
}
}
ImGui::SameLine();
ImVec2 iconSize(16, 16);
switch (item->Type)
{
case AssetType::Level:
ImGui::Image(Icons["World"]->TexHandle, iconSize);
break;
case AssetType::Texture:
ImGui::Image(Icons["Image"]->TexHandle, iconSize);
break;
case AssetType::Model:
ImGui::Image(Icons["Model"]->TexHandle, iconSize);
break;
case AssetType::Audio:
ImGui::Image(Icons["Audio"]->TexHandle, iconSize);
break;
case AssetType::Prefab:
ImGui::Image(Icons["Prefab"]->TexHandle, iconSize);
break;
default:
ImGui::Image(Icons["File"]->TexHandle, iconSize);
break;
}
}
if (ImGui::TableNextColumn())
ImGui::TextUnformatted(item->Name.c_str());
if(ImGui::TableNextColumn())
ImGui::Text(item->FullPath.LocalPath.c_str());
if (ImGui::TableNextColumn())
ImGui::Text(item->LastModifiedHuman.c_str());
ImGui::PopID();
}
}
ImGui::PopButtonRepeat();
ImGui::EndTable();
}
}
void AssetBrowserWidget::RefreshMetaPanel(const Path& item)
{
TryDestroyMetaFile();
if (item.Exists)
{
CurrentlyFocusedAsset = ResourceCache::GetInstance().GetCached(item);
if (CurrentlyFocusedAsset)
{
metafile = CurrentlyFocusedAsset->GetMetadata();
}
else
{
metafile = ResourceCache::GetInstance().LoadMetadata(item);
}
ShouldDelteteMetaFile = !CurrentlyFocusedAsset;
}
}
void AssetBrowserWidget::RequestOverlay(const std::function<void(Path)> cb, AssetType forcedType, bool isRequestingSave)
{
if (cb)
{
IsOpen = true;
}
else
{
IsOpen = !IsOpen;
}
ForcedAssetFilter = forcedType;
AssetSelectedCallback = cb;
items_need_filtered = IsOpen;
SavedName = "";
IsRequestingSave = isRequestingSave;
if(IsOpen && IsMetaPanelOpen && SelectedAsset)
{
RefreshMetaPanel(SelectedAsset->FullPath);
}
}
bool AssetBrowserWidget::OnEvent(const BaseEvent& evt)
{
if (evt.GetEventId() == RequestAssetSelectionEvent::GetEventId())
{
const RequestAssetSelectionEvent& event = static_cast<const RequestAssetSelectionEvent&>(evt);
RequestOverlay(event.Callback, event.ForcedFilter, event.IsRequestingSave);
}
return false;
}
void AssetBrowserWidget::Update()
{
}
void AssetBrowserWidget::Recursive(Directory& dir)
{
for (auto& directory : dir.Directories)
{
bool node_open = ImGui::TreeNode(directory.first.c_str());
if (ImGui::IsItemClicked())
{
}
if (ImGui::BeginDragDropTarget())
{
if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("DND_CHILD_TRANSFORM"))
{
IM_ASSERT(payload->DataSize == sizeof(ParentDescriptor));
ParentDescriptor* payload_n = (ParentDescriptor*)payload->Data;
json prefab;
SavePrefab(prefab, payload_n->Parent, true);
File(Path(directory.second.FullPath.Directory + "/" + payload_n->Parent->GetName() + std::string(".prefab"))).Write(prefab[0].dump(4));
}
ImGui::EndDragDropTarget();
}
if (node_open)
{
// we have a subdir
Recursive(directory.second);
ImGui::TreePop();
}
}
int i = 0;
for (AssetDescriptor& files : dir.Files)
{
switch (files.Type)
{
case AssetType::Level:
ImGui::Image(Icons["World"]->TexHandle, ImVec2(16, 16));
break;
case AssetType::Texture:
ImGui::Image(Icons["Image"]->TexHandle, ImVec2(16, 16));
break;
case AssetType::Model:
ImGui::Image(Icons["Model"]->TexHandle, ImVec2(16, 16));
break;
case AssetType::Audio:
ImGui::Image(Icons["Audio"]->TexHandle, ImVec2(16, 16));
break;
case AssetType::Prefab:
ImGui::Image(Icons["Prefab"]->TexHandle, ImVec2(16, 16));
break;
default:
ImGui::Image(Icons["File"]->TexHandle, ImVec2(16, 16));
break;
}
ImGui::SameLine();
//ImGui::Text(files.Name.c_str());
int node_clicked = -1;
ImGuiTreeNodeFlags node_flags = ImGuiTreeNodeFlags_OpenOnArrow;
node_flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen; // ImGuiTreeNodeFlags_Bullet
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 3));
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(-5, 3));
ImGui::TreeNodeEx((void*)(intptr_t)i, node_flags, files.Name.c_str());
if (ImGui::IsItemClicked())
{
SelectedAsset = &files;
node_clicked = i;
if (ImGui::IsMouseDoubleClicked(0))
{
if (files.FullPath.LocalPath.rfind(".lvl") != std::string::npos)
{
LoadSceneEvent evt;
evt.Level = files.FullPath.LocalPath;
evt.Fire();
}
else
{
#if ME_PLATFORM_WIN64
ShellExecute(NULL, L"open", StringUtils::ToWString(SelectedAsset->FullPath.FullPath).c_str(), NULL, NULL, SW_SHOWDEFAULT);
#endif
}
}
else if (ImGui::IsMouseClicked(0))
{
//InspectEvent evt;
//evt.AssetBrowserPath = Path(files.FullPath);
//evt.Fire();
}
}
if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_None))
{
//files.FullPath = dir.FullPath;
ImGui::SetDragDropPayload(AssetDescriptor::kDragAndDropPayload, &files, sizeof(AssetDescriptor));
ImGui::Text(files.Name.c_str());
ImGui::EndDragDropSource();
}
if (ImGui::BeginDragDropTarget())
{
if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("DND_CHILD_TRANSFORM"))
{
IM_ASSERT(payload->DataSize == sizeof(ParentDescriptor));
ParentDescriptor* payload_n = (ParentDescriptor*)payload->Data;
json prefab;
SavePrefab(prefab, payload_n->Parent, true);
File(Path(files.FullPath.Directory + payload_n->Parent->GetName() + std::string(".prefab"))).Write(prefab[0].dump(4));
}
ImGui::EndDragDropTarget();
}
ImGui::PopStyleVar(2);
i++;
}
}
void AssetBrowserWidget::ProccessDirectory(const std::filesystem::directory_entry& file, Directory& dirRef)
{
std::string& parentDir = dirRef.FullPath.FullPath;
std::size_t t = file.path().string().find(parentDir);
if (t != std::string::npos)
{
std::string dir2 = file.path().string().substr(parentDir.size(), file.path().string().size());
ProccessDirectoryRecursive(dir2, dirRef, file);
}
}
void AssetBrowserWidget::BuildAssets()
{
BuildAssetsRecursive(EngineAssetDirectory);
BuildAssetsRecursive(AssetDirectory);
}
void AssetBrowserWidget::BuildAssetsRecursive(Directory& dir)
{
for (auto& directory : dir.Directories)
{
BuildAssetsRecursive(directory.second);
}
for (AssetDescriptor& files : dir.Files)
{
switch (files.Type)
{
case AssetType::Level:
break;
case AssetType::Texture:
BRUH("Compiling: " + files.FullPath.FullPath);
m_compiledAssets.push_back(ResourceCache::GetInstance().Get<Moonlight::Texture>(files.FullPath));
break;
case AssetType::Model:
break;
case AssetType::Audio:
break;
case AssetType::Shader:
BRUH("Compiling: " + files.FullPath.FullPath);
m_compiledAssets.push_back(ResourceCache::GetInstance().Get<Moonlight::ShaderFile>(files.FullPath));
break;
default:
break;
}
}
}
void AssetBrowserWidget::TryDestroyMetaFile()
{
if (metafile)
{
AssetBrowserPath = Path();
if (ShouldDelteteMetaFile)
{
metafile.reset();
ShouldDelteteMetaFile = false;
}
metafile = nullptr;
}
}
int AssetBrowserWidget::CompareWithSortSpecs(const void* lhs, const void* rhs)
{
const AssetDescriptor* a = (const AssetDescriptor*)lhs;
const AssetDescriptor* b = (const AssetDescriptor*)rhs;
for (int n = 0; n < s_current_sort_specs->SpecsCount; n++)
{
// Here we identify columns using the ColumnUserID value that we ourselves passed to TableSetupColumn()
// We could also choose to identify columns based on their index (sort_spec->ColumnIndex), which is simpler!
const ImGuiTableColumnSortSpecs* sort_spec = &s_current_sort_specs->Specs[n];
int delta = 0;
switch (sort_spec->ColumnUserID)
{
case MyItemColumnID_ID: delta = ((int)a->Type - (int)b->Type); break;
case MyItemColumnID_Name: delta = (strcmp(a->Name.c_str(), b->Name.c_str())); break;
case MyItemColumnID_LastModified: delta = (a->LastModified - b->LastModified); break;
case MyItemColumnID_Description: delta = (strcmp(a->Name.c_str(), b->Name.c_str())); break;
default: IM_ASSERT(0); break;
}
if (delta > 0)
return (sort_spec->SortDirection == ImGuiSortDirection_Ascending) ? +1 : -1;
if (delta < 0)
return (sort_spec->SortDirection == ImGuiSortDirection_Ascending) ? -1 : +1;
}
// qsort() is instable so always return a way to differenciate items.
// Your own compare function may want to avoid fallback on implicit sort specs e.g. a Name compare if it wasn't already part of the sort specs.
return ((int)a->Type - (int)b->Type);
}
void AssetBrowserWidget::ClearAssets()
{
m_compiledAssets.clear();
}
bool AssetBrowserWidget::ProccessDirectoryRecursive(std::string& dir, Directory& dirRef, const std::filesystem::directory_entry& file)
{
#if ME_PLATFORM_MACOS
const char slash = '/';
#else
const char slash = '\\';
#endif
std::size_t d = dir.find_first_of(slash);
if (d != std::string::npos)
{
std::string newdir = dir.substr(d + 1, dir.length());
std::size_t d2 = newdir.find_first_of(slash);
if (d2 != std::string::npos)
{
std::string foldername = newdir.substr(0, d2);
if (dirRef.Directories.find(foldername) != dirRef.Directories.end())
{
return ProccessDirectoryRecursive(newdir, dirRef.Directories[foldername], file);
}
else
{
Directory newDirectory;
newDirectory.FullPath = Path(newdir);
dirRef.Directories[foldername] = newDirectory;
return true;
}
}
else
{
if (file.is_regular_file())
{
if (newdir.rfind(".meta") != std::string::npos
|| newdir.rfind(".dds") != std::string::npos
|| newdir.rfind(".pdn") != std::string::npos
|| newdir.rfind(".blend") != std::string::npos
|| newdir.rfind(".bin") != std::string::npos
|| newdir.rfind(".DS_Store") != std::string::npos)
{
return false;
}
// we have a file
AssetType type = AssetType::Unknown;
if (newdir.rfind(".png") != std::string::npos || newdir.rfind(".jpg") != std::string::npos || newdir.rfind(".tif") != std::string::npos)
{
type = AssetType::Texture;
}
else if (newdir.rfind(".lvl") != std::string::npos)
{
type = AssetType::Level;
}
else if (newdir.rfind(".prefab") != std::string::npos)
{
type = AssetType::Prefab;
}
else if (newdir.rfind(".wav") != std::string::npos || newdir.rfind(".mp3") != std::string::npos)
{
type = AssetType::Audio;
}
else if (newdir.rfind(".obj") != std::string::npos || newdir.rfind(".fbx") != std::string::npos || newdir.rfind(".FBX") != std::string::npos)
{
type = AssetType::Model;
}
else if (newdir.rfind(".frag") != std::string::npos || newdir.rfind(".vert") != std::string::npos)
{
type = AssetType::Shader;
}
else if (newdir.rfind(".html") != std::string::npos)
{
type = AssetType::UI;
}
AssetDescriptor desc;
desc.Name = newdir;
//desc.MetaFile = File(Path(file.path().string() + ".meta"));
desc.FullPath = Path(file.path().string());
desc.Type = type;
dirRef.Files.push_back(desc);
//const std::string & data = dirRef.Files.back().MetaFile.Read();
//if (data.empty())
//{
// //dirRef.Files.back().MetaFile.Write("{}");
//}
//else
//{
//}
desc.ID = MasterAssetsList.size();
#if ME_PLATFORM_WIN64
struct stat fileInfo;
if (stat(desc.FullPath.FullPath.c_str(), &fileInfo) != 0)
{
// Use stat() to get the info
//std::cerr << "Error: " << strerror(errno) << '\n';
}
desc.LastModified = static_cast<long>(fileInfo.st_mtime);
{
struct tm* requestedTimestampData;
int td, tsd;
int tm, tsm;
int ty, tsy;
time_t today;
time(&today);
// Today's Date
requestedTimestampData = localtime(&today);
td = requestedTimestampData->tm_mday;
tm = requestedTimestampData->tm_mon;
ty = requestedTimestampData->tm_year;
// Last Modified
std::time_t time2 = desc.LastModified;
requestedTimestampData = localtime(&time2);
tsd = requestedTimestampData->tm_mday;
tsm = requestedTimestampData->tm_mon;
tsy = requestedTimestampData->tm_year;
// #Todo Yesterday format will be inaccurate on first day of the month
const bool isSameMonthYear = (tsm == tm) && (tsy == ty);
char buffer[80];
if (tsd == td && isSameMonthYear)
{
strftime(buffer, 80, "Today at %I:%M %p", requestedTimestampData);
}
else if (tsd == td-1 && isSameMonthYear)
{
strftime(buffer, 80, "Yesterday at %I:%M %p", requestedTimestampData);
}
else
{
strftime(buffer, 80, "%b %d, %Y at %I:%M", requestedTimestampData);
}
desc.LastModifiedHuman = std::string(buffer);
auto place = desc.LastModifiedHuman.rfind("at 0");
if(place != std::string::npos)
{
desc.LastModifiedHuman = desc.LastModifiedHuman.replace(place+3, 1, "");
}
}
#endif
MasterAssetsList.push_back(desc);
return true;
}
Directory newDirectory;
newDirectory.FullPath = Path(dir);
dirRef.Directories[newdir] = newDirectory;
return true;
}
}
Directory newDirectory;
newDirectory.FullPath = Path(dir);
dirRef.Directories[dir] = newDirectory;
return false;
}
void AssetBrowserWidget::SavePrefab(json& d, Transform* CurrentTransform, bool IsRoot)
{
json newJson;
/*json& refJson = d;
if (!IsRoot)
{
refJson = newJson;
}*/
newJson["Name"] = CurrentTransform->GetName();
json& componentsJson = newJson["Components"];
EntityHandle ent = CurrentTransform->Parent;
auto comps = ent->GetAllComponents();
for (auto comp : comps)
{
json compJson;
comp->Serialize(compJson);
componentsJson.push_back(compJson);
}
if (CurrentTransform->GetChildren().size() > 0)
{
for (SharedPtr<Transform> Child : CurrentTransform->GetChildren())
{
SavePrefab(newJson["Children"], Child.get(), false);
}
}
d.push_back(newJson);
}
bool AssetBrowserWidget::Contains(const std::string& key)
{
return Paths.find(key) != Paths.end();
}
#endif
| [
"rastaninja77@gmail.com"
] | rastaninja77@gmail.com |
36339d5220f6933912a049b7470b9a1258d640d6 | adb7fdf18ed82a0a4351436f6e8cd2b42e689485 | /src/learnopengl/common/camera.h | fc05c1526f2bb7030cec5caafd4e0ea14a293580 | [
"MIT"
] | permissive | ikuokuo/start-opengl | 13767459ef8572d902e2572107464147c9cec509 | a66c75211c70a85e4690647b809b275ad083081a | refs/heads/master | 2021-07-12T09:45:48.029921 | 2021-03-10T02:03:12 | 2021-03-10T02:03:12 | 221,230,225 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,048 | h | #pragma once
#include <iostream>
#include <stdexcept>
#include <utility>
#include <vector>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
// Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
enum CameraMovement {
FORWARD,
BACKWARD,
LEFT,
RIGHT,
};
// Default camera values
const float YAW = -90.0f;
const float PITCH = 0.0f;
const float SPEED = 2.5f;
const float SENSITIVITY = 0.1f;
const float ZOOM = 45.0f;
// An abstract camera class that processes input and calculates the corresponding Euler Angles, Vectors and Matrices for use in OpenGL
class Camera {
public:
// Camera Attributes
glm::vec3 Position;
glm::vec3 Front;
glm::vec3 Up;
glm::vec3 Right;
glm::vec3 WorldUp;
// Euler Angles
float Yaw;
float Pitch;
// Camera options
float MovementSpeed;
float MouseSensitivity;
float Zoom;
// Constructor with vectors
Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f),
float yaw = YAW, float pitch = PITCH)
: Front(glm::vec3(0.0f, 0.0f, -1.0f)),
MovementSpeed(SPEED),
MouseSensitivity(SENSITIVITY),
Zoom(ZOOM) {
Position = position;
WorldUp = up;
Yaw = yaw;
Pitch = pitch;
UpdateCameraVectors();
}
// Constructor with scalar values
Camera(float posX, float posY, float posZ,
float upX, float upY, float upZ,
float yaw, float pitch)
: Front(glm::vec3(0.0f, 0.0f, -1.0f)),
MovementSpeed(SPEED),
MouseSensitivity(SENSITIVITY),
Zoom(ZOOM) {
Position = glm::vec3(posX, posY, posZ);
WorldUp = glm::vec3(upX, upY, upZ);
Yaw = yaw;
Pitch = pitch;
UpdateCameraVectors();
}
// Returns the view matrix calculated using Euler Angles and the LookAt Matrix
glm::mat4 GetViewMatrix() {
return glm::lookAt(Position, Position + Front, Up);
}
// Processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems)
void ProcessKeyboard(CameraMovement direction, float deltaTime) {
float velocity = MovementSpeed * deltaTime;
if (direction == FORWARD) Position += Front * velocity;
if (direction == BACKWARD) Position -= Front * velocity;
if (direction == LEFT) Position -= Right * velocity;
if (direction == RIGHT) Position += Right * velocity;
}
// Processes input received from a mouse input system. Expects the offset value in both the x and y direction.
void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true) {
xoffset *= MouseSensitivity;
yoffset *= MouseSensitivity;
Yaw += xoffset;
Pitch += yoffset;
// Make sure that when pitch is out of bounds, screen doesn't get flipped
if (constrainPitch) {
if (Pitch > 89.0f) Pitch = 89.0f;
if (Pitch < -89.0f) Pitch = -89.0f;
}
// Update Front, Right and Up Vectors using the updated Euler angles
UpdateCameraVectors();
}
// Processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis
void ProcessMouseScroll(float yoffset) {
if (Zoom >= 1.0f && Zoom <= 45.0f) Zoom -= yoffset;
if (Zoom <= 1.0f) Zoom = 1.0f;
if (Zoom >= 45.0f) Zoom = 45.0f;
}
private:
// Calculates the front vector from the Camera's (updated) Euler Angles
void UpdateCameraVectors() {
// Calculate the new Front vector
glm::vec3 front;
front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
front.y = sin(glm::radians(Pitch));
front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
Front = glm::normalize(front);
// Also re-calculate the Right and Up vector
Right = glm::normalize(glm::cross(Front, WorldUp)); // Normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement.
Up = glm::normalize(glm::cross(Right, Front));
}
};
class CameraHelperInterface {
public:
virtual ~CameraHelperInterface() = default;
virtual Camera &GetCamera() = 0;
virtual glm::mat4 GetPerspectiveMatrix(float z_near = 0.1f, float z_far = 100.0f) = 0;
virtual glm::mat4 GetViewMatrix() = 0;
virtual void OnFrame() = 0;
virtual void OnKeyEvent(GLFWwindow *) = 0;
virtual void OnMouseEvent(GLFWwindow *, double xpos, double ypos) = 0;
virtual void OnScrollEvent(GLFWwindow *, double xoffset, double yoffset) = 0;
};
class CameraHelper : public CameraHelperInterface {
public:
CameraHelper(int scr_width, int scr_height,
Camera camera = Camera(glm::vec3(0.0f, 0.0f, 3.0f)))
: scr_width_(scr_width),
scr_height_(scr_height),
camera_(std::move(camera)),
first_mouse_(true),
last_x_(scr_width / 2.0f),
last_y_(scr_height / 2.0f) {
}
Camera &GetCamera() override { return camera_; }
glm::mat4 GetPerspectiveMatrix(float z_near = 0.1f, float z_far = 100.0f) override {
return glm::perspective(glm::radians(camera_.Zoom),
(float)scr_width_ / (float)scr_height_, z_near, z_far);
}
glm::mat4 GetViewMatrix() override {
return camera_.GetViewMatrix();
}
void OnFrame() override {
float current_frame = glfwGetTime();
delta_time_ = current_frame - last_frame_;
last_frame_ = current_frame;
}
void OnKeyEvent(GLFWwindow *window) override {
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
camera_.ProcessKeyboard(FORWARD, delta_time_);
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
camera_.ProcessKeyboard(BACKWARD, delta_time_);
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
camera_.ProcessKeyboard(LEFT, delta_time_);
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
camera_.ProcessKeyboard(RIGHT, delta_time_);
}
// glfw: whenever the mouse moves
void OnMouseEvent(GLFWwindow *, double xpos, double ypos) override {
if (first_mouse_) {
last_x_ = xpos;
last_y_ = ypos;
first_mouse_ = false;
}
float xoffset = xpos - last_x_;
float yoffset = last_y_ - ypos; // reversed since y-coordinates go from bottom to top
last_x_ = xpos;
last_y_ = ypos;
camera_.ProcessMouseMovement(xoffset, yoffset);
}
// glfw: whenever the mouse scroll wheel scrolls
void OnScrollEvent(GLFWwindow *, double xoffset, double yoffset) override {
(void)xoffset;
camera_.ProcessMouseScroll(yoffset);
}
private:
int scr_width_;
int scr_height_;
// camera
Camera camera_;
bool first_mouse_;
float last_x_;
float last_y_;
// timing
float delta_time_ = 0.0f; // time between current frame and last frame
float last_frame_ = 0.0f;
};
class CameraHelper2 : public CameraHelperInterface {
private:
CameraHelper2(int scr_width, int scr_height, Camera camera)
: helper_(scr_width, scr_height, std::move(camera)) {
if (scr_width == 0 || scr_height == 0)
throw std::runtime_error{"CameraHelper2 not initialized"};
}
static CameraHelper2 &InstanceImpl(
int scr_width = 0, int scr_height = 0,
Camera camera = Camera(glm::vec3(0.0f, 0.0f, 3.0f))) {
static CameraHelper2 instance(scr_width, scr_height, std::move(camera));
return instance;
}
public:
static void Init(
int scr_width, int scr_height,
Camera camera = Camera(glm::vec3(0.0f, 0.0f, 3.0f))) {
InstanceImpl(scr_width, scr_height, std::move(camera));
}
static CameraHelper2 &Instance() {
return InstanceImpl();
}
Camera &GetCamera() override { return helper_.GetCamera(); }
glm::mat4 GetPerspectiveMatrix(float z_near = 0.1f, float z_far = 100.0f) override {
return helper_.GetPerspectiveMatrix(z_near, z_far);
}
glm::mat4 GetViewMatrix() override {
return helper_.GetViewMatrix();
}
void OnFrame() override {
helper_.OnFrame();
}
void OnKeyEvent(GLFWwindow *window) override {
helper_.OnKeyEvent(window);
}
void OnMouseEvent(GLFWwindow *window, double xpos, double ypos) override {
helper_.OnMouseEvent(window, xpos, ypos);
}
void OnScrollEvent(GLFWwindow *window, double xoffset, double yoffset) override {
helper_.OnScrollEvent(window, xoffset, yoffset);
}
static void glfw_init(GLFWwindow *window, bool glew_init = true) {
glfwMakeContextCurrent(window);
glfwSetFramebufferSizeCallback(window, glfw_framebuffer_size_callback);
glfwSetCursorPosCallback(window, glfw_mouse_callback);
glfwSetScrollCallback(window, glfw_scroll_callback);
// tell GLFW to capture our mouse
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
if (glew_init) CameraHelper2::glew_init();
}
static void glew_init() {
// Initialize GLEW
glewExperimental = true; // Needed in core profile
if (glewInit() != GLEW_OK) {
std::cerr << "Failed to initialize GLEW" << std::endl;
return;
}
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
std::cout << "OpenGL version supported " << glGetString(GL_VERSION) << std::endl;
}
// glfw: whenever the window size changed (by OS or user resize) this callback function executes
static void glfw_framebuffer_size_callback(GLFWwindow *, int width, int height) {
glViewport(0, 0, width, height);
}
// glfw: whenever the mouse moves, this callback is called
static void glfw_mouse_callback(GLFWwindow *window, double xpos, double ypos) {
CameraHelper2::Instance().OnMouseEvent(window, xpos, ypos);
}
// glfw: whenever the mouse scroll wheel scrolls, this callback is called
static void glfw_scroll_callback(GLFWwindow *window, double xoffset, double yoffset) {
CameraHelper2::Instance().OnScrollEvent(window, xoffset, yoffset);
}
private:
CameraHelper helper_;
};
| [
"ikuokuo@hotmail.com"
] | ikuokuo@hotmail.com |
3bf0cb7819527712bde5b6c2c07e4d5502524745 | 8dd76a0b184bef4e534cbae17dbb0cf228503343 | /next_token.h | 4e667c1d6039b27eb9d71f09e379269cb70c5a77 | [] | no_license | elicassion/MyScheme | 257270b8de773f8ff589d2f840da05a0545f6dfa | da1810022799df0f1fe140dedb18daf68d58d361 | refs/heads/master | 2020-05-18T18:27:01.391189 | 2015-07-28T15:56:17 | 2015-07-28T15:56:17 | 38,771,055 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,467 | h | #ifndef next_token_h
#define next_token_h
#include <cstdio>
#include <cassert>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
using namespace std;
FILE *input = stdin;
string s="";
int len=0;
char *next_token() {
char *res = NULL;
string ans;
int cur=0;
int ch;
while (!cur)
{
if(len > 0 && (s[0] == '(' || s[0] == ')'))// for cases:'(' ')'
{
ans=s;
cur=len;
s="";
len=0;
break;
}
if ((ch = fgetc(input)) == EOF)// ่ฏปๅญ็ฌฆ
break;
switch (ch)
{
case '(':
case ')':
if(len>0)
ans=s;cur=len;//ไธไธชblock็ๅณๆฌๅท
s="";//ๅคไธชๅตๅฅ็่ฟ็ปญๅณๆฌๅท
s=s+(char)ch;
len=1;
break;
default:
if (isspace(ch))
{
if(len>0)
ans=s;cur=len; //ไธๆฎตๅ
ๅฎน๏ผ็ฌฆๅทๆ่
ๆฐๅญ๏ผ
s="";
len=0;
}
else
{
s=s+(char)ch;
len++; //่ฟ็ปญ่ฏปๅ
ฅๅญ็ฌฆ็ปๆๅ
ๅฎน
}
}
}
if(cur>0)
{
res=new char[cur+2];
for(int i=0;i<=cur-1;i++)
res[i]=ans[i];
res[cur]='\0';
}
return res; //ไผ ๅๆ่ฏปๅ
ๅฎน
}
#endif // next_token_h
| [
"elicassion@sjtu.edu.cn"
] | elicassion@sjtu.edu.cn |
1a0ac754af9a221ea7138f55c0a181e66ff78481 | 36b857a9d76ea92a4db96298dff2d0a4c527c078 | /thirdparty/OPTI-master/OPTI-master/Solvers/Source/scip/scipsdpmex.cpp | 94c1bf15e24966bf0dc43aacdaef5b7f81e2f745 | [
"BSD-3-Clause",
"MIT"
] | permissive | AdamHibberd/Optimum_Interplanetary_Trajectory | 19e1e283ff5f3d106e2dcc1cfda7d656c898a212 | 77a04b36566edb8bf0735aea4fbe64c161fed197 | refs/heads/master | 2023-09-06T02:23:12.582604 | 2023-08-30T19:34:15 | 2023-08-30T19:34:15 | 124,371,700 | 14 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 21,950 | cpp | /* SCIPSDPMEX - A MATLAB MEX Interface to SCIP-SDP
* Released Under the BSD 3-Clause License:
* https://www.inverseproblem.co.nz/OPTI/index.php/DL/License
*
* Copyright (C) Jonathan Currie 2014
* www.inverseproblem.co.nz
*/
#include "mex.h"
#include <exception>
#include <ctype.h>
#include <stdio.h>
#include "SdpCone.h"
#include "objconshdlr_sdp.h"
#include "objrelax_sdp.h"
#include "scip/scip.h"
#include "scip/scipdefplugins.h"
#include "spxdefines.h"
#include "scipmex.h"
#include "mkl.h"
#include "dsdp5.h"
//Enable for Debug print out
#define DEBUG
//DSDP Version
#define DSDP_VERSION "5.8"
#define SCIPSDP_VERSION "1.0"
using namespace std;
//Argument Enumeration (in expected order of arguments)
enum {eF, eA, eB, eLB, eUB, eSDP, eXTYPE, eOPTS};
//PRHS Defines
#define pF prhs[eF]
#define pA prhs[eA]
#define pB prhs[eB]
#define pLB prhs[eLB]
#define pUB prhs[eUB]
#define pSDP prhs[eSDP]
#define pXTYPE prhs[eXTYPE]
#define pOPTS prhs[eOPTS]
//Function Prototypes
void printSolverInfo();
void addSDPCone(SCIP* scip, SCIP_VAR **scipvars, const mxArray *cone, int block);
void checkInputs(const mxArray *prhs[], int nrhs);
void getIntOption(const mxArray *opts, const char *option, int &var);
void getDblOption(const mxArray *opts, const char *option, double &var);
void getStrOption(const mxArray *opts, const char *option, char *str);
//Message Handler Callback
void msginfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *msg)
{
mexPrintf(msg);
mexEvalString("drawnow;"); //flush draw buffer
}
//Message Buffer
char msgbuf[BUFSIZE];
//Main Function
void mexFunction(int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[])
{
//Input Args
double *f, *A, *b, *lb, *ub;
char *xtype;
//Return Args
double *x, *fval, *exitflag, *iter, *nodes, *gap;
const char *fnames[3] = {"LPiter","BBnodes","BBgap"};
//Common Options
int maxiter = 1500;
int maxnodes = 10000;
int maxpresolve = -1;
double maxtime = 1000;
double primtol = 1e-6;
double objbias = 0.0;
int printLevel = 0;
//Internal Vars
size_t ncones = 0, ndec = 0, ncon = 0;
size_t ncnt = 0, nint = 0, nbin = 0;
size_t i, j;
int alb = 0, aub = 0, no = 0;
//Sparse Indicing
mwIndex *A_ir, *A_jc;
mwIndex startRow, stopRow;
//Print Header or return version string if requested
if(nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else {
plhs[0] = mxCreateString(SCIPSDP_VERSION);
}
return;
}
//Check Inputs
checkInputs(prhs,nrhs);
//Get pointers to input vars
f = mxGetPr(pF);
A = mxGetPr(pA); A_ir = mxGetIr(pA); A_jc = mxGetJc(pA);
b = mxGetPr(pB);
lb = mxGetPr(pLB); ub = mxGetPr(pUB);
if(nrhs > eSDP && !mxIsEmpty(pSDP)) {
if(mxIsCell(pSDP))
ncones = mxGetNumberOfElements(pSDP);
else
ncones = 1;
}
if(nrhs > eXTYPE)
xtype = mxArrayToString(pXTYPE);
//Get sizes from input args
ndec = mxGetNumberOfElements(pF);
ncon = mxGetM(pA);
//Get Common Options if specified
if(nrhs > eOPTS) {
getIntOption(pOPTS,"maxiter",maxiter);
getIntOption(pOPTS,"maxnodes",maxnodes);
getIntOption(pOPTS,"maxpresolve",maxpresolve);
getDblOption(pOPTS,"maxtime",maxtime);
getDblOption(pOPTS,"tolrfun",primtol);
getDblOption(pOPTS,"objbias",objbias);
getIntOption(pOPTS,"display",printLevel);
}
//Create Outputs
plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL);
plhs[1] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[3] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[4] = mxCreateDoubleMatrix(1,1, mxREAL);
x = mxGetPr(plhs[0]);
fval = mxGetPr(plhs[1]);
exitflag = mxGetPr(plhs[2]);
//Statistic Structure Output
plhs[3] = mxCreateStructMatrix(1,1,3,fnames);
mxSetField(plhs[3],0,fnames[0],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[1],mxCreateDoubleMatrix(1,1, mxREAL));
mxSetField(plhs[3],0,fnames[2],mxCreateDoubleMatrix(1,1, mxREAL));
iter = mxGetPr(mxGetField(plhs[3],0,fnames[0]));
nodes = mxGetPr(mxGetField(plhs[3],0,fnames[1]));
gap = mxGetPr(mxGetField(plhs[3],0,fnames[2]));
//SCIP Objects
SCIP* scip;
SCIP_VAR** vars = NULL;
SCIP_CONS** cons = NULL;
SCIP_VAR *objb = NULL;
//Create SCIP Object
SCIP_ERR( SCIPcreate(&scip) , "Error creating SCIP object");
//Add SCIP-SDP Plugins
SCIP_ERR( SCIPincludeObjConshdlr(scip, new ObjConshdlrSdp(scip), TRUE), "Error including SCIP-SDP Constraint Handler plugin");
SCIP_ERR( SCIPincludeObjRelax(scip, new scip::ObjRelaxSdp(scip), TRUE), "Error including SCIP-SDP Constraint Handler plugin");
const char *name = "sdpsolver";
const char *desc = "which sdpsolver should be called";
SCIP_PARAMDATA *paramdata = NULL;
SCIP_ERR( SCIPaddStringParam(scip, name, desc, NULL, FALSE, "dsdp" , NULL, paramdata), "Error adding SDP Solver Parameter");
//Add default plugins
SCIP_ERR( SCIPincludeDefaultPlugins(scip), "Error including SCIP default plugins");
//Add Ctrl-C Event Handler
SCIP_ERR( SCIPincludeCtrlCEventHdlr(scip), "Error adding Ctrl-C Event Handler");
//Create Empty Problem
SCIP_ERR( SCIPcreateProbBasic(scip,"OPTI Problem"), "Error creating basic SCIP problem");
//Create continuous xtype array if empty or not supplied
if(nrhs <= eXTYPE || mxIsEmpty(pXTYPE)) {
xtype = (char*)mxCalloc(ndec,sizeof(char));
for(i=0;i<ndec;i++)
xtype[i] = 'c';
}
//Create infinite bounds if empty
if(mxIsEmpty(pLB)) {
lb = (double*)mxCalloc(ndec,sizeof(double)); alb=1;
for(i=0;i<ndec;i++)
lb[i] = -1e50;
}
if(mxIsEmpty(pUB)) {
ub = (double*)mxCalloc(ndec,sizeof(double)); aub=1;
for(i=0;i<ndec;i++)
ub[i] = 1e50;
}
//Create SCIP Variables (also loads linear objective + bounds)
SCIP_ERR( SCIPallocMemoryArray(scip,&vars,(int)ndec), "Error allocating variable memory");
double llb, lub;
for(i=0;i<ndec;i++)
{
SCIP_VARTYPE vartype;
//Assign variable type
switch(tolower(xtype[i]))
{
case 'i':
vartype = SCIP_VARTYPE_INTEGER;
llb = lb[i]; lub = ub[i];
sprintf(msgbuf,"ivar%d",nint++);
break;
case 'b':
vartype = SCIP_VARTYPE_BINARY;
llb = lb[i] <= -1e50 ? 0 : lb[i]; //if we don't do this, SCIP fails during presolve
lub = ub[i] >= 1e50 ? 1 : ub[i];
sprintf(msgbuf,"bvar%d",nbin++);
break;
case 'c':
vartype = SCIP_VARTYPE_CONTINUOUS;
llb = lb[i]; lub = ub[i];
sprintf(msgbuf,"xvar%d",ncnt++);
break;
default:
sprintf(msgbuf,"Unknown variable type for variable %d",i);
mexErrMsgTxt(msgbuf);
}
//Create variable
SCIP_ERR( SCIPcreateVarBasic(scip,&vars[i],msgbuf,llb,lub,f[i],vartype), "Error creating basic SCIP variable");
//Add to problem
SCIP_ERR( SCIPaddVar(scip,vars[i]), "Error adding SCIP variable to problem");
}
//Add objective bias term if non-zero
if(objbias != 0) {
SCIP_ERR( SCIPcreateVarBasic(scip, &objb, "objbiasterm", objbias, objbias, 1.0, SCIP_VARTYPE_CONTINUOUS), "Error adding objective bias variable");
SCIP_ERR( SCIPaddVar(scip, objb), "Error adding objective bias variable");
}
//Add Linear Constraints (if they exist)
if(ncon) {
//Allocate memory for all constraints (we create them all now, as we have to add coefficients in column order)
SCIP_ERR( SCIPallocMemoryArray(scip, &cons, (int)ncon), "Error allocating constraint memory");
//Create each constraint and add row bounds, but leave coefficients empty
for(i=0;i<ncon;i++) {
SCIPsnprintf(msgbuf, BUFSIZE, "lincon%d", i); //appears constraints require a name
SCIP_ERR( SCIPcreateConsBasicLinear(scip,&cons[i],msgbuf,0,NULL,NULL,-SCIPinfinity(scip),b[i]), "Error creating basic SCIP linear constraint");
}
//Now for each column (variable), add coefficients
for(i = 0; i < ndec; i++) {
//Determine number of nz in this column
startRow = A_jc[i];
stopRow = A_jc[i+1];
no = (int)(stopRow - startRow);
//If we have nz in this column
if(no > 0) {
//Add each coefficient
for(j = startRow; j < stopRow; j++)
SCIP_ERR( SCIPaddCoefLinear(scip, cons[A_ir[j]], vars[i], A[j]), "Error adding constraint linear coefficient");
}
}
//Now for each constraint, add it to the problem, then release it
for(i=0;i<ncon;i++) {
SCIP_ERR( SCIPaddCons(scip,cons[i]), "Error adding linear constraint");
SCIP_ERR( SCIPreleaseCons(scip,&cons[i]), "Error releasing linear constraint");
}
}
//Add Semidefinite Constraints
for(i=0;i<ncones;i++) {
if(ncones == 1 && !mxIsCell(pSDP))
addSDPCone(scip,vars,pSDP,(int)i);
else
addSDPCone(scip,vars,mxGetCell(pSDP,i),(int)i);
}
//Set SCIP-SDP Recommended Options
SCIP_ERR( SCIPsetIntParam(scip,"relaxing/SDPRelax/freq",0), "Error setting SDPrelaxfreq");
SCIP_ERR( SCIPsetIntParam(scip, "lp/solvefreq", 1), "Error setting lp/solvefreq");
SCIP_ERR( SCIPsetRealParam(scip, "numerics/epsilon", 1e-6), "Error setting numerics/epsilon" );
SCIP_ERR( SCIPsetRealParam(scip, "numerics/feastol", 1e-4), "Error setting numerics/feastol");
SCIP_ERR( SCIPsetStringParam(scip, "sdpsolver", "dsdp"), "Error setting sdpsolver");
SCIP_ERR( SCIPsetBoolParam(scip, "lp/cleanuprows", FALSE), "Error setting lp/cleanuprows");
SCIP_ERR( SCIPsetBoolParam(scip, "lp/cleanuprowsroot", FALSE), "Error setting lp/cleanuprowsroot");
SCIP_ERR( SCIPsetIntParam(scip, "lp/rowagelimit", 10), "Error setting lp/rowagelimit");
SCIP_ERR( SCIPsetIntParam(scip, "separating/cutagelimit", 10), "Error setting separating/cutagelimit");
SCIP_ERR( SCIPsetIntParam(scip, "separating/maxrounds", 20), "Error setting separating/maxrounds");
SCIP_ERR( SCIPsetIntParam(scip, "separating/intobj/freq", -1), "Error setting separating/intobj/freq");
SCIP_ERR( SCIPsetIntParam(scip, "branching/inference/priority", -500000000), "Error setting branching/inference/priority"); //turn off basically
//Set Common OPTI Options
SCIP_ERR( SCIPsetRealParam(scip,"limits/time",maxtime), "Error setting maxtime");
SCIP_ERR( SCIPsetLongintParam(scip,"lp/iterlim",maxiter), "Error setting iterlim");
SCIP_ERR( SCIPsetLongintParam(scip,"limits/nodes",maxnodes), "Error setting nodes");
SCIP_ERR( SCIPsetRealParam(scip,"numerics/lpfeastol",primtol), "Error setting lpfeastol");
SCIP_ERR( SCIPsetIntParam(scip,"presolving/maxrounds",maxpresolve), "Error setting max presolve rounds");
//If user has requested print out
if(printLevel)
{
//Create Message Handler
SCIP_MESSAGEHDLR *mexprinter;
SCIPmessagehdlrCreate(&mexprinter,TRUE,NULL,FALSE,&msginfo,&msginfo,&msginfo,NULL,NULL);
SCIP_ERR( SCIPsetMessagehdlr(scip,mexprinter), "Error adding message handler");
//Set Verbosity Level
SCIP_ERR( SCIPsetIntParam(scip,"display/verblevel",printLevel), "Error setting verblevel");
}
//Solve Problem
SCIP_ERR( SCIPsolve(scip), "Error solving SCIP problem!");
//Assign Return Arguments
if(SCIPgetNSols(scip) > 0 )
{
SCIP_SOL* scipbestsol = SCIPgetBestSol(scip);
//Assign x
for(i = 0;i<ndec;i++)
x[i] = SCIPgetSolVal(scip,scipbestsol,vars[i]);
//Assign fval
*fval = SCIPgetSolOrigObj(scip, scipbestsol);
//Get Solve Statistics
*iter = (double)SCIPgetNLPIterations(scip);
*nodes = (double)SCIPgetNTotalNodes(scip);
*gap = SCIPgetGap(scip);
}
//Get Solution Status
*exitflag = (double)SCIPgetStatus(scip);
//Clean up memory from MATLAB mode*/
mxFree(xtype);
if(alb) mxFree(lb); alb = 0;
if(aub) mxFree(ub); aub = 0;
//Release Variables
for(i=0;i<ndec;i++)
SCIP_ERR( SCIPreleaseVar(scip,&vars[i]), "Error releasing SCIP variable");
if(objb != NULL)
SCIP_ERR( SCIPreleaseVar(scip,&objb), "Error releasing SCIP objective bias variable");
//Now free SCIP arrays & problem
SCIPfreeMemoryArray(scip, &vars);
if(ncon) SCIPfreeMemoryArray(scip, &cons);
//Clean up general SCIP memory
SCIP_ERR( SCIPfree(&scip), "Error releasing SCIP problem");
}
//Add SDP Constraint
void addSDPCone(SCIP* scip, SCIP_VAR **scipvars, const mxArray *cone, int block)
{
size_t i,j,idx,midx;
double *SDP_pr = mxGetPr(cone);
mwIndex *SDP_ir = mxGetIr(cone);
mwIndex *SDP_jc = mxGetJc(cone);
int SDP_M = (int)mxGetM(cone);
int SDP_N = (int)mxGetN(cone); //remember [C A0 A1 A2...] so non-square
int SDP_C_nnz = 0; //nnz in C
int SDP_A_nnz = 0; //nnz in current A
int SDP_DIM = (int)(sqrt((double)SDP_M)); //calculate dimension
int rind, cind;
//Find NNZ
SDP_C_nnz = (int)(SDP_jc[1]-SDP_jc[0]);
SDP_A_nnz = (int)SDP_jc[SDP_N] - SDP_C_nnz;
#ifdef DEBUG
mexPrintf("SDP_DIM [block %d]: %d, M: %d, N: %d\n",block,SDP_DIM,SDP_M,SDP_N);
mexPrintf("C nnz: %d, ALL A nnz: %d\n",SDP_C_nnz,SDP_A_nnz);
#endif
//Allocate constraint memory (we allocate too much here...)
SCIP_VAR ** vars = NULL;
int *col = NULL, *row = NULL, *const_col = NULL, *const_row = NULL, nnza = 0, nnzc = 0;
double *vals = NULL, *const_vals = NULL;
SCIP_ERR(SCIPallocBlockMemoryArray(scip, &vars, SDP_A_nnz), "Error Allocating SCIP-SDP Variable Memory");
SCIP_ERR(SCIPallocBlockMemoryArray(scip, &col, SDP_A_nnz), "Error Allocating SCIP-SDP Column Memory");
SCIP_ERR(SCIPallocBlockMemoryArray(scip, &row, SDP_A_nnz), "Error Allocating SCIP-SDP Row Memory");
SCIP_ERR(SCIPallocBlockMemoryArray(scip, &vals, SDP_A_nnz), "Error Allocating SCIP-SDP Values Memory");
SCIP_ERR(SCIPallocBlockMemoryArray(scip, &const_col, SDP_C_nnz), "Error Allocating SCIP-SDP Constant Column Memory");
SCIP_ERR(SCIPallocBlockMemoryArray(scip, &const_row, SDP_C_nnz), "Error Allocating SCIP-SDP Constant Row Memory");
SCIP_ERR(SCIPallocBlockMemoryArray(scip, &const_vals, SDP_C_nnz), "Error Allocating SCIP-SDP Constant Value Memory");
//Copy in C
idx = 0; midx = 0;
for(i=0;i<SDP_C_nnz;i++) {
//Row & Col Index
rind = SDP_ir[i] % SDP_DIM;
cind = (int)((SDP_ir[i] - rind)/SDP_DIM);
if(rind <= cind) {
//Copy In
const_row[idx] = rind+1;
const_col[idx] = cind+1;
const_vals[idx] = SDP_pr[i];
nnzc++;
#ifdef DEBUG
mexPrintf("(%d) - C[%d,%d] = %f\n",idx,const_row[idx],const_col[idx],const_vals[idx]);
#endif
idx++;
}
midx++;
}
idx = 0;
//Copy in all As
for(i=1;i<SDP_N;i++) { //for each variable (A_i matrix)
for(j=SDP_jc[i];j<SDP_jc[i+1];j++) { //for each element in A_i
//Row & Col Index
rind = SDP_ir[midx] % SDP_DIM;
cind = (int)((SDP_ir[midx] - rind)/SDP_DIM);
if(rind <= cind) {
//Copy in
vars[idx] = scipvars[i-1];
row[idx] = rind+1;
col[idx] = cind+1;
vals[idx] = SDP_pr[midx];
nnza++;
#ifdef DEBUG
mexPrintf("(%d) - A[%d][%d,%d] = %f\n",idx,i,row[idx],col[idx],vals[idx]);
#endif
idx++;
}
midx++;
}
}
//Create SCIP-SDP Constraint
SdpCone sdpcone(scip, SDP_DIM, vars, col, row, vals, nnza, const_col, const_row, const_vals, nnzc);
#ifdef DEBUG
mexPrintf("Actual NNZC %d, NNZA %d\n",nnzc,nnza);
mexPrintf("Created Sdcone %d\n",block);
#endif
//Create SCIP Constraint
SCIP_CONS* sdpcon;
SCIPsnprintf(msgbuf, BUFSIZE, "SDP-Constraint-%d", block);
SCIP_ERR( SCIPcreateConsSdp(scip, &sdpcon, msgbuf, sdpcone), "Error Creating SDP Constraint" );
SCIP_ERR( SCIPaddCons(scip, sdpcon), "Error Adding SDP Constraint" );
SCIP_ERR( SCIPreleaseCons(scip, &sdpcon), "Error Releasing SDP Constraint" );
#ifdef DEBUG
mexPrintf("Added Sdcone %d\n",block);
#endif
/*//Copy cast ir
iSDP_ir = (int*)mxCalloc(SDP_jc[SDP_N],sizeof(int));
for(i=0;i<(int)SDP_jc[SDP_N];i++)
iSDP_ir[i] = (int)SDP_ir[i];
//Set Cone Size
DSDP_ERR( SDPConeSetBlockSize(sdpcone,block,(int)SDP_DIM), "Error setting cone dimensions");
DSDP_ERR( SDPConeUsePackedFormat(sdpcone, block), "Error setting cone packed format");
DSDP_ERR( SDPConeSetSparsity(sdpcone,block,(int)SDP_jc[SDP_N]), "Error setting cone sparsity nnz");
//Add C
DSDP_ERR( SDPConeSetASparseVecMat(sdpcone,block,0,SDP_DIM,1.0,0,iSDP_ir,SDP_pr,SDP_C_nnz), "Error setting cone C matrix");
//Add Each A
SDP_A_index = SDP_C_nnz; //set index to elements after C
for(i=1;i<SDP_N;i++) {
SDP_A_nnz = (int)(SDP_jc[i+1]-SDP_jc[i]);
#if DEBUG
mexPrintf("A[%d] nnz: %d, A index: %d, pr[0] = %f ir[0] = %d\n",i-1,SDP_A_nnz,SDP_A_index,SDP_pr[SDP_A_index],iSDP_ir[SDP_A_index]);
#endif
DSDP_ERR( SDPConeSetASparseVecMat(sdpcone,block,i,SDP_DIM,1.0,0,&iSDP_ir[SDP_A_index],&SDP_pr[SDP_A_index],SDP_A_nnz), "Error setting cone A matrix");
SDP_A_index += SDP_A_nnz; //shift index forward
}
//Do not free memory here, MATLAB will take care of it once MEX completes (DSDP will use it during solving) [See MATLAB/User's Guide/C/C++ and Fortran API Reference/mxFree] */
}
//Check all inputs for size and type errors
void checkInputs(const mxArray *prhs[], int nrhs)
{
size_t ndec, ncon;
//Correct number of inputs
if(nrhs <= eUB)
mexErrMsgTxt("You must supply at least 6 arguments to scipsdp (f, A, b, lb, ub, sdcone)");
//Check we have an objective
if(mxIsEmpty(pF))
mexErrMsgTxt("You must supply a linear objective function via f (all zeros if not required)!");
//Check options is a structure
if(nrhs > eOPTS && !mxIsEmpty(pOPTS) && !mxIsStruct(pOPTS))
mexErrMsgTxt("The options argument must be a structure!");
//Get Sizes
ndec = mxGetNumberOfElements(pF);
ncon = mxGetM(pA);
//Check Constraint Pairs
if(ncon && mxIsEmpty(pB))
mexErrMsgTxt("b is empty!");
//Check Sparsity (only supported in A and H)
if(!mxIsEmpty(pA)) {
if(mxIsSparse(pF) || mxIsSparse(pB) || mxIsSparse(pLB))
mexErrMsgTxt("Only A is a sparse matrix");
if(!mxIsSparse(pA))
mexErrMsgTxt("A must be a sparse matrix");
}
//Check xtype data type
if(nrhs > eXTYPE && !mxIsEmpty(pXTYPE) && mxGetClassID(pXTYPE) != mxCHAR_CLASS)
mexErrMsgTxt("xtype must be a char array");
//Check Sizes
if(ncon) {
if(mxGetN(pA) != ndec)
mexErrMsgTxt("A has incompatible dimensions");
if(mxGetNumberOfElements(pB) != ncon)
mexErrMsgTxt("b has incompatible dimensions");
}
if(!mxIsEmpty(pLB) && (mxGetNumberOfElements(pLB) != ndec))
mexErrMsgTxt("lb has incompatible dimensions");
if(!mxIsEmpty(pUB) && (mxGetNumberOfElements(pUB) != ndec))
mexErrMsgTxt("ub has incompatible dimensions");
if(nrhs > eXTYPE && !mxIsEmpty(pXTYPE) && (mxGetNumberOfElements(pXTYPE) != ndec))
mexErrMsgTxt("xtype has incompatible dimensions");
}
//Option Getting Methods
void getIntOption(const mxArray *opts, const char *option, int &var)
{
if(mxGetField(opts,0,option))
var = (int)*mxGetPr(mxGetField(opts,0,option));
}
void getDblOption(const mxArray *opts, const char *option, double &var)
{
if(mxGetField(opts,0,option))
var = *mxGetPr(mxGetField(opts,0,option));
}
void getStrOption(const mxArray *opts, const char *option, char *str)
{
if(mxGetField(opts,0,option))
mxGetString(mxGetField(opts,0,option),str,BUFSIZE);
}
//Print Solver Information
void printSolverInfo()
{
mexPrintf("\n-----------------------------------------------------------\n");
mexPrintf(" SCIP-SDP: Solving Constraint Integer Programs Semidefinite Program Extension [v%s, Built %s]\n",SCIPSDP_VERSION,__DATE__);
mexPrintf(" - Released under the Lesser GNU Public License\n");
mexPrintf(" - Source available from: http://www.opt.tu-darmstadt.de/~smars/scip_sdp.html/\n\n");
mexPrintf(" This binary is statically linked to the following software:\n");
mexPrintf(" - SCIP [%d.%d.%d] (ZIB Academic License)\n",SCIPmajorVersion(),SCIPminorVersion(),SCIPtechVersion());
mexPrintf(" - SoPlex [v%d] (ZIB Academic License)\n",SOPLEX_VERSION);
mexPrintf(" - DSDP [v%s] (Copyright 2004 University of Chicago)\n",DSDP_VERSION);
mexPrintf(" - Intel Math Kernel Library [v%d.%d R%d]\n",__INTEL_MKL__,__INTEL_MKL_MINOR__,__INTEL_MKL_UPDATE__);
mexPrintf("\n MEX Interface J.Currie 2013 [BSD3] (www.inverseproblem.co.nz)\n");
mexPrintf("-----------------------------------------------------------\n");
}
| [
"34288648+AdamHibberd@users.noreply.github.com"
] | 34288648+AdamHibberd@users.noreply.github.com |
0f774a69521e8d6ae5155861670a1f22b49b1378 | b35d2463ee923ced614827fa8cdb5f31bf41ca49 | /union_find/main.cpp | b8afb3a721d697b457d9546cef37498635ec5c14 | [] | no_license | dengqian/file_backup | a204855faf31fdce692340982e4ccbd488fdf4c9 | 33bdcd0484ca2e16ae8aa1cb5f3098b448f01d04 | refs/heads/master | 2021-01-01T16:05:47.401938 | 2015-01-27T13:08:59 | 2015-01-27T13:08:59 | 29,914,590 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,788 | cpp | #include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string.h>
#define N 210
#define M 1010
#define INF 1000000
using namespace std;
struct edge
{
int from;
int to;
int speed;
};
int fn[N];
edge e[M];
bool cmp(edge a, edge b)
{
return a.speed < b.speed;
}
void init(int n)
{
for(int i=0; i<=n; i++)
{
fn[i] = i;
}
}
int root(int x)
{
return x == fn[x] ? x : fn[x] = root(fn[x]);
}
void Union(int a, int b)
{
int aa = root(a);
int bb = root(b);
if(aa != bb)
{
fn[bb] = aa;
}
}
int main()
{
int n;
int m;
int q;
while(scanf("%d%d", &n, &m) != EOF )
{
int cnt = 0;
int num = 0;
for(int i=0; i<m; i++)
{
scanf("%d%d%d", &e[i].from, &e[i].to, &e[i].speed);
}
sort(e, e+m, cmp);
scanf("%d", &q);
for(int j=0; j<q; j++)
{
int ans = INF;
int from,to;
scanf("%d%d", &from, &to);
for(int ii=0; ii<m; ii++)
{
init(n);
for(int jj=ii; jj<m; jj++)
{
Union(e[jj].from,e[jj].to);
if(root(from) == root(to))
{
if(e[jj].speed - e[ii].speed < ans)
{
ans = e[jj].speed - e[ii].speed;
// printf("%d\n",ans);
}
break;
}
}
}
if(ans == INF)
{
printf("-1\n");
}
else
{
printf("%d\n",ans);
}
}
}
return 0;
}
| [
"dengqiancici@163.com"
] | dengqiancici@163.com |
544c67dfee018aa4c27b8df1a6de0f49b48f607c | cd98135ee54252094c1ca7aba42d987b765f39cc | /src/psmlib/WLLibs/communicationsProtocolWL/WLPrtclUDPClient.cpp | 2985f8e9701a0662548604df9369075d02bcb75e | [] | no_license | isliulin/contron-psm70 | 4e0a10a5693bfe87a3f16f9837681d8f7eead450 | c57bff151653e2fed2dda2a13b4a3de3becab535 | refs/heads/master | 2023-03-16T10:16:25.604663 | 2015-09-25T09:36:18 | 2015-09-25T09:36:18 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 10,795 | cpp | // NetSvrClient.cpp: implementation of the CNetSvrClient class.7
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "WLPrtclUDPClient.h"
#include "WLProtocolDataType.h"
#include "../communicationModel/CRC8.h"
#include "../platformLayer/WLPlatformLayer.h"
//#include "../BusinessData/BusinessDataType.h"
//#include "../BusinessData/DSKeySocket.h"
#include "../communicationModel/UDPServer.h" //ไธบๅๅฎ๏ผๅฏๅฐๅฎไฟฎๆนไฝ็ฝฎ
#ifdef WL_IDE_VC6
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CWLPrtclUDPClient::CWLPrtclUDPClient(int localID,const char * remoteIP,WORD remotePort,WORD localPort) : CStreamClient()
{
m_localID = localID;
m_defTimeoutMilSec = 2000;
m_pSocket = new CUDPSocket(remoteIP,remotePort,localPort);
}
CWLPrtclUDPClient::~CWLPrtclUDPClient()
{
}
WORD CWLPrtclUDPClient::commDetect()
{
TRqtCmdIn cmdin = {CLA_RQT,INS_COMM_DETECT,0,0,0,0,0};
int outlen = 0;
WORD sw = cmd(&cmdin,NULL,outlen,0);
return sw;
}
WORD CWLPrtclUDPClient::getSvrTime(TWLTime * pTime)
{
if (pTime == NULL) return SW_INPUT_PARAM_ERR;
TRqtCmdIn cmdin = {CLA_RQT,INS_COMM_DETECT,0,0,0,0,0};
int outlen = 0;
WORD sw = cmd(&cmdin,(BYTE *)pTime,outlen,0);
return sw;
}
WORD CWLPrtclUDPClient::cmd(TRqtCmdIn * pIn,BYTE * pOutData,int & outlen,int remoteID)
//WORD CNetSvrClient::cmd(BYTE cla,BYTE ins,BYTE p1,BYTE p2,WORD sn,WORD lc,BYTE * pInData,BYTE * pOutData,int & outlen)
{
BYTE sendbuf[MAX_CMD_LEN];
BYTE recvbuf[MAX_CMD_LEN];
TAPDUHeader * pHeader = NULL; //ๆฅๆๅคด
BYTE * pBody = NULL; //ๆฅๆไฝ
TAPDUTailer tailer = {0}; //ๆฅๆๅฐพ
WORD sw; //ๅๅบ็ถๆๅญ
static WORD sn = 0;
WORD snCur = sn; //็จไบไฟๅญๆฌๆฌกsn๏ผๅค็บฟ็จๆๆผๆด๏ผๅจsnCur่ตๅผๅๆ็บฟ็จไฟฎๆนsn็ๅผๅไธๆญฃ็กฎ
sn = (sn+1)%0xFFFF;
snCur = sn;
memset(sendbuf,0x00,sizeof(sendbuf));
pHeader = (TAPDUHeader * )sendbuf;
//ๅกซๅ
ๅ่ฎฎๅคด
pHeader->syncheader = SYNC_HEADER;
pHeader->cla = pIn->cla;
pHeader->ins = pIn->ins;
pHeader->p1 = pIn->p1;
pHeader->p2 = pIn->p2;
pHeader->sn = snCur;//pIn->sn;
pHeader->id = m_localID;
pHeader->remoteID = remoteID;
pHeader->lc = pIn->lc;
//ๅกซๅ
ๅ่ฎฎไฝ
pBody = sendbuf + sizeof(TAPDUHeader);
memcpy(pBody,pIn->pData,pHeader->lc);
//ๅกซๅ
ๅ่ฎฎๅฐพ
int index = sizeof(TAPDUHeader)+pHeader->lc; //ๆฅๆๅฐพไฝ็ฝฎ
tailer.crc = CalcCRC8(sendbuf,index);
tailer.synctailer = SYNC_TAILER;
memcpy(sendbuf + index,&tailer,sizeof(TAPDUTailer));
DWORD sendlen = sizeof(TAPDUHeader) + pHeader->lc + sizeof(TAPDUTailer);
DWORD recvlen = sizeof(recvbuf);
int ret = 0;
int loop = 0;
LAB_LOOP:
ret = sendRqtRecvRsp(sendbuf,sendlen,recvbuf,recvlen,m_defTimeoutMilSec);
if (ret <= 0)
{
//WLOutDebug("ๅ้ๆฅๆๅคฑ่ดฅ,้่ฏฏ็ = %d",ret);
WLOutDebug("ๅ้ๆฅๆๅคฑ่ดฅ,้่ฏฏ็ = %d,cla = 0x%.2X, ins = 0x%.2X",ret,pHeader->cla,pHeader->ins);
return SW_NO_RSP;
}
//ๅค็ๅๅบๅ
pHeader = (TAPDUHeader *)recvbuf;
if (pHeader->sn != snCur) //้ๆ่ฏทๆฑ็ๅๅค๏ผ้ๆฐ่ฏทๆฑ
{
loop++;
if (loop > 3)
{
return SW_UNKNOWN_ERR; //ๆช่ทๅพ่ฏทๆฑ็ๅ
ๅฎน
}
WLOutDebug("้ๅค่ฏทๆฑ sn=%d,loop=%d",pHeader->sn,loop);
goto LAB_LOOP;
}
pBody = recvbuf + sizeof(TAPDUHeader);
memcpy(&sw,pBody,SW_LEN); //ๅ็ถๆๅญ
if (pHeader->lc > SW_LEN) //ๅ็ถๆๅญไนๅค็ๅๅบๅฝไปคๆฅๆไฝ
{
//pOutData = pBody + SW_LEN;
/**********************************************************************
ไฟฎๆน๏ผๆดๆฐไปฅไธไปฃ็ ๅฏผ่ด็ๅ
ๅญๆบขๅบ็ฐ่ฑก
ไฝ่
๏ผๅถๆๆ 2013-03-14
ๆน่ฏ๏ผๆฐๅขไปฃ็
**********************************************************************/
outlen = pHeader->lc - SW_LEN;
if (pOutData != NULL) memcpy(pOutData,pBody + SW_LEN,outlen);
//*******************************************************************
//ไปฅไธไปฃ็ ๆ่ฏฏ๏ผไผๆๅ
ๅญๆบขๅบ็ฐ่ฑก๏ผๆฏๅ ไธบๅฐๅๅบ็ ๅ่พๅบๆฐๆฎ้ฝcopyๅ
ฅไบ
//่พๅบๆฐๆฎๅบไบ
/**********************************************************************
if (pOutData != NULL) memcpy(pOutData,pBody + SW_LEN,pHeader->lc);
outlen = pHeader->lc - SW_LEN;
**********************************************************************/
}
else
{
pOutData = NULL;
outlen = 0;
}
//ๅกซๅ
่พๅ
ฅๅคด
pIn->cla = pHeader->cla;
pIn->ins = pHeader->ins;
pIn->p1 = pHeader->p1;
pIn->p2 = pHeader->p2;
pIn->sn = pHeader->sn;
pIn->lc = pHeader->lc;
pIn->pData = pOutData;
return sw;
}
/*********************************************************************
ๅ่ฝ๏ผๆ นๆฎ็ผๅฒm_recvBuf๏ผๅๆๅบๅฝไปคๅ
ๅๆฐ๏ผout๏ผ่พๅบๅๆฐ๏ผๅๆๅบไธๆกๅฝไปค็ๆ้๏ผๅ
ๅญ็ฉบ้ด็ฑๅค้จๅ้
outlen๏ผ่พๅบๅๆฐ๏ผๅๆๅบไธๆกๅฝไปค็้ฟๅบฆ
่ฟๅ๏ผ>=0๏ผๆๅ๏ผๅ
ถไธญ =0 ่กจ็คบ็ผๅฒๅบไธญๅทฒไธๅฏ่ฝๅญๅจไธๆกๅฎๆดๅฝไปค๏ผ
ๅ
ถไธญ >0 ่กจ็คบ็ผๅฒๅบไธญๅฏ่ฝ่ฟๆๅฎๆดๅฝไปค๏ผ่ฐ็จ่
ๅฏ้ๅค่ฐ
็จๆฌๅฝๆฐ๏ผๅๆๅบไฝไธๅฝไปค๏ผ็ดๅฐ่ฟๅๅผ<=0ไธบๆญข
<0๏ผๅคฑ่ดฅ
ๆณจๆ๏ผๆฌๅฝๆฐๅๆๅบๆญฃ็กฎๆฅๆๅ๏ผๅ่ฎฐ่ฆๅฐๆดๆนโDWORD m_recvbuflen;//็ผๅฒๅบๅฝๅ็ผๅฒๅญ่ๆฐโ
ไฝ่
๏ผๅถๆๆ 2012-09-20
*********************************************************************/
int CWLPrtclUDPClient::analyseProtocol(BYTE *out,DWORD &outlen)
{
//ๆๆถ็ฎๅๅฎ็ฐไน
outlen = (m_recvbuflen > MAX_CMD_LEN) ? MAX_CMD_LEN : m_recvbuflen;
memcpy(out,m_recvBuf,outlen);
m_recvbuflen = 0;
return 0;
}
/*********************************************************************
ๅ่ฝ๏ผ้ขๅค็ๅๅบๅ
(ๆฅๆถๅฐ็ๆฐๆฎๅ
)๏ผprocRecvCmdๅฝๆฐๅจๅค็ๅๅบๅ
ไนๅไผ
ๅ
่ฐ็จๆฌๅฝๆฐใๆฌๅฝๆฐ่ฟๅ1ๆถ๏ผprocRecvCmdๅฝๆฐๆพๅผๅฏนๅๅบๅ
่ฟไธๆญฅ
ๅค็ใ
ๅญ็ฑป้่ฝฝๆฌๅฝๆฐ๏ผๅฏๅฎ็ฐๅค็ๅฟ่ทณ็ญ็นๆฎๅ
๏ผๆไฟฎๆนๅๅบๅ
ๅๆฐ๏ผpCmd๏ผๅฝไปค็ๆ้
outlen๏ผๅฝไปค็้ฟๅบฆ
่ฟๅ๏ผ1๏ผ่ฏทๆฑ่ฐ็จ่
(procRecvCmdๅฝๆฐ)ไธญๆญข่ฟไธๆญฅๅค็;้1๏ผๆๆ ๆไน
ไฝ่
๏ผๅๅฐ็ฟ 2014-07-29
*********************************************************************/
int CWLPrtclUDPClient::pretreatmentRecvCmd(BYTE *pCmd,DWORD cmdlen)
{
return 0;
}
/*********************************************************************
ๅ่ฝ๏ผ้ช่ฏ่ฏทๆฑไธๅๅบๆฏๅฆๅน้
ๅๆฐ๏ผpRqt๏ผ่ฏทๆฑๅฝไปคๆ้
pRsp๏ผๅๅบๅฝไปคๆ้
่ฟๅ๏ผ1๏ผๅน้
0๏ผไธๅน้
ไฝ่
๏ผๅถๆๆ 2012-09-20
*********************************************************************/
BOOL CWLPrtclUDPClient::isMatchRqtRsp(BYTE *pRqt,DWORD rqtlen,BYTE *pRsp,DWORD rsplen)
{
static TAPDUHeader * pRqtHeader = NULL;
static TAPDUHeader * pRspHeader = NULL;
pRqtHeader = (TAPDUHeader *)pRqt;
pRspHeader = (TAPDUHeader *)pRsp;
if (pRqtHeader == NULL ||pRspHeader == NULL) return FALSE;
if (pRqtHeader->ins == pRspHeader->ins && (pRqtHeader->cla & CLA_RQT) == CLA_RQT && (pRspHeader->cla & CLA_RSP) == CLA_RSP) return TRUE;
else return FALSE;
}
/*********************************************************************
ๅ่ฝ๏ผๅค็ๅฏนๆนไธปๅจๅ่ตท็ๅฝไปค๏ผๅฏนๅบcใdไธค็ง้ไฟกๆจกๅ
ๅๆฐ๏ผpCmd,ๅฝไปคๆ้
cmdlen๏ผๅฝไปค้ฟๅบฆ
่ฟๅ๏ผๆ
ไฝ่
๏ผๅๅฐ็ฟ 2014-07-29
*********************************************************************/
void CWLPrtclUDPClient::procRemoteNotify(BYTE *pCmd,DWORD cmdlen)
{
if (NULL == pCmd) return;
TAPDUHeader * pHeader = (TAPDUHeader * )pCmd;
//ๅชๅค็่ฏทๆฑ
if (CLA_RQT != pHeader->cla) return;
if (pHeader->ins == INS_COMM_DETECT) //้ไฟกๆฃๆต๏ผ็จไบๅฟ่ทณ
onRecvCommDetect(pCmd,cmdlen);
else if (INS_GET_SVR_TIME == pHeader->ins)
onRecvGetLocalTime(pCmd,cmdlen);
else
WLOutDebug("ๆชๅฎ็ฐๆฅๆ");
}
/*********************************************************************
ๅ่ฝ๏ผๅ้ๅๅบ
ๅๆฐ๏ผpCmdIn๏ผๅฝไปค่พๅ
ฅ
่ฟๅ๏ผ่ฟๅ๏ผ<0๏ผ้่ฏฏ๏ผ
>=0๏ผๆๅๅ้ๅญ่ๆฐ
ไฝ่
๏ผๅๅฐ็ฟ 2014-07-30
*********************************************************************/
int CWLPrtclUDPClient::responseCmd(TRspCmdIn * pIn)
{
BYTE cmd[UDPSERVER_MAX_CMD_LEN] = {0};
DWORD sendlen = 0,index = 0,len = 0;
TAPDUHeader *pHeader = NULL; //ๆฅๆๅคด
BYTE *pBody = NULL; //ๆฅๆไฝ
TAPDUTailer tailer ; //ๆฅๆๅฐพ
memset(cmd,0x00,sizeof(cmd));
pHeader = (TAPDUHeader * )cmd;
//ๅกซๅ
ๅ่ฎฎๅคด
pHeader->syncheader = SYNC_HEADER;
pHeader->cla = pIn->cla | CLA_RSP;
pHeader->ins = pIn->ins;
pHeader->p1 = pIn->p1;
pHeader->p2 = pIn->p2;
pHeader->sn = pIn->sn;
pHeader->id = m_localID;
pHeader->lc = pIn->lc;
//ๅกซๅ
ๅ่ฎฎไฝ
index = sizeof(TAPDUHeader);
pBody = cmd+index;
memcpy(pBody,&(pIn->sw),2);
memcpy(pBody+2,pIn->pData,pHeader->lc -2);
//ๅกซๅ
ๅ่ฎฎๅฐพ
index = sizeof(TAPDUHeader)+pHeader->lc; //ๆฅๆๅฐพไฝ็ฝฎ
tailer.crc = CalcCRC8(cmd,index);
tailer.synctailer = SYNC_TAILER;
memcpy(cmd + index,&tailer,sizeof(TAPDUTailer));
//ๅ้ๅๅบๆฅๆ
len = sizeof(TAPDUHeader) + pHeader->lc + sizeof(TAPDUTailer);
sendlen = m_pSocket->send(cmd,len);
return sendlen;
}
/*
ๅ่ฝ๏ผๅค็ๅฏนๆนไธปๅจๆถๆฏ ๅฟ่ทณ
*/
void CWLPrtclUDPClient::onRecvCommDetect(BYTE *pCmd,DWORD len)
{
//ๅ่ฏทๆฑ
TAPDUHeader *pHeader = (TAPDUHeader *)pCmd;
//ๅค็่ฏทๆฑ
//ๅๅบๆฅๆๆฐๆฎๅบๆผๅ
WORD lc = SW_LEN;
WORD sw = SW_SUCCESS;
//ๅ้ๅๅบ
TRspCmdIn rspCmdin = {CLA_RSP,pHeader->ins,pHeader->p1,pHeader->p2,pHeader->sn,lc,sw,NULL};
responseCmd(&rspCmdin);
}
/*
ๅ่ฝ๏ผๅค็ๅฏนๆนไธปๅจๆถๆฏ ่ทๅๆฌ็ซฏๆถ้ด
*/
void CWLPrtclUDPClient::onRecvGetLocalTime(BYTE *pCmd,DWORD len)
{
//ๅ่ฏทๆฑ
TAPDUHeader *pHeader = (TAPDUHeader *)pCmd;
//ๅค็่ฏทๆฑ
//ๅๅบๆฅๆๆฐๆฎๅบๆผๅ
TWLTime tm;
WORD lc = SW_LEN + sizeof(TWLTime);
WORD sw = onRemoteRqtGetSvrTime(&tm);
//ๅ้ๅๅบ
TRspCmdIn rspCmdin = {CLA_RSP,pHeader->ins,pHeader->p1,pHeader->p2,pHeader->sn,lc,sw,(BYTE *)&tm};
responseCmd(&rspCmdin);
}
/*********************************************************************
ๅ่ฝ๏ผๅค็๏ผ่ฏทๆฑๆๅกๅจๆฌๆบๆถ้ด
ๅๆฐ๏ผpTime๏ผ่พๅบๅๆฐ๏ผๆฌๅฐๆถ้ด
่ฟๅ๏ผๅๅบ็
ไฝ่
๏ผๅถๆๆ 2013-11-28
*********************************************************************/
WORD CWLPrtclUDPClient::onRemoteRqtGetSvrTime(TWLTime * pTime)
{
int ret = WLGetLocalTime(pTime);
if (ret == 1) return SW_SUCCESS;
else return SW_UNKNOWN_ERR;
} | [
"zhlgh603@qq.com"
] | zhlgh603@qq.com |
833df540ccbc52f9452827667e43b254929be3f2 | 1fbf3598485f0721f9ae434a9d1b6d8674a50d18 | /Optimal-strategy-for-a-game.cpp | 41ecfa23d61dc207d46f3a03b1d4732f8d68f38d | [] | no_license | eqan/Interesting-Programmming-Questions | 0dc982fc47ca705595fece9b0add1217e52cfb4f | ffbb8fa0ebbca33708cae1dcd338c371c5df5245 | refs/heads/main | 2023-04-26T20:58:52.185637 | 2021-05-22T16:52:30 | 2021-05-22T16:52:30 | 369,775,349 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,600 | cpp | // C++ program to find out
// maximum value from a given
// sequence of coins
#include <bits/stdc++.h>
using namespace std;
// Returns optimal value possible
// that a player can collect from
// an array of coins of size n.
// Note than n must be even
int optimalStrategyOfGame(
int* arr, int n)
{
// Create a table to store
// solutions of subproblems
int table[n][n];
// Fill table using above
// recursive formula. Note
// that the table is filled
// in diagonal fashion (similar
// to http:// goo.gl/PQqoS),
// from diagonal elements to
// table[0][n-1] which is the result.
for (int gap = 0; gap < n; ++gap) {
for (int i = 0, j = gap; j < n; ++i, ++j) {
// Here x is value of F(i+2, j),
// y is F(i+1, j-1) and
// z is F(i, j-2) in above recursive
// formula
int x = ((i + 2) <= j)
? table[i + 2][j]
: 0;
int y = ((i + 1) <= (j - 1))
? table[i + 1][j - 1]
: 0;
int z = (i <= (j - 2))
? table[i][j - 2]
: 0;
table[i][j] = max(
arr[i] + min(x, y),
arr[j] + min(y, z));
}
}
return table[0][n - 1];
}
// Driver program to test above function
int main()
{
int arr1[] = { 8, 15, 3, 7 };
int n = sizeof(arr1) / sizeof(arr1[0]);
printf("%d\n",
optimalStrategyOfGame(arr1, n));
int arr2[] = { 2, 2, 2, 2 };
n = sizeof(arr2) / sizeof(arr2[0]);
printf("%d\n",
optimalStrategyOfGame(arr2, n));
int arr3[] = { 20, 30, 2, 2, 2, 10 };
n = sizeof(arr3) / sizeof(arr3[0]);
printf("%d\n",
optimalStrategyOfGame(arr3, n));
return 0;
}
| [
"eqan.ahmad123@gmail.com"
] | eqan.ahmad123@gmail.com |
27dcedd35a5c7f639c942c69f82773344bb253bc | cfa93e937e3bcd170a85eddbeec17091fca8fb53 | /01_mnist_cnn/hls/conv_core_new/solution1/.autopilot/db/conv_core.pp.0.cpp.ap-cdt.cpp | f7ac8d2f0ca1b920dd34ced8cb9e5ec4e1f131d3 | [
"MIT"
] | permissive | sinply/FPGA_CNN | b7ca694e00da503d1cec6129dd4321f149504f5f | b7b5d960886837ef6648ea3655a627bbaa295d00 | refs/heads/master | 2022-12-16T01:39:54.541379 | 2020-09-18T01:08:39 | 2020-09-18T01:08:39 | 288,867,431 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,172,769 | cpp | #pragma line 1 "conv_core_new/conv_core.cpp"
#pragma line 1 "conv_core_new/conv_core.cpp" 1
#pragma line 1 "<built-in>" 1
#pragma line 1 "<built-in>" 3
#pragma line 153 "<built-in>" 3
#pragma line 1 "<command line>" 1
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\etc/autopilot_ssdm_op.h" 1
/* autopilot_ssdm_op.h*/
/*
* __VIVADO_HLS_COPYRIGHT-INFO__
*
* $Id$
*/
#pragma line 99 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\etc/autopilot_ssdm_op.h"
/*#define AP_SPEC_ATTR __attribute__ ((pure))*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/****** SSDM Intrinsics: OPERATIONS ***/
// Interface operations
#pragma empty_line
//typedef unsigned int __attribute__ ((bitwidth(1))) _uint1_;
typedef bool _uint1_;
#pragma empty_line
void _ssdm_op_IfRead(...) __attribute__ ((nothrow));
void _ssdm_op_IfWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfNbRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfNbWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfCanRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfCanWrite(...) __attribute__ ((nothrow));
#pragma empty_line
// Stream Intrinsics
void _ssdm_StreamRead(...) __attribute__ ((nothrow));
void _ssdm_StreamWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamNbRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamNbWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamCanRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamCanWrite(...) __attribute__ ((nothrow));
unsigned _ssdm_StreamSize(...) __attribute__ ((nothrow));
#pragma empty_line
// Misc
void _ssdm_op_MemShiftRead(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Wait(...) __attribute__ ((nothrow));
void _ssdm_op_Poll(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Return(...) __attribute__ ((nothrow));
#pragma empty_line
/* SSDM Intrinsics: SPECIFICATIONS */
void _ssdm_op_SpecSynModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecTopModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDecl(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDef(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPort(...) __attribute__ ((nothrow));
void _ssdm_op_SpecConnection(...) __attribute__ ((nothrow));
void _ssdm_op_SpecChannel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecSensitive(...) __attribute__ ((nothrow));
void _ssdm_op_SpecModuleInst(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPortMap(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecReset(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPlatform(...) __attribute__ ((nothrow));
void _ssdm_op_SpecClockDomain(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPowerDomain(...) __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecRegionBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecRegionEnd(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopName(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopTripCount(...) __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecStateBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecStateEnd(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecInterface(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPipeline(...) __attribute__ ((nothrow));
void _ssdm_op_SpecDataflowPipeline(...) __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
void _ssdm_op_SpecLatency(...) __attribute__ ((nothrow));
void _ssdm_op_SpecParallel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProtocol(...) __attribute__ ((nothrow));
void _ssdm_op_SpecOccurrence(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecResource(...) __attribute__ ((nothrow));
void _ssdm_op_SpecResourceLimit(...) __attribute__ ((nothrow));
void _ssdm_op_SpecCHCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecFUCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIFCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIPCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecKeepValue(...) __attribute__ ((nothrow));
void _ssdm_op_SpecMemCore(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecExt(...) __attribute__ ((nothrow));
/*void* _ssdm_op_SpecProcess(...) SSDM_SPEC_ATTR;
void* _ssdm_op_SpecEdge(...) SSDM_SPEC_ATTR; */
#pragma empty_line
/* Presynthesis directive functions */
void _ssdm_SpecArrayDimSize(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_RegionBegin(...) __attribute__ ((nothrow));
void _ssdm_RegionEnd(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_Unroll(...) __attribute__ ((nothrow));
void _ssdm_UnrollRegion(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_InlineAll(...) __attribute__ ((nothrow));
void _ssdm_InlineLoop(...) __attribute__ ((nothrow));
void _ssdm_Inline(...) __attribute__ ((nothrow));
void _ssdm_InlineSelf(...) __attribute__ ((nothrow));
void _ssdm_InlineRegion(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecArrayMap(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayPartition(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayReshape(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecStream(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecExpr(...) __attribute__ ((nothrow));
void _ssdm_SpecExprBalance(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecDependence(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecLoopMerge(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopFlatten(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopRewind(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecFuncInstantiation(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncBuffer(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncExtract(...) __attribute__ ((nothrow));
void _ssdm_SpecConstant(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_DataPack(...) __attribute__ ((nothrow));
void _ssdm_SpecDataPack(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecBitsMap(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLicense(...) __attribute__ ((nothrow));
#pragma empty_line
void __xilinx_ip_top(...) __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
}
#pragma line 361 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\etc/autopilot_ssdm_op.h"
/*#define _ssdm_op_WaitUntil(X) while (!(X)) _ssdm_op_Wait(1);
#define _ssdm_op_Delayed(X) X */
#pragma line 375 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\etc/autopilot_ssdm_op.h"
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 8 "<command line>" 2
#pragma line 1 "<built-in>" 2
#pragma line 1 "conv_core_new/conv_core.cpp" 2
#pragma line 1 "conv_core_new/conv_core.h" 1
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\ap_int.h" 1
// -*- c++ -*-
/*
* __VIVADO_HLS_COPYRIGHT-INFO__
*
*/
#pragma line 14 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\ap_int.h"
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/hls_half.h" 1
// half - IEEE 754-based half-precision floating point library.
//
// Copyright (c) 2012-2013 Christian Rau <rauy@users.sourceforge.net>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#pragma empty_line
// Version 1.11.0
#pragma empty_line
/// \file
/// Main header file for half precision functionality.
#pragma line 32 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/hls_half.h"
//#error hls_half simulation header file is not applicable for synthesis (synthesis header to be added)
typedef __fp16 half;
#pragma line 3079 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/hls_half.h"
// implemented in lib_hlsm.cpp
//extern int __signbit(half a_re);
extern half half_nan(const char *tagp);
// extern int __isfinite(half t_in);
// extern int __isinf(half t_in);
// extern int __isnan(half t_in);
// extern int __isnormal(half t_in);
// extern int __fpclassify(half t_in);
extern half half_atan(half t);
extern half half_atan2(half y, half x);
extern half half_copysign(half x, half y);
//extern half copysign(half x, half y);
extern half half_fabs(half x);
//extern half fabs(half x);
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 fmax(half x, half y);
extern half half_fmin(half x, half y);
//extern half fmin(half x, half y);
extern half half_sin(half t_in);
extern half half_cos(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_log(half x);
extern half half_log10(half x);
extern half half_log2(half x);
extern half half_exp(half x);
extern half half_exp10(half x);
extern half half_exp2(half x);
#pragma empty_line
extern half half_floor(half x);
//half floor(half x)
extern half half_ceil(half x);
//half ceil(half x)
extern half half_trunc(half x);
// half trunc(half x)
extern half half_round(half x);
//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);
// half modf(half x, half *intpart)
extern half half_fract(half x, half *intpart);
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 15 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\ap_int.h" 2
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h" 1
/* -*- c++ -*-*/
/*
* __VIVADO_HLS_COPYRIGHT-INFO__
*
*/
#pragma line 22 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iostream" 1 3
// Standard iostream objects -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2005, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file iostream
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.3 Standard iostream objects
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iostream" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 1 3
// Predefined symbols and macros -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file c++config.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// The current version of the C++ library in compressed ISO date format.
#pragma empty_line
#pragma empty_line
// Macros for visibility.
// _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
// _GLIBCXX_VISIBILITY_ATTR
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// If this is not supplied by the OS-specific or CPU-specific
// headers included below, it will be defined to an empty default.
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Macros for deprecated.
// _GLIBCXX_DEPRECATED
// _GLIBCXX_DEPRECATED_ATTR
#pragma line 63 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// Macros for activating various namespace association modes.
// _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG
// _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL
// _GLIBCXX_NAMESPACE_ASSOCIATION_VERSION
#pragma empty_line
// Guide to libstdc++ namespaces.
/*
namespace std
{
namespace __debug { }
namespace __parallel { }
namespace __norm { } // __normative, __shadow, __replaced
namespace __cxx1998 { }
#pragma empty_line
namespace tr1 { }
}
*/
#pragma line 90 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// Namespace association for profile
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Defined if any namespace association modes are active.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Macros for namespace scope. Either namespace std:: or the name
// of some nested namespace within it.
// _GLIBCXX_STD
// _GLIBCXX_STD_D
// _GLIBCXX_STD_P
//
// Macros for enclosing namespaces and possibly nested namespaces.
// _GLIBCXX_BEGIN_NAMESPACE
// _GLIBCXX_END_NAMESPACE
// _GLIBCXX_BEGIN_NESTED_NAMESPACE
// _GLIBCXX_END_NESTED_NAMESPACE
#pragma line 187 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// Namespace associations for debug mode.
#pragma line 197 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// Namespace associations for parallel mode.
#pragma line 207 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// Namespace associations for profile mode
#pragma line 217 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// Namespace associations for versioning mode.
#pragma line 238 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// XXX GLIBCXX_ABI Deprecated
// Define if compatibility should be provided for -mlong-double-64
#pragma empty_line
#pragma empty_line
// Namespace associations for long double 128 mode.
#pragma line 258 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// Defines for C compatibility. In particular, define extern "C"
// linkage only when using C++.
#pragma line 272 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// First includes.
#pragma empty_line
// Pick up any OS-specific definitions.
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/os_defines.h" 1 3
// Specific definitions for generic platforms -*- C++ -*-
#pragma empty_line
// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
// 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file os_defines.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// System-specific #define, typedefs, corrections, etc, go here. This
// file will come before all others.
#pragma empty_line
// Define as 0, if you want, to enable inlining of gthread functions.
// By default, don't pollute libstdc++ with win32api names.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Don't let win32api windef.h define min and max as macros
// if included after c++config.h.
#pragma line 57 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/os_defines.h" 3
// See libstdc++/20806.
#pragma empty_line
#pragma empty_line
// See libstdc++/37522.
#pragma line 276 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 2 3
#pragma empty_line
// Pick up any CPU-specific definitions.
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/cpu_defines.h" 1 3
// Specific definitions for generic platforms -*- C++ -*-
#pragma empty_line
// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cpu_defines.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma line 279 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 2 3
#pragma empty_line
// If platform uses neither visibility nor psuedo-visibility,
// specify empty default for namespace annotation macros.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Allow use of "export template." This is currently not a feature
// that g++ supports.
// #define _GLIBCXX_EXPORT_TEMPLATE 1
#pragma empty_line
// Allow use of the GNU syntax extension, "extern template." This
// extension is fully documented in the g++ manual, but in a nutshell,
// it inhibits all implicit instantiations and is used throughout the
// library to avoid multiple weak definitions for required types that
// are already explicitly instantiated in the library binary. This
// substantially reduces the binary size of resulting executables.
#pragma empty_line
// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
// templates only in basic_string, thus activating its debug-mode
// checks even at -O0.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Certain function definitions that are meant to be overridable from
// user code are decorated with this macro. For some targets, this
// macro causes these definitions to be weak.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Assert.
// Avoid the use of assert, because we're trying to keep the <cassert>
// include out of the mix.
#pragma line 339 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// The remainder of the prewritten config is automatic; all the
// user hooks are listed above.
#pragma empty_line
// Create a boolean flag to be used to determine if --fast-math is set.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// This marks string literals in header files to be extracted for eventual
// translation. It is primarily used for messages in thrown exceptions; see
// src/functexcept.cc. We use __N because the more traditional _N is used
// for something else under certain OSes (see BADNAMES).
#pragma empty_line
#pragma empty_line
// For example, <windows.h> is known to #define min and max as macros...
#pragma line 379 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++config.h" 3
// End of prewritten config; the discovered settings follow.
/* config.h. Generated from config.h.in by configure. */
/* config.h.in. Generated from configure.ac by autoheader. */
#pragma empty_line
/* Define to 1 if you have the `acosf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `acosl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `asinf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `asinl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if the target assembler supports .symver directive. */
/* #undef _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE */
#pragma empty_line
/* Define to 1 if you have the `atan2f' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `atan2l' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `atanf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `atanl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if the target assembler supports thread-local storage. */
/* #undef _GLIBCXX_HAVE_CC_TLS */
#pragma empty_line
/* Define to 1 if you have the `ceilf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `ceill' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <complex.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `cosf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `coshf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `coshl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `cosl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <dlfcn.h> header file. */
/* #undef _GLIBCXX_HAVE_DLFCN_H */
#pragma empty_line
/* Define if EBADMSG exists. */
/* #undef _GLIBCXX_HAVE_EBADMSG */
#pragma empty_line
/* Define if ECANCELED exists. */
/* #undef _GLIBCXX_HAVE_ECANCELED */
#pragma empty_line
/* Define if EIDRM exists. */
/* #undef _GLIBCXX_HAVE_EIDRM */
#pragma empty_line
/* Define to 1 if you have the <endian.h> header file. */
/* #undef _GLIBCXX_HAVE_ENDIAN_H */
#pragma empty_line
/* Define if ENODATA exists. */
/* #undef _GLIBCXX_HAVE_ENODATA */
#pragma empty_line
/* Define if ENOLINK exists. */
/* #undef _GLIBCXX_HAVE_ENOLINK */
#pragma empty_line
/* Define if ENOSR exists. */
/* #undef _GLIBCXX_HAVE_ENOSR */
#pragma empty_line
/* Define if ENOSTR exists. */
/* #undef _GLIBCXX_HAVE_ENOSTR */
#pragma empty_line
/* Define if ENOTRECOVERABLE exists. */
/* #undef _GLIBCXX_HAVE_ENOTRECOVERABLE */
#pragma empty_line
/* Define if ENOTSUP exists. */
/* #undef _GLIBCXX_HAVE_ENOTSUP */
#pragma empty_line
/* Define if EOVERFLOW exists. */
/* #undef _GLIBCXX_HAVE_EOVERFLOW */
#pragma empty_line
/* Define if EOWNERDEAD exists. */
/* #undef _GLIBCXX_HAVE_EOWNERDEAD */
#pragma empty_line
/* Define if EPROTO exists. */
/* #undef _GLIBCXX_HAVE_EPROTO */
#pragma empty_line
/* Define if ETIME exists. */
/* #undef _GLIBCXX_HAVE_ETIME */
#pragma empty_line
/* Define if ETXTBSY exists. */
/* #undef _GLIBCXX_HAVE_ETXTBSY */
#pragma empty_line
/* Define to 1 if you have the <execinfo.h> header file. */
/* #undef _GLIBCXX_HAVE_EXECINFO_H */
#pragma empty_line
/* Define to 1 if you have the `expf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `expl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fabsf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fabsl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <fenv.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `finite' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `finitef' function. */
/* #undef _GLIBCXX_HAVE_FINITEF */
#pragma empty_line
/* Define to 1 if you have the `finitel' function. */
/* #undef _GLIBCXX_HAVE_FINITEL */
#pragma empty_line
/* Define to 1 if you have the <float.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `floorf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `floorl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fmodf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fmodl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fpclass' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <fp.h> header file. */
/* #undef _GLIBCXX_HAVE_FP_H */
#pragma empty_line
/* Define to 1 if you have the `frexpf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `frexpl' function. */
#pragma empty_line
#pragma empty_line
/* Define if _Unwind_GetIPInfo is available. */
#pragma empty_line
#pragma empty_line
/* Define if gthr-default.h exists (meaning that threading support is
enabled). */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `hypot' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `hypotf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `hypotl' function. */
#pragma empty_line
#pragma empty_line
/* Define if you have the iconv() function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <ieeefp.h> header file. */
/* #undef _GLIBCXX_HAVE_IEEEFP_H */
#pragma empty_line
/* Define if int64_t is available in <stdint.h>. */
#pragma empty_line
#pragma empty_line
/* Define if int64_t is a long. */
/* #undef _GLIBCXX_HAVE_INT64_T_LONG */
#pragma empty_line
/* Define if int64_t is a long long. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <inttypes.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isinf' function. */
/* #undef _GLIBCXX_HAVE_ISINF */
#pragma empty_line
/* Define to 1 if you have the `isinff' function. */
/* #undef _GLIBCXX_HAVE_ISINFF */
#pragma empty_line
/* Define to 1 if you have the `isinfl' function. */
/* #undef _GLIBCXX_HAVE_ISINFL */
#pragma empty_line
/* Define to 1 if you have the `isnan' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isnanf' function. */
/* #undef _GLIBCXX_HAVE_ISNANF */
#pragma empty_line
/* Define to 1 if you have the `isnanl' function. */
/* #undef _GLIBCXX_HAVE_ISNANL */
#pragma empty_line
/* Defined if iswblank exists. */
#pragma empty_line
#pragma empty_line
/* Define if LC_MESSAGES is available in <locale.h>. */
/* #undef _GLIBCXX_HAVE_LC_MESSAGES */
#pragma empty_line
/* Define to 1 if you have the `ldexpf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `ldexpl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <libintl.h> header file. */
/* #undef _GLIBCXX_HAVE_LIBINTL_H */
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
/* #undef _GLIBCXX_HAVE_LIMIT_AS */
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
/* #undef _GLIBCXX_HAVE_LIMIT_DATA */
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
/* #undef _GLIBCXX_HAVE_LIMIT_FSIZE */
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
/* #undef _GLIBCXX_HAVE_LIMIT_RSS */
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
/* #undef _GLIBCXX_HAVE_LIMIT_VMEM */
#pragma empty_line
/* Define if futex syscall is available. */
/* #undef _GLIBCXX_HAVE_LINUX_FUTEX */
#pragma empty_line
/* Define to 1 if you have the <locale.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `log10f' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `log10l' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `logf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `logl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <machine/endian.h> header file. */
/* #undef _GLIBCXX_HAVE_MACHINE_ENDIAN_H */
#pragma empty_line
/* Define to 1 if you have the <machine/param.h> header file. */
/* #undef _GLIBCXX_HAVE_MACHINE_PARAM_H */
#pragma empty_line
/* Define if mbstate_t exists in wchar.h. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <memory.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `modf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `modff' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `modfl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <nan.h> header file. */
/* #undef _GLIBCXX_HAVE_NAN_H */
#pragma empty_line
/* Define if poll is available in <poll.h>. */
/* #undef _GLIBCXX_HAVE_POLL */
#pragma empty_line
/* Define to 1 if you have the `powf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `powl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `qfpclass' function. */
/* #undef _GLIBCXX_HAVE_QFPCLASS */
#pragma empty_line
/* Define to 1 if you have the `setenv' function. */
/* #undef _GLIBCXX_HAVE_SETENV */
#pragma empty_line
/* Define to 1 if you have the `sincos' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sincosf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sincosl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinhf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinhl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sqrtf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sqrtl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <stdbool.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <stdint.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <stdlib.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define if strerror_l is available in <string.h>. */
/* #undef _GLIBCXX_HAVE_STRERROR_L */
#pragma empty_line
/* Define if strerror_r is available in <string.h>. */
/* #undef _GLIBCXX_HAVE_STRERROR_R */
#pragma empty_line
/* Define to 1 if you have the <strings.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <string.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `strtof' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `strtold' function. */
#pragma empty_line
#pragma empty_line
/* Define if strxfrm_l is available in <string.h>. */
/* #undef _GLIBCXX_HAVE_STRXFRM_L */
#pragma empty_line
/* Define to 1 if you have the <sys/filio.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_FILIO_H */
#pragma empty_line
/* Define to 1 if you have the <sys/ioctl.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_IOCTL_H */
#pragma empty_line
/* Define to 1 if you have the <sys/ipc.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_IPC_H */
#pragma empty_line
/* Define to 1 if you have the <sys/isa_defs.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_ISA_DEFS_H */
#pragma empty_line
/* Define to 1 if you have the <sys/machine.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_MACHINE_H */
#pragma empty_line
/* Define to 1 if you have the <sys/param.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/resource.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_RESOURCE_H */
#pragma empty_line
/* Define to 1 if you have the <sys/sem.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_SEM_H */
#pragma empty_line
/* Define to 1 if you have the <sys/stat.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/time.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/types.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/uio.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_UIO_H */
#pragma empty_line
/* Define if S_IFREG is available in <sys/stat.h>. */
/* #undef _GLIBCXX_HAVE_S_IFREG */
#pragma empty_line
/* Define if S_IFREG is available in <sys/stat.h>. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanhf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanhl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <tgmath.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if the target supports thread-local storage. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <unistd.h> header file. */
#pragma empty_line
#pragma empty_line
/* Defined if vfwscanf exists. */
#pragma empty_line
#pragma empty_line
/* Defined if vswscanf exists. */
#pragma empty_line
#pragma empty_line
/* Defined if vwscanf exists. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <wchar.h> header file. */
#pragma empty_line
#pragma empty_line
/* Defined if wcstof exists. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <wctype.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define if writev is available in <sys/uio.h>. */
/* #undef _GLIBCXX_HAVE_WRITEV */
#pragma empty_line
/* Define to 1 if you have the `_acosf' function. */
/* #undef _GLIBCXX_HAVE__ACOSF */
#pragma empty_line
/* Define to 1 if you have the `_acosl' function. */
/* #undef _GLIBCXX_HAVE__ACOSL */
#pragma empty_line
/* Define to 1 if you have the `_asinf' function. */
/* #undef _GLIBCXX_HAVE__ASINF */
#pragma empty_line
/* Define to 1 if you have the `_asinl' function. */
/* #undef _GLIBCXX_HAVE__ASINL */
#pragma empty_line
/* Define to 1 if you have the `_atan2f' function. */
/* #undef _GLIBCXX_HAVE__ATAN2F */
#pragma empty_line
/* Define to 1 if you have the `_atan2l' function. */
/* #undef _GLIBCXX_HAVE__ATAN2L */
#pragma empty_line
/* Define to 1 if you have the `_atanf' function. */
/* #undef _GLIBCXX_HAVE__ATANF */
#pragma empty_line
/* Define to 1 if you have the `_atanl' function. */
/* #undef _GLIBCXX_HAVE__ATANL */
#pragma empty_line
/* Define to 1 if you have the `_ceilf' function. */
/* #undef _GLIBCXX_HAVE__CEILF */
#pragma empty_line
/* Define to 1 if you have the `_ceill' function. */
/* #undef _GLIBCXX_HAVE__CEILL */
#pragma empty_line
/* Define to 1 if you have the `_cosf' function. */
/* #undef _GLIBCXX_HAVE__COSF */
#pragma empty_line
/* Define to 1 if you have the `_coshf' function. */
/* #undef _GLIBCXX_HAVE__COSHF */
#pragma empty_line
/* Define to 1 if you have the `_coshl' function. */
/* #undef _GLIBCXX_HAVE__COSHL */
#pragma empty_line
/* Define to 1 if you have the `_cosl' function. */
/* #undef _GLIBCXX_HAVE__COSL */
#pragma empty_line
/* Define to 1 if you have the `_expf' function. */
/* #undef _GLIBCXX_HAVE__EXPF */
#pragma empty_line
/* Define to 1 if you have the `_expl' function. */
/* #undef _GLIBCXX_HAVE__EXPL */
#pragma empty_line
/* Define to 1 if you have the `_fabsf' function. */
/* #undef _GLIBCXX_HAVE__FABSF */
#pragma empty_line
/* Define to 1 if you have the `_fabsl' function. */
/* #undef _GLIBCXX_HAVE__FABSL */
#pragma empty_line
/* Define to 1 if you have the `_finite' function. */
/* #undef _GLIBCXX_HAVE__FINITE */
#pragma empty_line
/* Define to 1 if you have the `_finitef' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `_finitel' function. */
/* #undef _GLIBCXX_HAVE__FINITEL */
#pragma empty_line
/* Define to 1 if you have the `_floorf' function. */
/* #undef _GLIBCXX_HAVE__FLOORF */
#pragma empty_line
/* Define to 1 if you have the `_floorl' function. */
/* #undef _GLIBCXX_HAVE__FLOORL */
#pragma empty_line
/* Define to 1 if you have the `_fmodf' function. */
/* #undef _GLIBCXX_HAVE__FMODF */
#pragma empty_line
/* Define to 1 if you have the `_fmodl' function. */
/* #undef _GLIBCXX_HAVE__FMODL */
#pragma empty_line
/* Define to 1 if you have the `_fpclass' function. */
/* #undef _GLIBCXX_HAVE__FPCLASS */
#pragma empty_line
/* Define to 1 if you have the `_frexpf' function. */
/* #undef _GLIBCXX_HAVE__FREXPF */
#pragma empty_line
/* Define to 1 if you have the `_frexpl' function. */
/* #undef _GLIBCXX_HAVE__FREXPL */
#pragma empty_line
/* Define to 1 if you have the `_hypot' function. */
/* #undef _GLIBCXX_HAVE__HYPOT */
#pragma empty_line
/* Define to 1 if you have the `_hypotf' function. */
/* #undef _GLIBCXX_HAVE__HYPOTF */
#pragma empty_line
/* Define to 1 if you have the `_hypotl' function. */
/* #undef _GLIBCXX_HAVE__HYPOTL */
#pragma empty_line
/* Define to 1 if you have the `_isinf' function. */
/* #undef _GLIBCXX_HAVE__ISINF */
#pragma empty_line
/* Define to 1 if you have the `_isinff' function. */
/* #undef _GLIBCXX_HAVE__ISINFF */
#pragma empty_line
/* Define to 1 if you have the `_isinfl' function. */
/* #undef _GLIBCXX_HAVE__ISINFL */
#pragma empty_line
/* Define to 1 if you have the `_isnan' function. */
/* #undef _GLIBCXX_HAVE__ISNAN */
#pragma empty_line
/* Define to 1 if you have the `_isnanf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `_isnanl' function. */
/* #undef _GLIBCXX_HAVE__ISNANL */
#pragma empty_line
/* Define to 1 if you have the `_ldexpf' function. */
/* #undef _GLIBCXX_HAVE__LDEXPF */
#pragma empty_line
/* Define to 1 if you have the `_ldexpl' function. */
/* #undef _GLIBCXX_HAVE__LDEXPL */
#pragma empty_line
/* Define to 1 if you have the `_log10f' function. */
/* #undef _GLIBCXX_HAVE__LOG10F */
#pragma empty_line
/* Define to 1 if you have the `_log10l' function. */
/* #undef _GLIBCXX_HAVE__LOG10L */
#pragma empty_line
/* Define to 1 if you have the `_logf' function. */
/* #undef _GLIBCXX_HAVE__LOGF */
#pragma empty_line
/* Define to 1 if you have the `_logl' function. */
/* #undef _GLIBCXX_HAVE__LOGL */
#pragma empty_line
/* Define to 1 if you have the `_modf' function. */
/* #undef _GLIBCXX_HAVE__MODF */
#pragma empty_line
/* Define to 1 if you have the `_modff' function. */
/* #undef _GLIBCXX_HAVE__MODFF */
#pragma empty_line
/* Define to 1 if you have the `_modfl' function. */
/* #undef _GLIBCXX_HAVE__MODFL */
#pragma empty_line
/* Define to 1 if you have the `_powf' function. */
/* #undef _GLIBCXX_HAVE__POWF */
#pragma empty_line
/* Define to 1 if you have the `_powl' function. */
/* #undef _GLIBCXX_HAVE__POWL */
#pragma empty_line
/* Define to 1 if you have the `_qfpclass' function. */
/* #undef _GLIBCXX_HAVE__QFPCLASS */
#pragma empty_line
/* Define to 1 if you have the `_sincos' function. */
/* #undef _GLIBCXX_HAVE__SINCOS */
#pragma empty_line
/* Define to 1 if you have the `_sincosf' function. */
/* #undef _GLIBCXX_HAVE__SINCOSF */
#pragma empty_line
/* Define to 1 if you have the `_sincosl' function. */
/* #undef _GLIBCXX_HAVE__SINCOSL */
#pragma empty_line
/* Define to 1 if you have the `_sinf' function. */
/* #undef _GLIBCXX_HAVE__SINF */
#pragma empty_line
/* Define to 1 if you have the `_sinhf' function. */
/* #undef _GLIBCXX_HAVE__SINHF */
#pragma empty_line
/* Define to 1 if you have the `_sinhl' function. */
/* #undef _GLIBCXX_HAVE__SINHL */
#pragma empty_line
/* Define to 1 if you have the `_sinl' function. */
/* #undef _GLIBCXX_HAVE__SINL */
#pragma empty_line
/* Define to 1 if you have the `_sqrtf' function. */
/* #undef _GLIBCXX_HAVE__SQRTF */
#pragma empty_line
/* Define to 1 if you have the `_sqrtl' function. */
/* #undef _GLIBCXX_HAVE__SQRTL */
#pragma empty_line
/* Define to 1 if you have the `_tanf' function. */
/* #undef _GLIBCXX_HAVE__TANF */
#pragma empty_line
/* Define to 1 if you have the `_tanhf' function. */
/* #undef _GLIBCXX_HAVE__TANHF */
#pragma empty_line
/* Define to 1 if you have the `_tanhl' function. */
/* #undef _GLIBCXX_HAVE__TANHL */
#pragma empty_line
/* Define to 1 if you have the `_tanl' function. */
/* #undef _GLIBCXX_HAVE__TANL */
#pragma empty_line
/* Define as const if the declaration of iconv() needs const. */
#pragma empty_line
#pragma empty_line
/* Define to the sub-directory in which libtool stores uninstalled libraries.
*/
#pragma empty_line
#pragma empty_line
/* Name of package */
/* #undef _GLIBCXX_PACKAGE */
#pragma empty_line
/* Define to the address where bug reports for this package should be sent. */
#pragma empty_line
#pragma empty_line
/* Define to the full name of this package. */
#pragma empty_line
#pragma empty_line
/* Define to the full name and version of this package. */
#pragma empty_line
#pragma empty_line
/* Define to the one symbol short name of this package. */
#pragma empty_line
#pragma empty_line
/* Define to the home page for this package. */
#pragma empty_line
#pragma empty_line
/* Define to the version of this package. */
#pragma empty_line
#pragma empty_line
/* The size of `char', as computed by sizeof. */
/* #undef SIZEOF_CHAR */
#pragma empty_line
/* The size of `int', as computed by sizeof. */
/* #undef SIZEOF_INT */
#pragma empty_line
/* The size of `long', as computed by sizeof. */
/* #undef SIZEOF_LONG */
#pragma empty_line
/* The size of `short', as computed by sizeof. */
/* #undef SIZEOF_SHORT */
#pragma empty_line
/* The size of `void *', as computed by sizeof. */
/* #undef SIZEOF_VOID_P */
#pragma empty_line
/* Define to 1 if you have the ANSI C header files. */
#pragma empty_line
#pragma empty_line
/* Version number of package */
/* #undef _GLIBCXX_VERSION */
#pragma empty_line
/* Define if builtin atomic operations for bool are supported on this host. */
#pragma empty_line
#pragma empty_line
/* Define if builtin atomic operations for short are supported on this host.
*/
#pragma empty_line
#pragma empty_line
/* Define if builtin atomic operations for int are supported on this host. */
#pragma empty_line
#pragma empty_line
/* Define if builtin atomic operations for long long are supported on this
host. */
#pragma empty_line
#pragma empty_line
/* Define to use concept checking code from the boost libraries. */
/* #undef _GLIBCXX_CONCEPT_CHECKS */
#pragma empty_line
/* Define if a fully dynamic basic_string is wanted. */
#pragma empty_line
#pragma empty_line
/* Define if gthreads library is available. */
/* #undef _GLIBCXX_HAS_GTHREADS */
#pragma empty_line
/* Define to 1 if a full hosted library is built, or 0 if freestanding. */
#pragma empty_line
#pragma empty_line
/* Define if compatibility should be provided for -mlong-double-64. */
#pragma empty_line
/* Define if ptrdiff_t is int. */
/* #undef _GLIBCXX_PTRDIFF_T_IS_INT */
#pragma empty_line
/* Define if using setrlimit to set resource limits during "make check" */
/* #undef _GLIBCXX_RES_LIMITS */
#pragma empty_line
/* Define if size_t is unsigned int. */
/* #undef _GLIBCXX_SIZE_T_IS_UINT */
#pragma empty_line
/* Define if the compiler is configured for setjmp/longjmp exceptions. */
#pragma empty_line
#pragma empty_line
/* Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2. */
#pragma empty_line
#pragma empty_line
/* Define to use symbol versioning in the shared library. */
#pragma empty_line
#pragma empty_line
/* Define to use darwin versioning in the shared library. */
/* #undef _GLIBCXX_SYMVER_DARWIN */
#pragma empty_line
/* Define to use GNU versioning in the shared library. */
#pragma empty_line
#pragma empty_line
/* Define to use GNU namespace versioning in the shared library. */
/* #undef _GLIBCXX_SYMVER_GNU_NAMESPACE */
#pragma empty_line
/* Define if C99 functions or macros from <wchar.h>, <math.h>, <complex.h>,
<stdio.h>, and <stdlib.h> can be used or exposed. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <complex.h> should be used in <complex>. Using
compiler builtins for these functions requires corresponding C99 library
functions to be present. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <complex.h> should be used in <tr1/complex>.
Using compiler builtins for these functions requires corresponding C99
library functions to be present. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <ctype.h> should be imported in <tr1/cctype> in
namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <fenv.h> should be imported in <tr1/cfenv> in
namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <inttypes.h> should be imported in
<tr1/cinttypes> in namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if wchar_t C99 functions in <inttypes.h> should be imported in
<tr1/cinttypes> in namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions or macros in <math.h> should be imported in <cmath>
in namespace std. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions or macros in <math.h> should be imported in
<tr1/cmath> in namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 types in <stdint.h> should be imported in <tr1/cstdint> in
namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Defined if clock_gettime has monotonic clock support. */
/* #undef _GLIBCXX_USE_CLOCK_MONOTONIC */
#pragma empty_line
/* Defined if clock_gettime has realtime clock support. */
/* #undef _GLIBCXX_USE_CLOCK_REALTIME */
#pragma empty_line
/* Define if ISO/IEC TR 24733 decimal floating point types are supported on
this host. */
/* #undef _GLIBCXX_USE_DECIMAL_FLOAT */
#pragma empty_line
/* Defined if gettimeofday is available. */
#pragma empty_line
#pragma empty_line
/* Define if LFS support is available. */
#pragma empty_line
#pragma empty_line
/* Define if code specialized for long long should be used. */
#pragma empty_line
#pragma empty_line
/* Defined if nanosleep is available. */
/* #undef _GLIBCXX_USE_NANOSLEEP */
#pragma empty_line
/* Define if NLS translations are to be used. */
/* #undef _GLIBCXX_USE_NLS */
#pragma empty_line
/* Define if /dev/random and /dev/urandom are available for the random_device
of TR1 (Chapter 5.1). */
#pragma empty_line
#pragma empty_line
/* Defined if sched_yield is available. */
/* #undef _GLIBCXX_USE_SCHED_YIELD */
#pragma empty_line
/* Define if code specialized for wchar_t should be used. */
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iostream" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ostream" 1 3
// Output streams -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ostream
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.6.2 Output streams
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ostream" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 1 3
// Iostreams base classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
// 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ios
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.4 Iostreams base classes
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iosfwd" 1 3
// Forwarding declarations -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file iosfwd
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.2 Forward declarations
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iosfwd" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stringfwd.h" 1 3
// String support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
// 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file stringfwd.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stringfwd.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _Alloc>
class allocator;
#pragma empty_line
/**
* @defgroup strings Strings
*
* @{
*/
#pragma empty_line
template<class _CharT>
struct char_traits;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
#pragma empty_line
template<> struct char_traits<char>;
#pragma empty_line
typedef basic_string<char> string; ///< A string of @c char
#pragma empty_line
#pragma empty_line
template<> struct char_traits<wchar_t>;
#pragma empty_line
typedef basic_string<wchar_t> wstring; ///< A string of @c wchar_t
#pragma line 80 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stringfwd.h" 3
/** @} */
#pragma empty_line
}
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iosfwd" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/postypes.h" 1 3
// Position types -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file postypes.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.4.1 - Types
// ISO C++ 14882: 27.4.3 - Template class fpos
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 40 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/postypes.h" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cwchar
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c wchar.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 21.4
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cstddef
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.1 Types
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __typeof__(sizeof(int)) size_t;
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
using ::ptrdiff_t;
using ::size_t;
#pragma empty_line
}
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 18 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* mingw.org's version macros: these make gcc to define
MINGW32_SUPPORTS_MT_EH and to use the _CRT_MT global
and the __mingwthr_key_dtor() function from the MinGW
CRT in its private gthr-win32.h header. */
#pragma line 47 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* For 32-bits we have always to prefix by underscore. */
#pragma line 62 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* Use alias for msvcr80 export of get/set_output_format. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set VC specific compiler target macros. */
#pragma line 79 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 3
/* This gives wrong (600 instead of 300) value if -march=i386 is specified
but we cannot check for__i386__ as it is defined for all 32-bit CPUs. */
#pragma line 10 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma empty_line
/* C/C++ specific language defines. */
#pragma line 32 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* Note the extern. This is needed to work around GCC's
limitations in handling dllimport attribute. */
#pragma line 147 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* Attribute `nonnull' was valid as of gcc 3.3. We don't use GCC's
variadiac macro facility, because variadic macros cause syntax
errors with --traditional-cpp. */
#pragma line 225 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* High byte is the major version, low byte is the minor. */
#pragma line 277 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 674 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_directx.h" 1 3
#pragma line 674 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_ddk.h" 1 3
#pragma line 675 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma line 13 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __builtin_va_list __gnuc_va_list;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __gnuc_va_list va_list;
#pragma line 46 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
/* Use GCC builtins */
#pragma line 99 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
}
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma line 277 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 316 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* We have to define _DLL for gcc based mingw version. This define is set
by VC, when DLL-based runtime is used. So, gcc based runtime just have
DLL-base runtime, therefore this define has to be set.
As our headers are possibly used by windows compiler having a static
C-runtime, we make this definition gnu compiler specific here. */
#pragma line 372 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef unsigned int size_t;
#pragma line 382 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef int ssize_t;
#pragma line 394 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef int intptr_t;
#pragma line 407 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef unsigned int uintptr_t;
#pragma line 420 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef int ptrdiff_t;
#pragma line 436 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef unsigned short wint_t;
typedef unsigned short wctype_t;
#pragma line 456 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef int errno_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long __time32_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ typedef long long __time64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __time32_t time_t;
#pragma line 518 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* _dowildcard is an int that controls the globbing of the command line.
* The MinGW32 (mingw.org) runtime calls it _CRT_glob, so we are adding
* a compatibility definition here: you can use either of _CRT_glob or
* _dowildcard .
* If _dowildcard is non-zero, the command line will be globbed: *.*
* will be expanded to be all files in the startup directory.
* In the mingw-w64 library a _dowildcard variable is defined as being
* 0, therefore command line globbing is DISABLED by default. To turn it
* on and to leave wildcard command line processing MS's globbing code,
* include a line in one of your source modules defining _dowildcard and
* setting it to -1, like so:
* int _dowildcard = -1;
*/
#pragma line 605 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
/* MSVC-isms: */
#pragma empty_line
struct threadlocaleinfostruct;
struct threadmbcinfostruct;
typedef struct threadlocaleinfostruct *pthreadlocinfo;
typedef struct threadmbcinfostruct *pthreadmbcinfo;
struct __lc_time_data;
#pragma empty_line
typedef struct localeinfo_struct {
pthreadlocinfo locinfo;
pthreadmbcinfo mbcinfo;
} _locale_tstruct,*_locale_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct tagLC_ID {
unsigned short wLanguage;
unsigned short wCountry;
unsigned short wCodePage;
} LC_ID,*LPLC_ID;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct threadlocaleinfostruct {
int refcount;
unsigned int lc_codepage;
unsigned int lc_collate_cp;
unsigned long lc_handle[6];
LC_ID lc_id[6];
struct {
char *locale;
wchar_t *wlocale;
int *refcount;
int *wrefcount;
} lc_category[6];
int lc_clike;
int mb_cur_max;
int *lconv_intl_refcount;
int *lconv_num_refcount;
int *lconv_mon_refcount;
struct lconv *lconv;
int *ctype1_refcount;
unsigned short *ctype1;
const unsigned short *pctype;
const unsigned char *pclmap;
const unsigned char *pcumap;
struct __lc_time_data *lc_time_curr;
} threadlocinfo;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
/* mingw-w64 specific functions: */
const char *__mingw_get_crt_info (void);
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma line 9 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma line 27 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;
#pragma line 50 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
extern FILE (* _imp___iob)[]; /* A pointer to an array of FILE */
#pragma line 66 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
typedef unsigned long _fsize_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _wfinddata32_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
_fsize_t size;
wchar_t name[260];
};
#pragma empty_line
struct _wfinddata32i64_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
__extension__ long long size;
wchar_t name[260];
};
#pragma empty_line
struct _wfinddata64i32_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
_fsize_t size;
wchar_t name[260];
};
#pragma empty_line
struct _wfinddata64_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
__extension__ long long size;
wchar_t name[260];
};
/* #endif */
#pragma line 164 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
extern unsigned short ** _imp___pctype;
#pragma line 178 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
extern unsigned short ** _imp___wctype;
#pragma line 193 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
extern unsigned short ** _imp___pwctype;
#pragma line 217 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
int iswalpha(wint_t _C);
__attribute__ ((__dllimport__)) int _iswalpha_l(wint_t _C,_locale_t _Locale);
int iswupper(wint_t _C);
__attribute__ ((__dllimport__)) int _iswupper_l(wint_t _C,_locale_t _Locale);
int iswlower(wint_t _C);
__attribute__ ((__dllimport__)) int _iswlower_l(wint_t _C,_locale_t _Locale);
int iswdigit(wint_t _C);
__attribute__ ((__dllimport__)) int _iswdigit_l(wint_t _C,_locale_t _Locale);
int iswxdigit(wint_t _C);
__attribute__ ((__dllimport__)) int _iswxdigit_l(wint_t _C,_locale_t _Locale);
int iswspace(wint_t _C);
__attribute__ ((__dllimport__)) int _iswspace_l(wint_t _C,_locale_t _Locale);
int iswpunct(wint_t _C);
__attribute__ ((__dllimport__)) int _iswpunct_l(wint_t _C,_locale_t _Locale);
int iswalnum(wint_t _C);
__attribute__ ((__dllimport__)) int _iswalnum_l(wint_t _C,_locale_t _Locale);
int iswprint(wint_t _C);
__attribute__ ((__dllimport__)) int _iswprint_l(wint_t _C,_locale_t _Locale);
int iswgraph(wint_t _C);
__attribute__ ((__dllimport__)) int _iswgraph_l(wint_t _C,_locale_t _Locale);
int iswcntrl(wint_t _C);
__attribute__ ((__dllimport__)) int _iswcntrl_l(wint_t _C,_locale_t _Locale);
int iswascii(wint_t _C);
int isleadbyte(int _C);
__attribute__ ((__dllimport__)) int _isleadbyte_l(int _C,_locale_t _Locale);
wint_t towupper(wint_t _C);
__attribute__ ((__dllimport__)) wint_t _towupper_l(wint_t _C,_locale_t _Locale);
wint_t towlower(wint_t _C);
__attribute__ ((__dllimport__)) wint_t _towlower_l(wint_t _C,_locale_t _Locale);
int iswctype(wint_t _C,wctype_t _Type);
__attribute__ ((__dllimport__)) int _iswctype_l(wint_t _C,wctype_t _Type,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __iswcsymf(wint_t _C);
__attribute__ ((__dllimport__)) int _iswcsymf_l(wint_t _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __iswcsym(wint_t _C);
__attribute__ ((__dllimport__)) int _iswcsym_l(wint_t _C,_locale_t _Locale);
int is_wctype(wint_t _C,wctype_t _Type);
#pragma empty_line
#pragma empty_line
int iswblank(wint_t _C);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wgetcwd(wchar_t *_DstBuf,int _SizeInWords);
__attribute__ ((__dllimport__)) wchar_t * _wgetdcwd(int _Drive,wchar_t *_DstBuf,int _SizeInWords);
wchar_t * _wgetdcwd_nolock(int _Drive,wchar_t *_DstBuf,int _SizeInWords);
__attribute__ ((__dllimport__)) int _wchdir(const wchar_t *_Path);
__attribute__ ((__dllimport__)) int _wmkdir(const wchar_t *_Path);
__attribute__ ((__dllimport__)) int _wrmdir(const wchar_t *_Path);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _waccess(const wchar_t *_Filename,int _AccessMode);
__attribute__ ((__dllimport__)) int _wchmod(const wchar_t *_Filename,int _Mode);
__attribute__ ((__dllimport__)) int _wcreat(const wchar_t *_Filename,int _PermissionMode) ;
__attribute__ ((__dllimport__)) intptr_t _wfindfirst(const wchar_t *_Filename,struct _wfinddata32_t *_FindData);
__attribute__ ((__dllimport__)) int _wfindnext(intptr_t _FindHandle,struct _wfinddata32_t *_FindData);
__attribute__ ((__dllimport__)) int _wunlink(const wchar_t *_Filename);
__attribute__ ((__dllimport__)) int _wrename(const wchar_t *_NewFilename,const wchar_t *_OldFilename);
__attribute__ ((__dllimport__)) wchar_t * _wmktemp(wchar_t *_TemplateName) ;
__attribute__ ((__dllimport__)) intptr_t _wfindfirsti64(const wchar_t *_Filename,struct _wfinddata32i64_t *_FindData);
intptr_t _wfindfirst64i32(const wchar_t *_Filename,struct _wfinddata64i32_t *_FindData);
__attribute__ ((__dllimport__)) intptr_t _wfindfirst64(const wchar_t *_Filename,struct _wfinddata64_t *_FindData);
__attribute__ ((__dllimport__)) int _wfindnexti64(intptr_t _FindHandle,struct _wfinddata32i64_t *_FindData);
int _wfindnext64i32(intptr_t _FindHandle,struct _wfinddata64i32_t *_FindData);
__attribute__ ((__dllimport__)) int _wfindnext64(intptr_t _FindHandle,struct _wfinddata64_t *_FindData);
__attribute__ ((__dllimport__)) errno_t _wsopen_s(int *_FileHandle,const wchar_t *_Filename,int _OpenFlag,int _ShareFlag,int _PermissionFlag);
__attribute__ ((__dllimport__)) int _wopen(const wchar_t *_Filename,int _OpenFlag,...) ;
__attribute__ ((__dllimport__)) int _wsopen(const wchar_t *_Filename,int _OpenFlag,int _ShareFlag,...) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wsetlocale(int _Category,const wchar_t *_Locale);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) intptr_t _wexecl(const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wexecle(const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wexeclp(const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wexeclpe(const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wexecv(const wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t _wexecve(const wchar_t *_Filename,const wchar_t *const *_ArgList,const wchar_t *const *_Env);
__attribute__ ((__dllimport__)) intptr_t _wexecvp(const wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t _wexecvpe(const wchar_t *_Filename,const wchar_t *const *_ArgList,const wchar_t *const *_Env);
__attribute__ ((__dllimport__)) intptr_t _wspawnl(int _Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wspawnle(int _Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wspawnlp(int _Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wspawnlpe(int _Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t _wspawnv(int _Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t _wspawnve(int _Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList,const wchar_t *const *_Env);
__attribute__ ((__dllimport__)) intptr_t _wspawnvp(int _Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t _wspawnvpe(int _Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList,const wchar_t *const *_Env);
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wsystem(const wchar_t *_Command);
#pragma line 360 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
typedef unsigned short _ino_t;
#pragma empty_line
typedef unsigned short ino_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned int _dev_t;
#pragma empty_line
typedef unsigned int dev_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long _off_t;
#pragma empty_line
typedef long off_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ typedef long long _off64_t;
#pragma empty_line
__extension__ typedef long long off64_t;
#pragma line 412 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
struct _stat {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
_off_t st_size;
__time32_t st_atime;
__time32_t st_mtime;
__time32_t st_ctime;
};
#pragma empty_line
#pragma empty_line
struct stat {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
_off_t st_size;
time_t st_atime;
time_t st_mtime;
time_t st_ctime;
};
#pragma empty_line
#pragma empty_line
struct _stati64 {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
__extension__ long long st_size;
__time32_t st_atime;
__time32_t st_mtime;
__time32_t st_ctime;
};
#pragma empty_line
struct _stat64i32 {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
_off_t st_size;
__time64_t st_atime;
__time64_t st_mtime;
__time64_t st_ctime;
};
#pragma empty_line
struct _stat64 {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
__extension__ long long st_size;
__time64_t st_atime;
__time64_t st_mtime;
__time64_t st_ctime;
};
#pragma line 493 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
__attribute__ ((__dllimport__)) int _wstat(const wchar_t *_Name,struct _stat *_Stat);
__attribute__ ((__dllimport__)) int _wstati64(const wchar_t *_Name,struct _stati64 *_Stat);
int _wstat64i32(const wchar_t *_Name,struct _stat64i32 *_Stat);
__attribute__ ((__dllimport__)) int _wstat64(const wchar_t *_Name,struct _stat64 *_Stat);
#pragma line 507 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
__attribute__ ((__dllimport__)) wchar_t *_cgetws(wchar_t *_Buffer) ;
__attribute__ ((__dllimport__)) wint_t _getwch(void);
__attribute__ ((__dllimport__)) wint_t _getwche(void);
__attribute__ ((__dllimport__)) wint_t _putwch(wchar_t _WCh);
__attribute__ ((__dllimport__)) wint_t _ungetwch(wint_t _WCh);
__attribute__ ((__dllimport__)) int _cputws(const wchar_t *_String);
__attribute__ ((__dllimport__)) int _cwprintf(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _cwscanf(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _cwscanf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vcwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _cwprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vcwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
#pragma empty_line
__attribute__ ((__dllimport__)) int _cwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vcwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _cwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vcwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
wint_t _putwch_nolock(wchar_t _WCh);
wint_t _getwch_nolock(void);
wint_t _getwche_nolock(void);
wint_t _ungetwch_nolock(wint_t _WCh);
#pragma line 540 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
__attribute__ ((__dllimport__)) FILE * _wfsopen(const wchar_t *_Filename,const wchar_t *_Mode,int _ShFlag);
#pragma empty_line
#pragma empty_line
wint_t fgetwc(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fgetwchar(void);
wint_t fputwc(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwchar(wchar_t _Ch);
wint_t getwc(FILE *_File);
wint_t getwchar(void);
wint_t putwc(wchar_t _Ch,FILE *_File);
wint_t putwchar(wchar_t _Ch);
wint_t ungetwc(wint_t _Ch,FILE *_File);
wchar_t * fgetws(wchar_t * __restrict__ _Dst,int _SizeInWords,FILE * __restrict__ _File);
int fputws(const wchar_t * __restrict__ _Str,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) wchar_t * _getws(wchar_t *_String) ;
__attribute__ ((__dllimport__)) int _putws(const wchar_t *_Str);
int fwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
int wprintf(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _scwprintf(const wchar_t * __restrict__ _Format,...);
int vfwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
int vwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...) ;
__attribute__ ((__dllimport__)) int _swprintf_l(wchar_t * __restrict__ ,size_t _SizeInWords,const wchar_t * __restrict__ _Format,_locale_t _Locale,... ) ;
__attribute__ ((__dllimport__)) int vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ ,va_list) ;
__attribute__ ((__dllimport__)) int _swprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _vsnwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,va_list _Args) ;
#pragma empty_line
int snwprintf (wchar_t * __restrict__ s, size_t n, const wchar_t * __restrict__ format, ...);
int vsnwprintf (wchar_t * __restrict__ , size_t, const wchar_t * __restrict__ , va_list);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int vwscanf (const wchar_t * __restrict__ , va_list);
int vfwscanf (FILE * __restrict__ ,const wchar_t * __restrict__ ,va_list);
int vswscanf (const wchar_t * __restrict__ ,const wchar_t * __restrict__ ,va_list);
#pragma empty_line
__attribute__ ((__dllimport__)) int _fwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _wprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vfwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _wprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _wprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _fwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _fwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vfwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vfwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _swprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vswprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vswprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _scwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vsnwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList) ;
__attribute__ ((__dllimport__)) int _swprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,va_list _Args);
__attribute__ ((__dllimport__)) int __swprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,...) ;
__attribute__ ((__dllimport__)) int _vswprintf_l(wchar_t * __restrict__ _Dest,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList) ;
__attribute__ ((__dllimport__)) int __vswprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,va_list _Args) ;
#pragma line 621 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
__attribute__ ((__dllimport__)) wchar_t * _wtempnam(const wchar_t *_Directory,const wchar_t *_FilePrefix);
__attribute__ ((__dllimport__)) int _vscwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vscwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
int fwscanf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _fwscanf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
int swscanf(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _swscanf_l(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) int _snwscanf(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _snwscanf_l(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
int wscanf(const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _wscanf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) FILE * _wfdopen(int _FileHandle ,const wchar_t *_Mode);
__attribute__ ((__dllimport__)) FILE * _wfopen(const wchar_t * __restrict__ _Filename,const wchar_t * __restrict__ _Mode) ;
__attribute__ ((__dllimport__)) FILE * _wfreopen(const wchar_t * __restrict__ _Filename,const wchar_t * __restrict__ _Mode,FILE * __restrict__ _OldFile) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) void _wperror(const wchar_t *_ErrMsg);
#pragma empty_line
__attribute__ ((__dllimport__)) FILE * _wpopen(const wchar_t *_Command,const wchar_t *_Mode);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wremove(const wchar_t *_Filename);
__attribute__ ((__dllimport__)) wchar_t * _wtmpnam(wchar_t *_Buffer);
__attribute__ ((__dllimport__)) wint_t _fgetwc_nolock(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwc_nolock(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _ungetwc_nolock(wint_t _Ch,FILE *_File);
#pragma line 669 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
__attribute__ ((__dllimport__)) wchar_t * _itow(int _Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t * _ltow(long _Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t * _ultow(unsigned long _Value,wchar_t *_Dest,int _Radix) ;
double wcstod(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr);
__attribute__ ((__dllimport__)) double _wcstod_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,_locale_t _Locale);
float wcstof( const wchar_t * __restrict__ nptr, wchar_t ** __restrict__ endptr);
#pragma empty_line
float wcstof (const wchar_t * __restrict__, wchar_t ** __restrict__);
long double wcstold (const wchar_t * __restrict__, wchar_t ** __restrict__);
#pragma empty_line
long wcstol(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) long _wcstol_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
unsigned long wcstoul(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) unsigned long _wcstoul_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t * _wgetenv(const wchar_t *_VarName) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) double _wtof(const wchar_t *_Str);
__attribute__ ((__dllimport__)) double _wtof_l(const wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wtoi(const wchar_t *_Str);
__attribute__ ((__dllimport__)) int _wtoi_l(const wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) long _wtol(const wchar_t *_Str);
__attribute__ ((__dllimport__)) long _wtol_l(const wchar_t *_Str,_locale_t _Locale);
#pragma empty_line
__extension__ __attribute__ ((__dllimport__)) wchar_t * _i64tow(long long _Val,wchar_t *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) wchar_t * _ui64tow(unsigned long long _Val,wchar_t *_DstBuf,int _Radix);
__extension__ __attribute__ ((__dllimport__)) long long _wtoi64(const wchar_t *_Str);
__extension__ __attribute__ ((__dllimport__)) long long _wtoi64_l(const wchar_t *_Str,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) long long _wcstoi64(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) long long _wcstoi64_l(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _wcstoui64(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix);
__extension__ __attribute__ ((__dllimport__)) unsigned long long _wcstoui64_l(const wchar_t *_Str,wchar_t **_EndPtr,int _Radix,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wfullpath(wchar_t *_FullPath,const wchar_t *_Path,size_t _SizeInWords);
__attribute__ ((__dllimport__)) void _wmakepath(wchar_t *_ResultPath,const wchar_t *_Drive,const wchar_t *_Dir,const wchar_t *_Filename,const wchar_t *_Ext);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _wputenv(const wchar_t *_EnvString);
__attribute__ ((__dllimport__)) void _wsearchenv(const wchar_t *_Filename,const wchar_t *_EnvVar,wchar_t *_ResultPath) ;
__attribute__ ((__dllimport__)) void _wsplitpath(const wchar_t *_FullPath,wchar_t *_Drive,wchar_t *_Dir,wchar_t *_Filename,wchar_t *_Ext) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wcsdup(const wchar_t *_Str);
wchar_t * wcscat(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source) ;
wchar_t * wcschr(const wchar_t *_Str,wchar_t _Ch);
int wcscmp(const wchar_t *_Str1,const wchar_t *_Str2);
wchar_t * wcscpy(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source) ;
size_t wcscspn(const wchar_t *_Str,const wchar_t *_Control);
size_t wcslen(const wchar_t *_Str);
size_t wcsnlen(const wchar_t *_Src,size_t _MaxCount);
wchar_t * wcsncat(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count) ;
int wcsncmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
wchar_t * wcsncpy(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count) ;
wchar_t * _wcsncpy_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t _Count,_locale_t _Locale) ;
wchar_t * wcspbrk(const wchar_t *_Str,const wchar_t *_Control);
wchar_t * wcsrchr(const wchar_t *_Str,wchar_t _Ch);
size_t wcsspn(const wchar_t *_Str,const wchar_t *_Control);
wchar_t * wcsstr(const wchar_t *_Str,const wchar_t *_SubStr);
wchar_t * wcstok(wchar_t * __restrict__ _Str,const wchar_t * __restrict__ _Delim) ;
__attribute__ ((__dllimport__)) wchar_t * _wcserror(int _ErrNum) ;
__attribute__ ((__dllimport__)) wchar_t * __wcserror(const wchar_t *_Str) ;
__attribute__ ((__dllimport__)) int _wcsicmp(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcsicmp_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsnicmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsnicmp_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t * _wcsnset(wchar_t *_Str,wchar_t _Val,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) wchar_t * _wcsrev(wchar_t *_Str);
__attribute__ ((__dllimport__)) wchar_t * _wcsset(wchar_t *_Str,wchar_t _Val) ;
__attribute__ ((__dllimport__)) wchar_t * _wcslwr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcslwr_l(wchar_t *_String,_locale_t _Locale) ;
__attribute__ ((__dllimport__)) wchar_t * _wcsupr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcsupr_l(wchar_t *_String,_locale_t _Locale) ;
size_t wcsxfrm(wchar_t * __restrict__ _Dst,const wchar_t * __restrict__ _Src,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t _wcsxfrm_l(wchar_t * __restrict__ _Dst,const wchar_t * __restrict__ _Src,size_t _MaxCount,_locale_t _Locale);
int wcscoll(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcscoll_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsicoll(const wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int _wcsicoll_l(const wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsncoll(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsncoll_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _wcsnicoll(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int _wcsnicoll_l(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
#pragma empty_line
#pragma empty_line
wchar_t * wcsdup(const wchar_t *_Str) ;
#pragma empty_line
int wcsicmp(const wchar_t *_Str1,const wchar_t *_Str2) ;
int wcsnicmp(const wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount) ;
wchar_t * wcsnset(wchar_t *_Str,wchar_t _Val,size_t _MaxCount) ;
wchar_t * wcsrev(wchar_t *_Str) ;
wchar_t * wcsset(wchar_t *_Str,wchar_t _Val) ;
wchar_t * wcslwr(wchar_t *_Str) ;
wchar_t * wcsupr(wchar_t *_Str) ;
int wcsicoll(const wchar_t *_Str1,const wchar_t *_Str2) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) wchar_t * _wasctime(const struct tm *_Tm);
wchar_t * _wctime32(const __time32_t *_Time) ;
size_t wcsftime(wchar_t * __restrict__ _Buf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,const struct tm * __restrict__ _Tm);
__attribute__ ((__dllimport__)) size_t _wcsftime_l(wchar_t * __restrict__ _Buf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,const struct tm * __restrict__ _Tm,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t * _wstrdate(wchar_t *_Buffer) ;
__attribute__ ((__dllimport__)) wchar_t * _wstrtime(wchar_t *_Buffer) ;
__attribute__ ((__dllimport__)) wchar_t * _wctime64(const __time64_t *_Time) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
wchar_t * _wctime(const time_t *_Time) ;
#pragma line 816 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
typedef int mbstate_t;
typedef wchar_t _Wint_t;
#pragma empty_line
wint_t btowc(int);
size_t mbrlen(const char * __restrict__ _Ch,size_t _SizeInBytes,mbstate_t * __restrict__ _State);
size_t mbrtowc(wchar_t * __restrict__ _DstCh,const char * __restrict__ _SrcCh,size_t _SizeInBytes,mbstate_t * __restrict__ _State);
size_t mbsrtowcs(wchar_t * __restrict__ _Dest,const char ** __restrict__ _PSrc,size_t _Count,mbstate_t * __restrict__ _State) ;
size_t wcrtomb(char * __restrict__ _Dest,wchar_t _Source,mbstate_t * __restrict__ _State) ;
size_t wcsrtombs(char * __restrict__ _Dest,const wchar_t ** __restrict__ _PSource,size_t _Count,mbstate_t * __restrict__ _State) ;
int wctob(wint_t _WCh);
#pragma empty_line
#pragma empty_line
wchar_t * wmemset(wchar_t *s, wchar_t c, size_t n);
wchar_t * wmemchr(const wchar_t *s, wchar_t c, size_t n);
int wmemcmp(const wchar_t *s1, const wchar_t *s2,size_t n);
wchar_t * wmemcpy(wchar_t * __restrict__ s1,const wchar_t * __restrict__ s2,size_t n) ;
wchar_t * wmemmove(wchar_t *s1, const wchar_t *s2, size_t n) ;
int fwide(FILE *stream,int mode);
int mbsinit(const mbstate_t *ps);
__extension__ long long wcstoll(const wchar_t * __restrict__ nptr,wchar_t ** __restrict__ endptr, int base);
__extension__ unsigned long long wcstoull(const wchar_t * __restrict__ nptr,wchar_t ** __restrict__ endptr, int base);
#pragma empty_line
#pragma empty_line
void * memmove(void *_Dst,const void *_Src,size_t _MaxCount);
void * memcpy(void * __restrict__ _Dst,const void * __restrict__ _Src,size_t _MaxCount) ;
#pragma line 876 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 3
}
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/wchar_s.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/wchar_s.h" 2 3
#pragma line 881 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wchar.h" 2 3
#pragma line 47 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Need to do a bit of trickery here with mbstate_t as char_traits
// assumes it is in wchar.h, regardless of wchar_t specializations.
#pragma line 64 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 3
namespace std {
#pragma empty_line
using ::mbstate_t;
#pragma empty_line
}
#pragma empty_line
// Get rid of those macros defined in <wchar.h> in lieu of real functions.
#pragma line 138 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 3
namespace std {
#pragma empty_line
using ::wint_t;
#pragma empty_line
using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
#pragma empty_line
using ::vfwscanf;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::vswscanf;
#pragma empty_line
using ::vwprintf;
#pragma empty_line
using ::vwscanf;
#pragma empty_line
using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;
#pragma empty_line
using ::wcstof;
#pragma empty_line
using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;
#pragma empty_line
#pragma empty_line
inline wchar_t*
wcschr(wchar_t* __p, wchar_t __c)
{ return wcschr(const_cast<const wchar_t*>(__p), __c); }
#pragma empty_line
inline wchar_t*
wcspbrk(wchar_t* __s1, const wchar_t* __s2)
{ return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
#pragma empty_line
inline wchar_t*
wcsrchr(wchar_t* __p, wchar_t __c)
{ return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
#pragma empty_line
inline wchar_t*
wcsstr(wchar_t* __s1, const wchar_t* __s2)
{ return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
#pragma empty_line
inline wchar_t*
wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::wcstold;
#pragma line 257 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 3
using ::wcstoll;
using ::wcstoull;
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
namespace std {
#pragma empty_line
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
#pragma empty_line
}
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/postypes.h" 2 3
#pragma empty_line
// XXX If <stdint.h> is really needed, make sure to define the macros
// before including it, in order not to break <tr1/cstdint> (and <cstdint>
// in C++0x). Reconsider all this as soon as possible...
#pragma line 69 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/postypes.h" 3
namespace std {
#pragma empty_line
// The types streamoff, streampos and wstreampos and the class
// template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2,
// 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbiage, the
// behaviour of these types is mostly implementation defined or
// unspecified. The behaviour in this implementation is as noted
// below.
#pragma empty_line
/**
* @brief Type used by fpos, char_traits<char>, and char_traits<wchar_t>.
*
* In clauses 21.1.3.1 and 27.4.1 streamoff is described as an
* implementation defined type.
* Note: In versions of GCC up to and including GCC 3.3, streamoff
* was typedef long.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long long streamoff;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/// Integral type for I/O operation counts and buffer sizes.
typedef ptrdiff_t streamsize; // Signed integral type
#pragma empty_line
/**
* @brief Class representing stream positions.
*
* The standard places no requirements upon the template parameter StateT.
* In this implementation StateT must be DefaultConstructible,
* CopyConstructible and Assignable. The standard only requires that fpos
* should contain a member of type StateT. In this implementation it also
* contains an offset stored as a signed integer.
*
* @param StateT Type passed to and returned from state().
*/
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
#pragma empty_line
public:
// The standard doesn't require that fpos objects can be default
// constructed. This implementation provides a default
// constructor that initializes the offset to 0 and default
// constructs the state.
fpos()
: _M_off(0), _M_state() { }
#pragma empty_line
// The standard requires that fpos objects can be constructed
// from streamoff objects using the constructor syntax, and
// fails to give any meaningful semantics. In this
// implementation implicit conversion is also allowed, and this
// constructor stores the streamoff as the offset and default
// constructs the state.
/// Construct position from offset.
fpos(streamoff __off)
: _M_off(__off), _M_state() { }
#pragma empty_line
/// Convert to streamoff.
operator streamoff() const { return _M_off; }
#pragma empty_line
/// Remember the value of @a st.
void
state(_StateT __st)
{ _M_state = __st; }
#pragma empty_line
/// Return the last set value of @a st.
_StateT
state() const
{ return _M_state; }
#pragma empty_line
// The standard requires that this operator must be defined, but
// gives no semantics. In this implementation it just adds its
// argument to the stored offset and returns *this.
/// Add offset to this position.
fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// gives no semantics. In this implementation it just subtracts
// its argument from the stored offset and returns *this.
/// Subtract offset from this position.
fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// defines its semantics only in terms of operator-. In this
// implementation it constructs a copy of *this, adds the
// argument to that copy using operator+= and then returns the
// copy.
/// Add position and offset.
fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// defines its semantics only in terms of operator+. In this
// implementation it constructs a copy of *this, subtracts the
// argument from that copy using operator-= and then returns the
// copy.
/// Subtract offset from position.
fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// defines its semantics only in terms of operator+. In this
// implementation it returns the difference between the offset
// stored in *this and in the argument.
/// Subtract position to return offset.
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};
#pragma empty_line
// The standard only requires that operator== must be an
// equivalence relation. In this implementation two fpos<StateT>
// objects belong to the same equivalence class if the contained
// offsets compare equal.
/// Test if equivalent to another position.
template<typename _StateT>
inline bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) == streamoff(__rhs); }
#pragma empty_line
template<typename _StateT>
inline bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) != streamoff(__rhs); }
#pragma empty_line
// Clauses 21.1.3.1 and 21.1.3.2 describe streampos and wstreampos
// as implementation defined types, but clause 27.2 requires that
// they must both be typedefs for fpos<mbstate_t>
/// File position for char streams.
typedef fpos<mbstate_t> streampos;
/// File position for wchar_t streams.
typedef fpos<mbstate_t> wstreampos;
#pragma line 238 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/postypes.h" 3
}
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iosfwd" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @defgroup io I/O
*
* Nearly all of the I/O classes are parameterized on the type of
* characters they read and write. (The major exception is ios_base at
* the top of the hierarchy.) This is a change from pre-Standard
* streams, which were not templates.
*
* For ease of use and compatibility, all of the basic_* I/O-related
* classes are given typedef names for both of the builtin character
* widths (wide and narrow). The typedefs are the same as the
* pre-Standard names, for example:
*
* @code
* typedef basic_ifstream<char> ifstream;
* @endcode
*
* Because properly forward-declaring these classes can be difficult, you
* should not do it yourself. Instead, include the <iosfwd>
* header, which contains only declarations of all the I/O classes as
* well as the typedefs. Trying to forward-declare the typedefs
* themselves (e.g., <code>class ostream;</code>) is not valid ISO C++.
*
* For more specific declarations, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html
*
* @{
*/
class ios_base;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ios;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_istream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ostream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_iostream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringbuf;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_istringstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_ostringstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_filebuf;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ifstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ofstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_fstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class istreambuf_iterator;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class ostreambuf_iterator;
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// Not included. (??? Apparently no LWG number?)
#pragma empty_line
typedef basic_ios<char> ios; ///< @isiosfwd
typedef basic_streambuf<char> streambuf; ///< @isiosfwd
typedef basic_istream<char> istream; ///< @isiosfwd
typedef basic_ostream<char> ostream; ///< @isiosfwd
typedef basic_iostream<char> iostream; ///< @isiosfwd
typedef basic_stringbuf<char> stringbuf; ///< @isiosfwd
typedef basic_istringstream<char> istringstream; ///< @isiosfwd
typedef basic_ostringstream<char> ostringstream; ///< @isiosfwd
typedef basic_stringstream<char> stringstream; ///< @isiosfwd
typedef basic_filebuf<char> filebuf; ///< @isiosfwd
typedef basic_ifstream<char> ifstream; ///< @isiosfwd
typedef basic_ofstream<char> ofstream; ///< @isiosfwd
typedef basic_fstream<char> fstream; ///< @isiosfwd
#pragma empty_line
#pragma empty_line
typedef basic_ios<wchar_t> wios; ///< @isiosfwd
typedef basic_streambuf<wchar_t> wstreambuf; ///< @isiosfwd
typedef basic_istream<wchar_t> wistream; ///< @isiosfwd
typedef basic_ostream<wchar_t> wostream; ///< @isiosfwd
typedef basic_iostream<wchar_t> wiostream; ///< @isiosfwd
typedef basic_stringbuf<wchar_t> wstringbuf; ///< @isiosfwd
typedef basic_istringstream<wchar_t> wistringstream; ///< @isiosfwd
typedef basic_ostringstream<wchar_t> wostringstream; ///< @isiosfwd
typedef basic_stringstream<wchar_t> wstringstream; ///< @isiosfwd
typedef basic_filebuf<wchar_t> wfilebuf; ///< @isiosfwd
typedef basic_ifstream<wchar_t> wifstream; ///< @isiosfwd
typedef basic_ofstream<wchar_t> wofstream; ///< @isiosfwd
typedef basic_fstream<wchar_t> wfstream; ///< @isiosfwd
#pragma empty_line
/** @} */
#pragma empty_line
}
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\exception" 1 3
// Exception Handling support header for -*- C++ -*-
#pragma empty_line
// Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
// 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file exception
* This is a Standard C++ Library header.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\exception" 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C++" {
#pragma empty_line
namespace std
{
/**
* @defgroup exceptions Exceptions
* @ingroup diagnostics
*
* Classes and functions for reporting errors via exception classes.
* @{
*/
#pragma empty_line
/**
* @brief Base class for all library exceptions.
*
* This is the base class for all exceptions thrown by the standard
* library, and by certain language expressions. You are free to derive
* your own %exception classes, or use a different hierarchy, or to
* throw non-class data (e.g., fundamental types).
*/
class exception
{
public:
exception() throw() { }
virtual ~exception() throw();
#pragma empty_line
/** Returns a C-style character string describing the general cause
* of the current error. */
virtual const char* what() const throw();
};
#pragma empty_line
/** If an %exception is thrown which is not listed in a function's
* %exception specification, one of these may be thrown. */
class bad_exception : public exception
{
public:
bad_exception() throw() { }
#pragma empty_line
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
virtual ~bad_exception() throw();
#pragma empty_line
// See comment in eh_exception.cc.
virtual const char* what() const throw();
};
#pragma empty_line
/// If you write a replacement %terminate handler, it must be of this type.
typedef void (*terminate_handler) ();
#pragma empty_line
/// If you write a replacement %unexpected handler, it must be of this type.
typedef void (*unexpected_handler) ();
#pragma empty_line
/// Takes a new handler function as an argument, returns the old function.
terminate_handler set_terminate(terminate_handler) throw();
#pragma empty_line
/** The runtime will call this function if %exception handling must be
* abandoned for any reason. It can also be called by the user. */
void terminate() throw() __attribute__ ((__noreturn__));
#pragma empty_line
/// Takes a new handler function as an argument, returns the old function.
unexpected_handler set_unexpected(unexpected_handler) throw();
#pragma empty_line
/** The runtime will call this function if an %exception is thrown which
* violates the function's %exception specification. */
void unexpected() __attribute__ ((__noreturn__));
#pragma empty_line
/** [18.6.4]/1: 'Returns true after completing evaluation of a
* throw-expression until either completing initialization of the
* exception-declaration in the matching handler or entering @c unexpected()
* due to the throw; or after entering @c terminate() for any reason
* other than an explicit call to @c terminate(). [Note: This includes
* stack unwinding [15.2]. end note]'
*
* 2: 'When @c uncaught_exception() is true, throwing an
* %exception can result in a call of @c terminate()
* (15.5.1).'
*/
bool uncaught_exception() throw() __attribute__ ((__pure__));
#pragma empty_line
// @} group exceptions
} // namespace std
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
/**
* @brief A replacement for the standard terminate_handler which
* prints more information about the terminating exception (if any)
* on stderr.
*
* @ingroup exceptions
*
* Call
* @code
* std::set_terminate(__gnu_cxx::__verbose_terminate_handler)
* @endcode
* to use. For more info, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt02ch06s02.html
*
* In 3.4 and later, this is on by default.
*/
void __verbose_terminate_handler();
#pragma empty_line
}
#pragma empty_line
} // extern "C++"
#pragma empty_line
#pragma GCC visibility pop
#pragma line 40 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/char_traits.h" 1 3
// Character Traits for use by standard string and iostream -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file char_traits.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/char_traits.h" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 1 3
// Core algorithmic facilities -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file stl_algobase.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cstddef
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.1 Types
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 2 3
#pragma line 62 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/functexcept.h" 1 3
// Function-Based Exception Support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2004, 2005, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file functexcept.h
* This header provides support for -fno-exceptions.
*/
#pragma empty_line
//
// ISO C++ 14882: 19.1 Exception classes
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\exception_defines.h" 1 3
// -fno-exceptions Support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2006, 2007, 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
//
// ISO C++ 14882: 19.1 Exception classes
//
#pragma empty_line
/** @file exception_defines.h
* This is a Standard C++ Library header.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Iff -fno-exceptions, transform error handling code to work without it.
#pragma line 38 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/functexcept.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
// Helper for exception objects in <except>
void
__throw_bad_exception(void) __attribute__((__noreturn__));
#pragma empty_line
// Helper for exception objects in <new>
void
__throw_bad_alloc(void) __attribute__((__noreturn__));
#pragma empty_line
// Helper for exception objects in <typeinfo>
void
__throw_bad_cast(void) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_bad_typeid(void) __attribute__((__noreturn__));
#pragma empty_line
// Helpers for exception objects in <stdexcept>
void
__throw_logic_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_domain_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_invalid_argument(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_length_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_out_of_range(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_runtime_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_range_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_overflow_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_underflow_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
// Helpers for exception objects in <ios>
void
__throw_ios_failure(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_system_error(int) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_future_error(int) __attribute__((__noreturn__));
#pragma empty_line
// Helpers for exception objects in <functional>
void
__throw_bad_function_call() __attribute__((__noreturn__));
#pragma empty_line
}
#pragma line 63 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/cpp_type_traits.h" 1 3
// The -*- C++ -*- type traits classes for internal use in libstdc++
#pragma empty_line
// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cpp_type_traits.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
// Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 36 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/cpp_type_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
//
// This file provides some compile-time information about various types.
// These representations were designed, on purpose, to be constant-expressions
// and not types as found in <bits/type_traits.h>. In particular, they
// can be used in control structures and the optimizer hopefully will do
// the obvious thing.
//
// Why integral expressions, and not functions nor types?
// Firstly, these compile-time entities are used as template-arguments
// so function return values won't work: We need compile-time entities.
// We're left with types and constant integral expressions.
// Secondly, from the point of view of ease of use, type-based compile-time
// information is -not- *that* convenient. On has to write lots of
// overloaded functions and to hope that the compiler will select the right
// one. As a net effect, the overall structure isn't very clear at first
// glance.
// Thirdly, partial ordering and overload resolution (of function templates)
// is highly costly in terms of compiler-resource. It is a Good Thing to
// keep these resource consumption as least as possible.
//
// See valarray_array.h for a case use.
//
// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
//
// Update 2005: types are also provided and <bits/type_traits.h> has been
// removed.
//
#pragma empty_line
// Forward declaration hack, should really include this from somewhere.
namespace __gnu_cxx {
#pragma empty_line
template<typename _Iterator, typename _Container>
class __normal_iterator;
#pragma empty_line
}
#pragma empty_line
namespace std {
#pragma empty_line
struct __true_type { };
struct __false_type { };
#pragma empty_line
template<bool>
struct __truth_type
{ typedef __false_type __type; };
#pragma empty_line
template<>
struct __truth_type<true>
{ typedef __true_type __type; };
#pragma empty_line
// N.B. The conversions to bool are needed due to the issue
// explained in c++/19404.
template<class _Sp, class _Tp>
struct __traitor
{
enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
typedef typename __truth_type<__value>::__type __type;
};
#pragma empty_line
// Compare for equality of types.
template<typename, typename>
struct __are_same
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<typename _Tp>
struct __are_same<_Tp, _Tp>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
// Holds if the template-argument is a void type.
template<typename _Tp>
struct __is_void
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<>
struct __is_void<void>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
//
// Integer types
//
template<typename _Tp>
struct __is_integer
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
// Thirteen specializations (yes there are eleven standard integer
// types; <em>long long</em> and <em>unsigned long long</em> are
// supported as extensions)
template<>
struct __is_integer<bool>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<>
struct __is_integer<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma line 193 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/cpp_type_traits.h" 3
template<>
struct __is_integer<short>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned short>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<int>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned int>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
//
// Floating point types
//
template<typename _Tp>
struct __is_floating
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
// three specializations (float, double and 'long double')
template<>
struct __is_floating<float>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_floating<double>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_floating<long double>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
//
// Pointer types
//
template<typename _Tp>
struct __is_pointer
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<typename _Tp>
struct __is_pointer<_Tp*>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
//
// Normal iterator type
//
template<typename _Tp>
struct __is_normal_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<typename _Iterator, typename _Container>
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
_Container> >
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
//
// An arithmetic type is an integer type or a floating point type
//
template<typename _Tp>
struct __is_arithmetic
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
{ };
#pragma empty_line
//
// A fundamental type is `void' or and arithmetic type
//
template<typename _Tp>
struct __is_fundamental
: public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
{ };
#pragma empty_line
//
// A scalar type is an arithmetic type or a pointer type
//
template<typename _Tp>
struct __is_scalar
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
{ };
#pragma empty_line
//
// For use in std::copy and std::find overloads for streambuf iterators.
//
template<typename _Tp>
struct __is_char
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<>
struct __is_char<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<>
struct __is_char<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_byte
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<>
struct __is_byte<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_byte<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_byte<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
//
// Move iterator type
//
template<typename _Tp>
struct __is_move_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma line 416 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/cpp_type_traits.h" 3
template<typename _Tp>
class __is_iterator_helper
{
typedef char __one;
typedef struct { char __arr[2]; } __two;
#pragma empty_line
template<typename _Up>
struct _Wrap_type
{ };
#pragma empty_line
template<typename _Up>
static __one __test(_Wrap_type<typename _Up::iterator_category>*);
#pragma empty_line
template<typename _Up>
static __two __test(...);
#pragma empty_line
public:
static const bool __value = (sizeof(__test<_Tp>(0)) == 1
|| __is_pointer<_Tp>::__value);
};
#pragma empty_line
template<typename _Tp>
struct __is_iterator
{
enum { __value = __is_iterator_helper<_Tp>::__value };
typedef typename __truth_type<__value>::__type __type;
};
#pragma empty_line
}
#pragma line 64 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/type_traits.h" 1 3
// -*- C++ -*-
#pragma empty_line
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.
#pragma empty_line
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ext/type_traits.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 32 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/type_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
// Define a nested type if some predicate holds.
template<bool, typename>
struct __enable_if
{ };
#pragma empty_line
template<typename _Tp>
struct __enable_if<true, _Tp>
{ typedef _Tp __type; };
#pragma empty_line
#pragma empty_line
// Conditional expression for types. If true, first, if false, second.
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct __conditional_type
{ typedef _Iftrue __type; };
#pragma empty_line
template<typename _Iftrue, typename _Iffalse>
struct __conditional_type<false, _Iftrue, _Iffalse>
{ typedef _Iffalse __type; };
#pragma empty_line
#pragma empty_line
// Given an integral builtin type, return the corresponding unsigned type.
template<typename _Tp>
struct __add_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
#pragma empty_line
public:
typedef typename __if_type::__type __type;
};
#pragma empty_line
template<>
struct __add_unsigned<char>
{ typedef unsigned char __type; };
#pragma empty_line
template<>
struct __add_unsigned<signed char>
{ typedef unsigned char __type; };
#pragma empty_line
template<>
struct __add_unsigned<short>
{ typedef unsigned short __type; };
#pragma empty_line
template<>
struct __add_unsigned<int>
{ typedef unsigned int __type; };
#pragma empty_line
template<>
struct __add_unsigned<long>
{ typedef unsigned long __type; };
#pragma empty_line
template<>
struct __add_unsigned<long long>
{ typedef unsigned long long __type; };
#pragma empty_line
// Declare but don't define.
template<>
struct __add_unsigned<bool>;
#pragma empty_line
template<>
struct __add_unsigned<wchar_t>;
#pragma empty_line
#pragma empty_line
// Given an integral builtin type, return the corresponding signed type.
template<typename _Tp>
struct __remove_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
#pragma empty_line
public:
typedef typename __if_type::__type __type;
};
#pragma empty_line
template<>
struct __remove_unsigned<char>
{ typedef signed char __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned char>
{ typedef signed char __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned short>
{ typedef short __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned int>
{ typedef int __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned long>
{ typedef long __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned long long>
{ typedef long long __type; };
#pragma empty_line
// Declare but don't define.
template<>
struct __remove_unsigned<bool>;
#pragma empty_line
template<>
struct __remove_unsigned<wchar_t>;
#pragma empty_line
#pragma empty_line
// For use in string and vstring.
template<typename _Type>
inline bool
__is_null_pointer(_Type* __ptr)
{ return __ptr == 0; }
#pragma empty_line
template<typename _Type>
inline bool
__is_null_pointer(_Type)
{ return false; }
#pragma empty_line
#pragma empty_line
// For complex and cmath
template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
struct __promote
{ typedef double __type; };
#pragma empty_line
template<typename _Tp>
struct __promote<_Tp, false>
{ typedef _Tp __type; };
#pragma empty_line
template<typename _Tp, typename _Up>
struct __promote_2
{
private:
typedef typename __promote<_Tp>::__type __type1;
typedef typename __promote<_Up>::__type __type2;
#pragma empty_line
public:
typedef __typeof__(__type1() + __type2()) __type;
};
#pragma empty_line
template<typename _Tp, typename _Up, typename _Vp>
struct __promote_3
{
private:
typedef typename __promote<_Tp>::__type __type1;
typedef typename __promote<_Up>::__type __type2;
typedef typename __promote<_Vp>::__type __type3;
#pragma empty_line
public:
typedef __typeof__(__type1() + __type2() + __type3()) __type;
};
#pragma empty_line
template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
struct __promote_4
{
private:
typedef typename __promote<_Tp>::__type __type1;
typedef typename __promote<_Up>::__type __type2;
typedef typename __promote<_Vp>::__type __type3;
typedef typename __promote<_Wp>::__type __type4;
#pragma empty_line
public:
typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
};
#pragma empty_line
}
#pragma line 65 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/numeric_traits.h" 1 3
// -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.
#pragma empty_line
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ext/numeric_traits.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 32 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/numeric_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
// Compile time constants for builtin types.
// Sadly std::numeric_limits member functions cannot be used for this.
#pragma line 51 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_integer
{
// Only integers for initialization of member constant.
static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
#pragma empty_line
// NB: these two also available in std::numeric_limits as compile
// time constants, but <limits> is big and we avoid including it.
static const bool __is_signed = ((_Value)(-1) < 0);
static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
};
#pragma empty_line
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__min;
#pragma empty_line
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__max;
#pragma empty_line
template<typename _Value>
const bool __numeric_traits_integer<_Value>::__is_signed;
#pragma empty_line
template<typename _Value>
const int __numeric_traits_integer<_Value>::__digits;
#pragma line 96 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_floating
{
// Only floating point types. See N1822.
static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 3010 / 10000);
#pragma empty_line
// See above comment...
static const bool __is_signed = true;
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};
#pragma empty_line
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
#pragma empty_line
template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
#pragma empty_line
template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
#pragma empty_line
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
#pragma empty_line
template<typename _Value>
struct __numeric_traits
: public __conditional_type<std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type
{ };
#pragma empty_line
}
#pragma line 66 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_pair.h" 1 3
// Pair implementation -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file stl_pair.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/move.h" 1 3
// Move, forward and identity for C++0x + swap -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file move.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cstddef
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.1 Types
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 2 3
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/move.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/concept_check.h" 1 3
// Concept-checking control -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file concept_check.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/concept_check.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
// All places in libstdc++-v3 where these are used, or /might/ be used, or
// don't need to be used, or perhaps /should/ be used, are commented with
// "concept requirements" (and maybe some more text). So grep like crazy
// if you're looking for additional places to use these.
#pragma empty_line
// Concept-checking code is off by default unless users turn it on via
// configure options or editing c++config.h.
#pragma line 36 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/move.h" 2 3
#pragma line 95 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/move.h" 3
namespace std {
#pragma empty_line
/**
* @brief Swaps two values.
* @ingroup mutating_algorithms
* @param __a A thing of arbitrary type.
* @param __b Another thing of arbitrary type.
* @return Nothing.
*/
template<typename _Tp>
inline void
swap(_Tp& __a, _Tp& __b)
{
// concept requirements
#pragma empty_line
#pragma empty_line
_Tp __tmp = (__a);
__a = (__b);
__b = (__tmp);
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 809. std::swap should be overloaded for array types.
template<typename _Tp, size_t _Nm>
inline void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
#pragma empty_line
}
#pragma line 61 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_pair.h" 2 3
// std::swap
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
/// pair holds two objects of arbitrary type.
template<class _T1, class _T2>
struct pair
{
typedef _T1 first_type; ///< @c first_type is the first bound type
typedef _T2 second_type; ///< @c second_type is the second bound type
#pragma empty_line
_T1 first; ///< @c first is a copy of the first object
_T2 second; ///< @c second is a copy of the second object
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 265. std::pair::pair() effects overly restrictive
/** The default constructor creates @c first and @c second using their
* respective default constructors. */
pair()
: first(), second() { }
#pragma empty_line
/** Two objects may be passed to a @c pair constructor to be copied. */
pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
#pragma line 112 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_pair.h" 3
/** There is also a templated copy ctor for the @c pair class itself. */
template<class _U1, class _U2>
pair(const pair<_U1, _U2>& __p)
: first(__p.first),
second(__p.second) { }
#pragma line 149 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_pair.h" 3
};
#pragma empty_line
/// Two pairs of the same type are equal iff their members are equal.
template<class _T1, class _T2>
inline bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
#pragma empty_line
/// <http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html>
template<class _T1, class _T2>
inline bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first < __y.first
|| (!(__y.first < __x.first) && __x.second < __y.second); }
#pragma empty_line
/// Uses @c operator== to find the result.
template<class _T1, class _T2>
inline bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
#pragma empty_line
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
#pragma empty_line
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
#pragma empty_line
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
#pragma line 198 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_pair.h" 3
/**
* @brief A convenience wrapper for creating a pair from two objects.
* @param x The first object.
* @param y The second object.
* @return A newly-constructed pair<> object of the appropriate type.
*
* The standard requires that the objects be passed by reference-to-const,
* but LWG issue #181 says they should be passed by const value. We follow
* the LWG by default.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 181. make_pair() unintended behavior
#pragma empty_line
template<class _T1, class _T2>
inline pair<_T1, _T2>
make_pair(_T1 __x, _T2 __y)
{ return pair<_T1, _T2>(__x, __y); }
#pragma line 257 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_pair.h" 3
}
#pragma line 67 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator_base_types.h" 1 3
// Types used in iterator implementation -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file stl_iterator_base_types.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*
* This file contains all of the general iterator-related utility types,
* such as iterator_traits and struct iterator.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 63 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator_base_types.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cstddef
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.1 Types
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 2 3
#pragma line 66 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator_base_types.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @defgroup iterators Iterators
* Abstractions for uniform iterating through various underlying types.
*/
//@{
#pragma empty_line
/**
* @defgroup iterator_tags Iterator Tags
* These are empty types, used to distinguish different iterators. The
* distinction is not made by what they contain, but simply by what they
* are. Different underlying algorithms can then be used based on the
* different operations supported by different iterator types.
*/
//@{
/// Marking input iterators.
struct input_iterator_tag { };
#pragma empty_line
/// Marking output iterators.
struct output_iterator_tag { };
#pragma empty_line
/// Forward iterators support a superset of input iterator operations.
struct forward_iterator_tag : public input_iterator_tag { };
#pragma empty_line
/// Bidirectional iterators support a superset of forward iterator
/// operations.
struct bidirectional_iterator_tag : public forward_iterator_tag { };
#pragma empty_line
/// Random-access iterators support a superset of bidirectional
/// iterator operations.
struct random_access_iterator_tag : public bidirectional_iterator_tag { };
//@}
#pragma empty_line
/**
* @brief Common %iterator class.
*
* This class does nothing but define nested typedefs. %Iterator classes
* can inherit from this class to save some work. The typedefs are then
* used in specializations and overloading.
*
* In particular, there are no default implementations of requirements
* such as @c operator++ and the like. (How could there be?)
*/
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
typename _Pointer = _Tp*, typename _Reference = _Tp&>
struct iterator
{
/// One of the @link iterator_tags tag types@endlink.
typedef _Category iterator_category;
/// The type "pointed to" by the iterator.
typedef _Tp value_type;
/// Distance between iterators is represented as this type.
typedef _Distance difference_type;
/// This type represents a pointer-to-value_type.
typedef _Pointer pointer;
/// This type represents a reference-to-value_type.
typedef _Reference reference;
};
#pragma empty_line
/**
* @brief Traits class for iterators.
*
* This class does nothing but define nested typedefs. The general
* version simply @a forwards the nested typedefs from the Iterator
* argument. Specialized versions for pointers and pointers-to-const
* provide tighter, more correct semantics.
*/
template<typename _Iterator>
struct iterator_traits
{
typedef typename _Iterator::iterator_category iterator_category;
typedef typename _Iterator::value_type value_type;
typedef typename _Iterator::difference_type difference_type;
typedef typename _Iterator::pointer pointer;
typedef typename _Iterator::reference reference;
};
#pragma empty_line
/// Partial specialization for pointer types.
template<typename _Tp>
struct iterator_traits<_Tp*>
{
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
#pragma empty_line
/// Partial specialization for const pointer types.
template<typename _Tp>
struct iterator_traits<const _Tp*>
{
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef const _Tp* pointer;
typedef const _Tp& reference;
};
#pragma empty_line
/**
* This function is not a part of the C++ standard but is syntactic
* sugar for internal library use only.
*/
template<typename _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{ return typename iterator_traits<_Iter>::iterator_category(); }
#pragma empty_line
//@}
#pragma empty_line
}
#pragma line 68 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator_base_funcs.h" 1 3
// Functions used by iterators -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file stl_iterator_base_funcs.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*
* This file contains all of the general iterator-related utility
* functions, such as distance() and advance().
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 63 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator_base_funcs.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
// concept requirements
#pragma empty_line
#pragma empty_line
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last)
{
++__first;
++__n;
}
return __n;
}
#pragma empty_line
template<typename _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
{
// concept requirements
#pragma empty_line
#pragma empty_line
return __last - __first;
}
#pragma empty_line
/**
* @brief A generalization of pointer arithmetic.
* @param first An input iterator.
* @param last An input iterator.
* @return The distance between them.
*
* Returns @c n such that first + n == last. This requires that @p last
* must be reachable from @p first. Note that @c n may be negative.
*
* For random access iterators, this uses their @c + and @c - operations
* and are constant time. For other %iterator classes they are linear time.
*/
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
{
// concept requirements -- taken care of in __distance
return std::__distance(__first, __last,
std::__iterator_category(__first));
}
#pragma empty_line
template<typename _InputIterator, typename _Distance>
inline void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
{
// concept requirements
#pragma empty_line
while (__n--)
++__i;
}
#pragma empty_line
template<typename _BidirectionalIterator, typename _Distance>
inline void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
{
// concept requirements
#pragma empty_line
#pragma empty_line
if (__n > 0)
while (__n--)
++__i;
else
while (__n++)
--__i;
}
#pragma empty_line
template<typename _RandomAccessIterator, typename _Distance>
inline void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
{
// concept requirements
#pragma empty_line
#pragma empty_line
__i += __n;
}
#pragma empty_line
/**
* @brief A generalization of pointer arithmetic.
* @param i An input iterator.
* @param n The @a delta by which to change @p i.
* @return Nothing.
*
* This increments @p i by @p n. For bidirectional and random access
* iterators, @p n may be negative, in which case @p i is decremented.
*
* For random access iterators, this uses their @c + and @c - operations
* and are constant time. For other %iterator classes they are linear time.
*/
template<typename _InputIterator, typename _Distance>
inline void
advance(_InputIterator& __i, _Distance __n)
{
// concept requirements -- taken care of in __advance
typename iterator_traits<_InputIterator>::difference_type __d = __n;
std::__advance(__i, __d, std::__iterator_category(__i));
}
#pragma empty_line
}
#pragma line 69 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator.h" 1 3
// Iterators -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file stl_iterator.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*
* This file implements reverse_iterator, back_insert_iterator,
* front_insert_iterator, insert_iterator, __normal_iterator, and their
* supporting functions and overloaded operators.
*/
#pragma line 68 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator.h" 3
namespace std {
#pragma empty_line
/**
* @addtogroup iterators
* @{
*/
#pragma empty_line
// 24.4.1 Reverse iterators
/**
* Bidirectional and random access iterators have corresponding reverse
* %iterator adaptors that iterate through the data structure in the
* opposite direction. They have the same signatures as the corresponding
* iterators. The fundamental relation between a reverse %iterator and its
* corresponding %iterator @c i is established by the identity:
* @code
* &*(reverse_iterator(i)) == &*(i - 1)
* @endcode
*
* <em>This mapping is dictated by the fact that while there is always a
* pointer past the end of an array, there might not be a valid pointer
* before the beginning of an array.</em> [24.4.1]/1,2
*
* Reverse iterators can be tricky and surprising at first. Their
* semantics make sense, however, and the trickiness is a side effect of
* the requirement that the iterators must be safe.
*/
template<typename _Iterator>
class reverse_iterator
: public iterator<typename iterator_traits<_Iterator>::iterator_category,
typename iterator_traits<_Iterator>::value_type,
typename iterator_traits<_Iterator>::difference_type,
typename iterator_traits<_Iterator>::pointer,
typename iterator_traits<_Iterator>::reference>
{
protected:
_Iterator current;
#pragma empty_line
typedef iterator_traits<_Iterator> __traits_type;
#pragma empty_line
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::pointer pointer;
typedef typename __traits_type::reference reference;
#pragma empty_line
/**
* The default constructor default-initializes member @p current.
* If it is a pointer, that means it is zero-initialized.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 235 No specification of default ctor for reverse_iterator
reverse_iterator() : current() { }
#pragma empty_line
/**
* This %iterator will move in the opposite direction that @p x does.
*/
explicit
reverse_iterator(iterator_type __x) : current(__x) { }
#pragma empty_line
/**
* The copy constructor is normal.
*/
reverse_iterator(const reverse_iterator& __x)
: current(__x.current) { }
#pragma empty_line
/**
* A reverse_iterator across other types can be copied in the normal
* fashion.
*/
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }
#pragma empty_line
/**
* @return @c current, the %iterator used for underlying work.
*/
iterator_type
base() const
{ return current; }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reference
operator*() const
{
_Iterator __tmp = current;
return *--__tmp;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
pointer
operator->() const
{ return &(operator*()); }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator++()
{
--current;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator++(int)
{
reverse_iterator __tmp = *this;
--current;
return __tmp;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator--()
{
++current;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator--(int)
{
reverse_iterator __tmp = *this;
++current;
return __tmp;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator+(difference_type __n) const
{ return reverse_iterator(current - __n); }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator+=(difference_type __n)
{
current -= __n;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator-(difference_type __n) const
{ return reverse_iterator(current + __n); }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator-=(difference_type __n)
{
current += __n;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reference
operator[](difference_type __n) const
{ return *(*this + __n); }
};
#pragma empty_line
//@{
/**
* @param x A %reverse_iterator.
* @param y A %reverse_iterator.
* @return A simple bool.
*
* Reverse iterators forward many operations to their underlying base()
* iterators. Others are implemented in terms of one another.
*
*/
template<typename _Iterator>
inline bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __x.base() == __y.base(); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() < __x.base(); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x == __y); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y < __x; }
#pragma empty_line
template<typename _Iterator>
inline bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__y < __x); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x < __y); }
#pragma empty_line
template<typename _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() - __x.base(); }
#pragma empty_line
template<typename _Iterator>
inline reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x)
{ return reverse_iterator<_Iterator>(__x.base() - __n); }
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
template<typename _IteratorL, typename _IteratorR>
inline bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __x.base() == __y.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y.base() < __x.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x == __y); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y < __x; }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__y < __x); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x < __y); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline typename reverse_iterator<_IteratorL>::difference_type
operator-(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
#pragma empty_line
{ return __y.base() - __x.base(); }
//@}
#pragma empty_line
// 24.4.2.2.1 back_insert_iterator
/**
* @brief Turns assignment into insertion.
*
* These are output iterators, constructed from a container-of-T.
* Assigning a T to the iterator appends it to the container using
* push_back.
*
* Tip: Using the back_inserter function to create these iterators can
* save typing.
*/
template<typename _Container>
class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
#pragma empty_line
public:
/// A nested typedef for the type of whatever container you used.
typedef _Container container_type;
#pragma empty_line
/// The only way to create this %iterator is with a container.
explicit
back_insert_iterator(_Container& __x) : container(&__x) { }
#pragma empty_line
/**
* @param value An instance of whatever type
* container_type::const_reference is; presumably a
* reference-to-const T for container<T>.
* @return This %iterator, for chained operations.
*
* This kind of %iterator doesn't really have a @a position in the
* container (you can think of the position as being permanently at
* the end, if you like). Assigning a value to the %iterator will
* always append the value to the end of the container.
*/
#pragma empty_line
back_insert_iterator&
operator=(typename _Container::const_reference __value)
{
container->push_back(__value);
return *this;
}
#pragma line 442 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator.h" 3
/// Simply returns *this.
back_insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
back_insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
back_insert_iterator
operator++(int)
{ return *this; }
};
#pragma empty_line
/**
* @param x A container of arbitrary type.
* @return An instance of back_insert_iterator working on @p x.
*
* This wrapper function helps in creating back_insert_iterator instances.
* Typing the name of the %iterator requires knowing the precise full
* type of the container, which can be tedious and impedes generic
* programming. Using this function lets you take advantage of automatic
* template parameter deduction, making the compiler match the correct
* types for you.
*/
template<typename _Container>
inline back_insert_iterator<_Container>
back_inserter(_Container& __x)
{ return back_insert_iterator<_Container>(__x); }
#pragma empty_line
/**
* @brief Turns assignment into insertion.
*
* These are output iterators, constructed from a container-of-T.
* Assigning a T to the iterator prepends it to the container using
* push_front.
*
* Tip: Using the front_inserter function to create these iterators can
* save typing.
*/
template<typename _Container>
class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
#pragma empty_line
public:
/// A nested typedef for the type of whatever container you used.
typedef _Container container_type;
#pragma empty_line
/// The only way to create this %iterator is with a container.
explicit front_insert_iterator(_Container& __x) : container(&__x) { }
#pragma empty_line
/**
* @param value An instance of whatever type
* container_type::const_reference is; presumably a
* reference-to-const T for container<T>.
* @return This %iterator, for chained operations.
*
* This kind of %iterator doesn't really have a @a position in the
* container (you can think of the position as being permanently at
* the front, if you like). Assigning a value to the %iterator will
* always prepend the value to the front of the container.
*/
#pragma empty_line
front_insert_iterator&
operator=(typename _Container::const_reference __value)
{
container->push_front(__value);
return *this;
}
#pragma line 532 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator.h" 3
/// Simply returns *this.
front_insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
front_insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
front_insert_iterator
operator++(int)
{ return *this; }
};
#pragma empty_line
/**
* @param x A container of arbitrary type.
* @return An instance of front_insert_iterator working on @p x.
*
* This wrapper function helps in creating front_insert_iterator instances.
* Typing the name of the %iterator requires knowing the precise full
* type of the container, which can be tedious and impedes generic
* programming. Using this function lets you take advantage of automatic
* template parameter deduction, making the compiler match the correct
* types for you.
*/
template<typename _Container>
inline front_insert_iterator<_Container>
front_inserter(_Container& __x)
{ return front_insert_iterator<_Container>(__x); }
#pragma empty_line
/**
* @brief Turns assignment into insertion.
*
* These are output iterators, constructed from a container-of-T.
* Assigning a T to the iterator inserts it in the container at the
* %iterator's position, rather than overwriting the value at that
* position.
*
* (Sequences will actually insert a @e copy of the value before the
* %iterator's position.)
*
* Tip: Using the inserter function to create these iterators can
* save typing.
*/
template<typename _Container>
class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
typename _Container::iterator iter;
#pragma empty_line
public:
/// A nested typedef for the type of whatever container you used.
typedef _Container container_type;
#pragma empty_line
/**
* The only way to create this %iterator is with a container and an
* initial position (a normal %iterator into the container).
*/
insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(&__x), iter(__i) {}
#pragma empty_line
/**
* @param value An instance of whatever type
* container_type::const_reference is; presumably a
* reference-to-const T for container<T>.
* @return This %iterator, for chained operations.
*
* This kind of %iterator maintains its own position in the
* container. Assigning a value to the %iterator will insert the
* value into the container at the place before the %iterator.
*
* The position is maintained such that subsequent assignments will
* insert values immediately after one another. For example,
* @code
* // vector v contains A and Z
*
* insert_iterator i (v, ++v.begin());
* i = 1;
* i = 2;
* i = 3;
*
* // vector v contains A, 1, 2, 3, and Z
* @endcode
*/
#pragma empty_line
insert_iterator&
operator=(typename _Container::const_reference __value)
{
iter = container->insert(iter, __value);
++iter;
return *this;
}
#pragma line 646 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_iterator.h" 3
/// Simply returns *this.
insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
insert_iterator&
operator++(int)
{ return *this; }
};
#pragma empty_line
/**
* @param x A container of arbitrary type.
* @return An instance of insert_iterator working on @p x.
*
* This wrapper function helps in creating insert_iterator instances.
* Typing the name of the %iterator requires knowing the precise full
* type of the container, which can be tedious and impedes generic
* programming. Using this function lets you take advantage of automatic
* template parameter deduction, making the compiler match the correct
* types for you.
*/
template<typename _Container, typename _Iterator>
inline insert_iterator<_Container>
inserter(_Container& __x, _Iterator __i)
{
return insert_iterator<_Container>(__x,
typename _Container::iterator(__i));
}
#pragma empty_line
// @} group iterators
#pragma empty_line
}
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter. Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
class __normal_iterator
{
protected:
_Iterator _M_current;
#pragma empty_line
typedef iterator_traits<_Iterator> __traits_type;
#pragma empty_line
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::iterator_category iterator_category;
typedef typename __traits_type::value_type value_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::reference reference;
typedef typename __traits_type::pointer pointer;
#pragma empty_line
__normal_iterator() : _M_current(_Iterator()) { }
#pragma empty_line
explicit
__normal_iterator(const _Iterator& __i) : _M_current(__i) { }
#pragma empty_line
// Allow iterator to const_iterator conversion
template<typename _Iter>
__normal_iterator(const __normal_iterator<_Iter,
typename __enable_if<
(std::__are_same<_Iter, typename _Container::pointer>::__value),
_Container>::__type>& __i)
: _M_current(__i.base()) { }
#pragma empty_line
// Forward iterator requirements
reference
operator*() const
{ return *_M_current; }
#pragma empty_line
pointer
operator->() const
{ return _M_current; }
#pragma empty_line
__normal_iterator&
operator++()
{
++_M_current;
return *this;
}
#pragma empty_line
__normal_iterator
operator++(int)
{ return __normal_iterator(_M_current++); }
#pragma empty_line
// Bidirectional iterator requirements
__normal_iterator&
operator--()
{
--_M_current;
return *this;
}
#pragma empty_line
__normal_iterator
operator--(int)
{ return __normal_iterator(_M_current--); }
#pragma empty_line
// Random access iterator requirements
reference
operator[](const difference_type& __n) const
{ return _M_current[__n]; }
#pragma empty_line
__normal_iterator&
operator+=(const difference_type& __n)
{ _M_current += __n; return *this; }
#pragma empty_line
__normal_iterator
operator+(const difference_type& __n) const
{ return __normal_iterator(_M_current + __n); }
#pragma empty_line
__normal_iterator&
operator-=(const difference_type& __n)
{ _M_current -= __n; return *this; }
#pragma empty_line
__normal_iterator
operator-(const difference_type& __n) const
{ return __normal_iterator(_M_current - __n); }
#pragma empty_line
const _Iterator&
base() const
{ return _M_current; }
};
#pragma empty_line
// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid. However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type. Can someone
// remind me what generic programming is about? -- Gaby
#pragma empty_line
// Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline bool
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() != __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline bool
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() != __rhs.base(); }
#pragma empty_line
// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline bool
operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() > __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline bool
operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() > __rhs.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() <= __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline bool
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() <= __rhs.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() >= __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline bool
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() >= __rhs.base(); }
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline typename __normal_iterator<_IteratorL, _Container>::difference_type
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
#pragma empty_line
{ return __lhs.base() - __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline typename __normal_iterator<_Iterator, _Container>::difference_type
operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() - __rhs.base(); }
#pragma empty_line
template<typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container>
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
__n, const __normal_iterator<_Iterator, _Container>& __i)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
#pragma empty_line
}
#pragma line 70 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\debug/debug.h" 1 3
// Debugging support implementation -*- C++ -*-
#pragma empty_line
// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file debug/debug.h
* This file is a GNU debug extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/** Macros and namespaces used by the implementation outside of debug
* wrappers to verify certain properties. The __glibcxx_requires_xxx
* macros are merely wrappers around the __glibcxx_check_xxx wrappers
* when we are compiling with debug mode, but disappear when we are
* in release mode so that there is no checking performed in, e.g.,
* the standard library algorithms.
*/
#pragma empty_line
// Debug mode namespaces.
#pragma empty_line
/**
* @namespace std::__debug
* @brief GNU debug code, replaces standard behavior with debug behavior.
*/
namespace std
{
namespace __debug { }
}
#pragma empty_line
/** @namespace __gnu_debug
* @brief GNU debug classes for public use.
*/
namespace __gnu_debug
{
using namespace std::__debug;
}
#pragma line 72 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
// See http://gcc.gnu.org/ml/libstdc++/2004-08/msg00167.html: in a
// nutshell, we are partially implementing the resolution of DR 187,
// when it's safe, i.e., the value_types are equal.
template<bool _BoolType>
struct __iter_swap
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
static void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
typedef typename iterator_traits<_ForwardIterator1>::value_type
_ValueType1;
_ValueType1 __tmp = (*__a);
*__a = (*__b);
*__b = (__tmp);
}
};
#pragma empty_line
template<>
struct __iter_swap<true>
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
static void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
swap(*__a, *__b);
}
};
#pragma empty_line
/**
* @brief Swaps the contents of two iterators.
* @ingroup mutating_algorithms
* @param a An iterator.
* @param b Another iterator.
* @return Nothing.
*
* This function swaps the values pointed to by two iterators, not the
* iterators themselves.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
typedef typename iterator_traits<_ForwardIterator1>::value_type
_ValueType1;
typedef typename iterator_traits<_ForwardIterator2>::value_type
_ValueType2;
#pragma empty_line
// concept requirements
#pragma line 134 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 3
typedef typename iterator_traits<_ForwardIterator1>::reference
_ReferenceType1;
typedef typename iterator_traits<_ForwardIterator2>::reference
_ReferenceType2;
std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
&& __are_same<_ValueType1&, _ReferenceType1>::__value
&& __are_same<_ValueType2&, _ReferenceType2>::__value>::
iter_swap(__a, __b);
}
#pragma empty_line
/**
* @brief Swap the elements of two sequences.
* @ingroup mutating_algorithms
* @param first1 A forward iterator.
* @param last1 A forward iterator.
* @param first2 A forward iterator.
* @return An iterator equal to @p first2+(last1-first1).
*
* Swaps each element in the range @p [first1,last1) with the
* corresponding element in the range @p [first2,(last1-first1)).
* The ranges must not overlap.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{
// concept requirements
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first1 != __last1; ++__first1, ++__first2)
std::iter_swap(__first1, __first2);
return __first2;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @return The lesser of the parameters.
*
* This is the simple classic generic implementation. It will work on
* temporary expressions, since they are only evaluated once, unlike a
* preprocessor macro.
*/
template<typename _Tp>
inline const _Tp&
min(const _Tp& __a, const _Tp& __b)
{
// concept requirements
#pragma empty_line
//return __b < __a ? __b : __a;
if (__b < __a)
return __b;
return __a;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @return The greater of the parameters.
*
* This is the simple classic generic implementation. It will work on
* temporary expressions, since they are only evaluated once, unlike a
* preprocessor macro.
*/
template<typename _Tp>
inline const _Tp&
max(const _Tp& __a, const _Tp& __b)
{
// concept requirements
#pragma empty_line
//return __a < __b ? __b : __a;
if (__a < __b)
return __b;
return __a;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @param comp A @link comparison_functors comparison functor@endlink.
* @return The lesser of the parameters.
*
* This will work on temporary expressions, since they are only evaluated
* once, unlike a preprocessor macro.
*/
template<typename _Tp, typename _Compare>
inline const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
//return __comp(__b, __a) ? __b : __a;
if (__comp(__b, __a))
return __b;
return __a;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @param comp A @link comparison_functors comparison functor@endlink.
* @return The greater of the parameters.
*
* This will work on temporary expressions, since they are only evaluated
* once, unlike a preprocessor macro.
*/
template<typename _Tp, typename _Compare>
inline const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
//return __comp(__a, __b) ? __b : __a;
if (__comp(__a, __b))
return __b;
return __a;
}
#pragma empty_line
#pragma empty_line
// If _Iterator has a base returns it otherwise _Iterator is returned
// untouched
template<typename _Iterator, bool _HasBase>
struct _Iter_base
{
typedef _Iterator iterator_type;
static iterator_type
_S_base(_Iterator __it)
{ return __it; }
};
#pragma empty_line
template<typename _Iterator>
struct _Iter_base<_Iterator, true>
{
typedef typename _Iterator::iterator_type iterator_type;
static iterator_type
_S_base(_Iterator __it)
{ return __it.base(); }
};
#pragma empty_line
// If _Iterator is a __normal_iterator return its base (a plain pointer,
// normally) otherwise return it untouched. See copy, fill, ...
template<typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
{ };
#pragma empty_line
template<typename _Iterator>
inline typename _Niter_base<_Iterator>::iterator_type
__niter_base(_Iterator __it)
{ return std::_Niter_base<_Iterator>::_S_base(__it); }
#pragma empty_line
// Likewise, for move_iterator.
template<typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
{ };
#pragma empty_line
template<typename _Iterator>
inline typename _Miter_base<_Iterator>::iterator_type
__miter_base(_Iterator __it)
{ return std::_Miter_base<_Iterator>::_S_base(__it); }
#pragma empty_line
// All of these auxiliary structs serve two purposes. (1) Replace
// calls to copy with memmove whenever possible. (Memmove, not memcpy,
// because the input and output ranges are permitted to overlap.)
// (2) If we're using random access iterators, then write the loop as
// a for loop with an explicit count.
#pragma empty_line
template<bool, bool, typename>
struct __copy_move
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
for (; __first != __last; ++__result, ++__first)
*__result = *__first;
return __result;
}
};
#pragma line 339 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 3
template<>
struct __copy_move<false, false, random_access_iterator_tag>
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
typedef typename iterator_traits<_II>::difference_type _Distance;
for(_Distance __n = __last - __first; __n > 0; --__n)
{
*__result = *__first;
++__first;
++__result;
}
return __result;
}
};
#pragma line 377 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 3
template<bool _IsMove>
struct __copy_move<_IsMove, true, random_access_iterator_tag>
{
template<typename _Tp>
static _Tp*
__copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
{
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
return __result + _Num;
}
};
#pragma empty_line
template<bool _IsMove, typename _II, typename _OI>
inline _OI
__copy_move_a(_II __first, _II __last, _OI __result)
{
typedef typename iterator_traits<_II>::value_type _ValueTypeI;
typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
typedef typename iterator_traits<_II>::iterator_category _Category;
const bool __simple = (__is_pod(_ValueTypeI)
&& __is_pointer<_II>::__value
&& __is_pointer<_OI>::__value
&& __are_same<_ValueTypeI, _ValueTypeO>::__value);
#pragma empty_line
return std::__copy_move<_IsMove, __simple,
_Category>::__copy_m(__first, __last, __result);
}
#pragma empty_line
// Helpers for streambuf iterators (either istream or ostream).
// NB: avoid including <iosfwd>, relatively large.
template<typename _CharT>
struct char_traits;
#pragma empty_line
template<typename _CharT, typename _Traits>
class istreambuf_iterator;
#pragma empty_line
template<typename _CharT, typename _Traits>
class ostreambuf_iterator;
#pragma empty_line
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(_CharT*, _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
#pragma empty_line
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(const _CharT*, const _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
#pragma empty_line
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
#pragma empty_line
template<bool _IsMove, typename _II, typename _OI>
inline _OI
__copy_move_a2(_II __first, _II __last, _OI __result)
{
return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result)));
}
#pragma empty_line
/**
* @brief Copies the range [first,last) into result.
* @ingroup mutating_algorithms
* @param first An input iterator.
* @param last An input iterator.
* @param result An output iterator.
* @return result + (first - last)
*
* This inline function will boil down to a call to @c memmove whenever
* possible. Failing that, if random access iterators are passed, then the
* loop count will be known (and therefore a candidate for compiler
* optimizations such as unrolling). Result may not be contained within
* [first,last); the copy_backward function should be used instead.
*
* Note that the end of the output range is permitted to be contained
* within [first,last).
*/
template<typename _II, typename _OI>
inline _OI
copy(_II __first, _II __last, _OI __result)
{
// concept requirements
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
#pragma line 514 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 3
template<bool, bool, typename>
struct __copy_move_backward
{
template<typename _BI1, typename _BI2>
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
while (__first != __last)
*--__result = *--__last;
return __result;
}
};
#pragma line 542 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 3
template<>
struct __copy_move_backward<false, false, random_access_iterator_tag>
{
template<typename _BI1, typename _BI2>
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
typename iterator_traits<_BI1>::difference_type __n;
for (__n = __last - __first; __n > 0; --__n)
*--__result = *--__last;
return __result;
}
};
#pragma line 572 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 3
template<bool _IsMove>
struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
{
template<typename _Tp>
static _Tp*
__copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
{
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
return __result - _Num;
}
};
#pragma empty_line
template<bool _IsMove, typename _BI1, typename _BI2>
inline _BI2
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
{
typedef typename iterator_traits<_BI1>::value_type _ValueType1;
typedef typename iterator_traits<_BI2>::value_type _ValueType2;
typedef typename iterator_traits<_BI1>::iterator_category _Category;
const bool __simple = (__is_pod(_ValueType1)
&& __is_pointer<_BI1>::__value
&& __is_pointer<_BI2>::__value
&& __are_same<_ValueType1, _ValueType2>::__value);
#pragma empty_line
return std::__copy_move_backward<_IsMove, __simple,
_Category>::__copy_move_b(__first,
__last,
__result);
}
#pragma empty_line
template<bool _IsMove, typename _BI1, typename _BI2>
inline _BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
{
return _BI2(std::__copy_move_backward_a<_IsMove>
(std::__niter_base(__first), std::__niter_base(__last),
std::__niter_base(__result)));
}
#pragma empty_line
/**
* @brief Copies the range [first,last) into result.
* @ingroup mutating_algorithms
* @param first A bidirectional iterator.
* @param last A bidirectional iterator.
* @param result A bidirectional iterator.
* @return result - (first - last)
*
* The function has the same effect as copy, but starts at the end of the
* range and works its way to the start, returning the start of the result.
* This inline function will boil down to a call to @c memmove whenever
* possible. Failing that, if random access iterators are passed, then the
* loop count will be known (and therefore a candidate for compiler
* optimizations such as unrolling).
*
* Result may not be in the range [first,last). Use copy instead. Note
* that the start of the output range may overlap [first,last).
*/
template<typename _BI1, typename _BI2>
inline _BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{
// concept requirements
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
#pragma line 689 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_algobase.h" 3
template<typename _ForwardIterator, typename _Tp>
inline typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
for (; __first != __last; ++__first)
*__first = __value;
}
#pragma empty_line
template<typename _ForwardIterator, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __first != __last; ++__first)
*__first = __tmp;
}
#pragma empty_line
// Specialization: for char types we can use memset.
template<typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
{
const _Tp __tmp = __c;
__builtin_memset(__first, static_cast<unsigned char>(__tmp),
__last - __first);
}
#pragma empty_line
/**
* @brief Fills the range [first,last) with copies of value.
* @ingroup mutating_algorithms
* @param first A forward iterator.
* @param last A forward iterator.
* @param value A reference-to-const of arbitrary type.
* @return Nothing.
*
* This function fills a range with copies of the same value. For char
* types filling contiguous areas of memory, this becomes an inline call
* to @c memset or @c wmemset.
*/
template<typename _ForwardIterator, typename _Tp>
inline void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
// concept requirements
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
__value);
}
#pragma empty_line
template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
for (; __n > 0; --__n, ++__first)
*__first = __value;
return __first;
}
#pragma empty_line
template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __n > 0; --__n, ++__first)
*__first = __tmp;
return __first;
}
#pragma empty_line
template<typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
{
std::__fill_a(__first, __first + __n, __c);
return __first + __n;
}
#pragma empty_line
/**
* @brief Fills the range [first,first+n) with copies of value.
* @ingroup mutating_algorithms
* @param first An output iterator.
* @param n The count of copies to perform.
* @param value A reference-to-const of arbitrary type.
* @return The iterator at first+n.
*
* This function fills a range with copies of the same value. For char
* types filling contiguous areas of memory, this becomes an inline call
* to @c memset or @ wmemset.
*
* _GLIBCXX_RESOLVE_LIB_DEFECTS
* DR 865. More algorithms that throw away information
*/
template<typename _OI, typename _Size, typename _Tp>
inline _OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
{
// concept requirements
#pragma empty_line
#pragma empty_line
return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
}
#pragma empty_line
template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
for (; __first1 != __last1; ++__first1, ++__first2)
if (!(*__first1 == *__first2))
return false;
return true;
}
};
#pragma empty_line
template<>
struct __equal<true>
{
template<typename _Tp>
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
{
return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
* (__last1 - __first1));
}
};
#pragma empty_line
template<typename _II1, typename _II2>
inline bool
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
{
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
const bool __simple = (__is_integer<_ValueType1>::__value
&& __is_pointer<_II1>::__value
&& __is_pointer<_II2>::__value
&& __are_same<_ValueType1, _ValueType2>::__value);
#pragma empty_line
return std::__equal<__simple>::equal(__first1, __last1, __first2);
}
#pragma empty_line
#pragma empty_line
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
{ return __last1; }
#pragma empty_line
template<typename _II>
static bool
__cnd2(_II __first, _II __last)
{ return __first != __last; }
};
#pragma empty_line
template<>
struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
{
template<typename _RAI1, typename _RAI2>
static _RAI1
__newlast1(_RAI1 __first1, _RAI1 __last1,
_RAI2 __first2, _RAI2 __last2)
{
const typename iterator_traits<_RAI1>::difference_type
__diff1 = __last1 - __first1;
const typename iterator_traits<_RAI2>::difference_type
__diff2 = __last2 - __first2;
return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
}
#pragma empty_line
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
{ return true; }
};
#pragma empty_line
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
#pragma empty_line
template<bool _BoolType>
template<typename _II1, typename _II2>
bool
__lexicographical_compare<_BoolType>::
__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
{
typedef typename iterator_traits<_II1>::iterator_category _Category1;
typedef typename iterator_traits<_II2>::iterator_category _Category2;
typedef std::__lc_rai<_Category1, _Category2> __rai_type;
#pragma empty_line
__last1 = __rai_type::__newlast1(__first1, __last1,
__first2, __last2);
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, ++__first2)
{
if (*__first1 < *__first2)
return true;
if (*__first2 < *__first1)
return false;
}
return __first1 == __last1 && __first2 != __last2;
}
#pragma empty_line
template<>
struct __lexicographical_compare<true>
{
template<typename _Tp, typename _Up>
static bool
__lc(const _Tp* __first1, const _Tp* __last1,
const _Up* __first2, const _Up* __last2)
{
const size_t __len1 = __last1 - __first1;
const size_t __len2 = __last2 - __first2;
const int __result = __builtin_memcmp(__first1, __first2,
std::min(__len1, __len2));
return __result != 0 ? __result < 0 : __len1 < __len2;
}
};
#pragma empty_line
template<typename _II1, typename _II2>
inline bool
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
{
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
const bool __simple =
(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
&& !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
&& !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
&& __is_pointer<_II1>::__value
&& __is_pointer<_II2>::__value);
#pragma empty_line
return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
__first2, __last2);
}
#pragma empty_line
/**
* @brief Finds the first position in which @a val could be inserted
* without changing the ordering.
* @param first An iterator.
* @param last Another iterator.
* @param val The search term.
* @return An iterator pointing to the first element <em>not less
* than</em> @a val, or end() if every element is less than
* @a val.
* @ingroup binary_search_algorithms
*/
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
#pragma empty_line
// concept requirements
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
_ForwardIterator __middle;
#pragma empty_line
while (__len > 0)
{
__half = __len >> 1;
__middle = __first;
std::advance(__middle, __half);
if (*__middle < __val)
{
__first = __middle;
++__first;
__len = __len - __half - 1;
}
else
__len = __half;
}
return __first;
}
#pragma empty_line
/// This is a helper function for the sort routines and for random.tcc.
// Precondition: __n > 0.
template<typename _Size>
inline _Size
__lg(_Size __n)
{
_Size __k;
for (__k = 0; __n != 0; __n >>= 1)
++__k;
return __k - 1;
}
#pragma empty_line
inline int
__lg(int __n)
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
#pragma empty_line
inline long
__lg(long __n)
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
#pragma empty_line
inline long long
__lg(long long __n)
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
#pragma empty_line
}
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @brief Tests a range for element-wise equality.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @return A boolean true or false.
*
* This compares the elements of two ranges using @c == and returns true or
* false depending on whether all of the corresponding elements of the
* ranges are equal.
*/
template<typename _II1, typename _II2>
inline bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
// concept requirements
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__equal_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2));
}
#pragma empty_line
/**
* @brief Tests a range for element-wise equality.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param binary_pred A binary predicate @link functors
* functor@endlink.
* @return A boolean true or false.
*
* This compares the elements of two ranges using the binary_pred
* parameter, and returns true or
* false depending on whether all of the corresponding elements of the
* ranges are equal.
*/
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
inline bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
{
// concept requirements
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first1 != __last1; ++__first1, ++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return true;
}
#pragma empty_line
/**
* @brief Performs @b dictionary comparison on ranges.
* @ingroup sorting_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param last2 An input iterator.
* @return A boolean true or false.
*
* <em>Returns true if the sequence of elements defined by the range
* [first1,last1) is lexicographically less than the sequence of elements
* defined by the range [first2,last2). Returns false otherwise.</em>
* (Quoted from [25.3.8]/1.) If the iterators are all character pointers,
* then this is an inline call to @c memcmp.
*/
template<typename _II1, typename _II2>
inline bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
{
// concept requirements
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__lexicographical_compare_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2),
std::__niter_base(__last2));
}
#pragma empty_line
/**
* @brief Performs @b dictionary comparison on ranges.
* @ingroup sorting_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param last2 An input iterator.
* @param comp A @link comparison_functors comparison functor@endlink.
* @return A boolean true or false.
*
* The same as the four-parameter @c lexicographical_compare, but uses the
* comp parameter instead of @c <.
*/
template<typename _II1, typename _II2, typename _Compare>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2, _Compare __comp)
{
typedef typename iterator_traits<_II1>::iterator_category _Category1;
typedef typename iterator_traits<_II2>::iterator_category _Category2;
typedef std::__lc_rai<_Category1, _Category2> __rai_type;
#pragma empty_line
// concept requirements
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, ++__first2)
{
if (__comp(*__first1, *__first2))
return true;
if (__comp(*__first2, *__first1))
return false;
}
return __first1 == __last1 && __first2 != __last2;
}
#pragma empty_line
/**
* @brief Finds the places in ranges which don't match.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @return A pair of iterators pointing to the first mismatch.
*
* This compares the elements of two ranges using @c == and returns a pair
* of iterators. The first iterator points into the first range, the
* second iterator points into the second range, and the elements pointed
* to by the iterators are not equal.
*/
template<typename _InputIterator1, typename _InputIterator2>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
{
// concept requirements
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
while (__first1 != __last1 && *__first1 == *__first2)
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
#pragma empty_line
/**
* @brief Finds the places in ranges which don't match.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param binary_pred A binary predicate @link functors
* functor@endlink.
* @return A pair of iterators pointing to the first mismatch.
*
* This compares the elements of two ranges using the binary_pred
* parameter, and returns a pair
* of iterators. The first iterator points into the first range, the
* second iterator points into the second range, and the elements pointed
* to by the iterators are not equal.
*/
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
{
// concept requirements
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
#pragma empty_line
}
#pragma empty_line
// NB: This file is included within many other C++ includes, as a way
// of getting the base algorithms. So, make sure that parallel bits
// come in too if requested.
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/char_traits.h" 2 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cwchar
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c wchar.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 21.4
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cstddef
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.1 Types
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 2 3
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwchar" 2 3
#pragma line 43 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/char_traits.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
/**
* @brief Mapping from character type to associated types.
*
* @note This is an implementation class for the generic version
* of char_traits. It defines int_type, off_type, pos_type, and
* state_type. By default these are unsigned long, streamoff,
* streampos, and mbstate_t. Users who need a different set of
* types, but who don't need to change the definitions of any function
* defined in char_traits, can specialize __gnu_cxx::_Char_types
* while leaving __gnu_cxx::char_traits alone. */
template<typename _CharT>
struct _Char_types
{
typedef unsigned long int_type;
typedef std::streampos pos_type;
typedef std::streamoff off_type;
typedef std::mbstate_t state_type;
};
#pragma empty_line
#pragma empty_line
/**
* @brief Base class used to implement std::char_traits.
*
* @note For any given actual character type, this definition is
* probably wrong. (Most of the member functions are likely to be
* right, but the int_type and state_type typedefs, and the eof()
* member function, are likely to be wrong.) The reason this class
* exists is so users can specialize it. Classes in namespace std
* may not be specialized for fundamental types, but classes in
* namespace __gnu_cxx may be.
*
* See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
* for advice on how to make use of this class for @a unusual character
* types. Also, check out include/ext/pod_char_traits.h.
*/
template<typename _CharT>
struct char_traits
{
typedef _CharT char_type;
typedef typename _Char_types<_CharT>::int_type int_type;
typedef typename _Char_types<_CharT>::pos_type pos_type;
typedef typename _Char_types<_CharT>::off_type off_type;
typedef typename _Char_types<_CharT>::state_type state_type;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
#pragma empty_line
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
#pragma empty_line
static int
compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
#pragma empty_line
static std::size_t
length(const char_type* __s);
#pragma empty_line
static const char_type*
find(const char_type* __s, std::size_t __n, const char_type& __a);
#pragma empty_line
static char_type*
move(char_type* __s1, const char_type* __s2, std::size_t __n);
#pragma empty_line
static char_type*
copy(char_type* __s1, const char_type* __s2, std::size_t __n);
#pragma empty_line
static char_type*
assign(char_type* __s, std::size_t __n, char_type __a);
#pragma empty_line
static char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
#pragma empty_line
static int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(__c); }
#pragma empty_line
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static int_type
eof()
{ return static_cast<int_type>((-1)); }
#pragma empty_line
static int_type
not_eof(const int_type& __c)
{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
};
#pragma empty_line
template<typename _CharT>
int
char_traits<_CharT>::
compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
#pragma empty_line
template<typename _CharT>
std::size_t
char_traits<_CharT>::
length(const char_type* __p)
{
std::size_t __i = 0;
while (!eq(__p[__i], char_type()))
++__i;
return __i;
}
#pragma empty_line
template<typename _CharT>
const typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
find(const char_type* __s, std::size_t __n, const char_type& __a)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
#pragma empty_line
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
move(char_type* __s1, const char_type* __s2, std::size_t __n)
{
return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
__n * sizeof(char_type)));
}
#pragma empty_line
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
copy(char_type* __s1, const char_type* __s2, std::size_t __n)
{
// NB: Inline std::copy so no recursive dependencies.
std::copy(__s2, __s2 + __n, __s1);
return __s1;
}
#pragma empty_line
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
assign(char_type* __s, std::size_t __n, char_type __a)
{
// NB: Inline std::fill_n so no recursive dependencies.
std::fill_n(__s, __n, __a);
return __s;
}
#pragma empty_line
}
#pragma empty_line
namespace std {
#pragma empty_line
// 21.1
/**
* @brief Basis for explicit traits specializations.
*
* @note For any given actual character type, this definition is
* probably wrong. Since this is just a thin wrapper around
* __gnu_cxx::char_traits, it is possible to achieve a more
* appropriate definition by specializing __gnu_cxx::char_traits.
*
* See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
* for advice on how to make use of this class for @a unusual character
* types. Also, check out include/ext/pod_char_traits.h.
*/
template<class _CharT>
struct char_traits : public __gnu_cxx::char_traits<_CharT>
{ };
#pragma empty_line
#pragma empty_line
/// 21.1.3.1 char_traits specializations
template<>
struct char_traits<char>
{
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
#pragma empty_line
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
#pragma empty_line
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{ return __builtin_memcmp(__s1, __s2, __n); }
#pragma empty_line
static size_t
length(const char_type* __s)
{ return __builtin_strlen(__s); }
#pragma empty_line
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
#pragma empty_line
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
#pragma empty_line
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
#pragma empty_line
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
#pragma empty_line
static char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
#pragma empty_line
// To keep both the byte 0xff and the eof symbol 0xffffffff
// from ending up as 0xffffffff.
static int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
#pragma empty_line
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static int_type
eof()
{ return static_cast<int_type>((-1)); }
#pragma empty_line
static int_type
not_eof(const int_type& __c)
{ return (__c == eof()) ? 0 : __c; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/// 21.1.3.2 char_traits specializations
template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
typedef streamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
#pragma empty_line
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
#pragma empty_line
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcmp(__s1, __s2, __n); }
#pragma empty_line
static size_t
length(const char_type* __s)
{ return wcslen(__s); }
#pragma empty_line
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{ return wmemchr(__s, __a, __n); }
#pragma empty_line
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemmove(__s1, __s2, __n); }
#pragma empty_line
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcpy(__s1, __s2, __n); }
#pragma empty_line
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return wmemset(__s, __a, __n); }
#pragma empty_line
static char_type
to_char_type(const int_type& __c)
{ return char_type(__c); }
#pragma empty_line
static int_type
to_int_type(const char_type& __c)
{ return int_type(__c); }
#pragma empty_line
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static int_type
eof()
{ return static_cast<int_type>((wint_t)(0xFFFF)); }
#pragma empty_line
static int_type
not_eof(const int_type& __c)
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
#pragma empty_line
#pragma empty_line
}
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/localefwd.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file localefwd.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/localefwd.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++locale.h" 1 3
// Wrapper for underlying C-language localization -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file c++locale.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 22.8 Standard locale categories.
//
#pragma empty_line
// Written by Benjamin Kosnik <bkoz@redhat.com>
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 40 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++locale.h" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\clocale" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file clocale
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c locale.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.2.2 Implementation properties: C library
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\clocale" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\locale.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\locale.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\locale.h" 3
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;
};
#pragma line 75 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\locale.h" 3
int _configthreadlocale(int _Flag);
char * setlocale(int _Category,const char *_Locale);
__attribute__ ((__dllimport__)) struct lconv * localeconv(void);
_locale_t _get_current_locale(void);
_locale_t _create_locale(int _Category,const char *_Locale);
void _free_locale(_locale_t _Locale);
_locale_t __get_current_locale(void);
_locale_t __create_locale(int _Category,const char *_Locale);
void __free_locale(_locale_t _Locale);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\clocale" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Get rid of those macros defined in <locale.h> in lieu of real functions.
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
using ::lconv;
using ::setlocale;
using ::localeconv;
#pragma empty_line
}
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++locale.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cstddef
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.1 Types
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 2 3
#pragma line 43 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++locale.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
typedef int* __c_locale;
#pragma empty_line
// Convert numeric value of type double and long double to string and
// return length of string. If vsnprintf is available use it, otherwise
// fall back to the unsafe vsprintf which, in general, can be dangerous
// and should be avoided.
inline int
__convert_from_v(const __c_locale&, char* __out,
const int __size __attribute__((__unused__)),
const char* __fmt, ...)
{
char* __old = std::setlocale(4, __null);
char* __sav = __null;
if (__builtin_strcmp(__old, "C"))
{
const size_t __len = __builtin_strlen(__old) + 1;
__sav = new char[__len];
__builtin_memcpy(__sav, __old, __len);
std::setlocale(4, "C");
}
#pragma empty_line
__builtin_va_list __args;
__builtin_va_start(__args, __fmt);
#pragma empty_line
#pragma empty_line
const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__builtin_va_end(__args);
#pragma empty_line
if (__sav)
{
std::setlocale(4, __sav);
delete [] __sav;
}
return __ret;
}
#pragma empty_line
}
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/localefwd.h" 2 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cctype" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cctype
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c ctype.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: <ccytpe>
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cctype" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\ctype.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\ctype.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma line 70 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\ctype.h" 3
/* CRT stuff */
#pragma empty_line
extern const unsigned char __newclmap[];
extern const unsigned char __newcumap[];
extern pthreadlocinfo __ptlocinfo;
extern pthreadmbcinfo __ptmbcinfo;
extern int __globallocalestatus;
extern int __locale_changed;
extern struct threadlocaleinfostruct __initiallocinfo;
extern _locale_tstruct __initiallocalestructinfo;
pthreadlocinfo __updatetlocinfo(void);
pthreadmbcinfo __updatetmbcinfo(void);
#pragma line 100 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\ctype.h" 3
__attribute__ ((__dllimport__)) int _isctype(int _C,int _Type);
__attribute__ ((__dllimport__)) int _isctype_l(int _C,int _Type,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isalpha(int _C);
__attribute__ ((__dllimport__)) int _isalpha_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isupper(int _C);
__attribute__ ((__dllimport__)) int _isupper_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int islower(int _C);
__attribute__ ((__dllimport__)) int _islower_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isdigit(int _C);
__attribute__ ((__dllimport__)) int _isdigit_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isxdigit(int _C);
__attribute__ ((__dllimport__)) int _isxdigit_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isspace(int _C);
__attribute__ ((__dllimport__)) int _isspace_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int ispunct(int _C);
__attribute__ ((__dllimport__)) int _ispunct_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isalnum(int _C);
__attribute__ ((__dllimport__)) int _isalnum_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isprint(int _C);
__attribute__ ((__dllimport__)) int _isprint_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int isgraph(int _C);
__attribute__ ((__dllimport__)) int _isgraph_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int iscntrl(int _C);
__attribute__ ((__dllimport__)) int _iscntrl_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int toupper(int _C);
__attribute__ ((__dllimport__)) int tolower(int _C);
__attribute__ ((__dllimport__)) int _tolower(int _C);
__attribute__ ((__dllimport__)) int _tolower_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int _toupper(int _C);
__attribute__ ((__dllimport__)) int _toupper_l(int _C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __isascii(int _C);
__attribute__ ((__dllimport__)) int __toascii(int _C);
__attribute__ ((__dllimport__)) int __iscsymf(int _C);
__attribute__ ((__dllimport__)) int __iscsym(int _C);
#pragma empty_line
#pragma empty_line
int isblank(int _C);
#pragma line 193 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\ctype.h" 3
extern int * _imp____mb_cur_max;
#pragma line 275 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\ctype.h" 3
}
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cctype" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Get rid of those macros defined in <ctype.h> in lieu of real functions.
#pragma line 63 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cctype" 3
namespace std {
#pragma empty_line
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isdigit;
using ::isgraph;
using ::islower;
using ::isprint;
using ::ispunct;
using ::isspace;
using ::isupper;
using ::isxdigit;
using ::tolower;
using ::toupper;
#pragma empty_line
}
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/localefwd.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @defgroup locales Locales
*
* Classes and functions for internationalization and localization.
*/
#pragma empty_line
// 22.1.1 Locale
class locale;
#pragma empty_line
template<typename _Facet>
bool
has_facet(const locale&) throw();
#pragma empty_line
template<typename _Facet>
const _Facet&
use_facet(const locale&);
#pragma empty_line
// 22.1.3 Convenience interfaces
template<typename _CharT>
bool
isspace(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isprint(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
iscntrl(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isupper(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
islower(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isalpha(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isdigit(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
ispunct(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isxdigit(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isalnum(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isgraph(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
_CharT
toupper(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
_CharT
tolower(_CharT, const locale&);
#pragma empty_line
// 22.2.1 and 22.2.1.3 ctype
class ctype_base;
template<typename _CharT>
class ctype;
template<> class ctype<char>;
#pragma empty_line
template<> class ctype<wchar_t>;
#pragma empty_line
template<typename _CharT>
class ctype_byname;
// NB: Specialized for char and wchar_t in locale_facets.h.
#pragma empty_line
class codecvt_base;
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt;
template<> class codecvt<char, char, mbstate_t>;
#pragma empty_line
template<> class codecvt<wchar_t, char, mbstate_t>;
#pragma empty_line
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt_byname;
#pragma empty_line
// 22.2.2 and 22.2.3 numeric
#pragma empty_line
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class num_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class num_put;
#pragma empty_line
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
#pragma empty_line
// 22.2.4 collation
template<typename _CharT>
class collate;
template<typename _CharT> class
collate_byname;
#pragma empty_line
// 22.2.5 date and time
class time_base;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get_byname;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put_byname;
#pragma empty_line
// 22.2.6 money
class money_base;
#pragma empty_line
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
#pragma empty_line
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
#pragma empty_line
// 22.2.7 message retrieval
class messages_base;
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
#pragma empty_line
}
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ios_base.h" 1 3
// Iostreams base classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ios_base.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.4 Iostreams base classes
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ios_base.h" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/atomicity.h" 1 3
// Support for atomic operations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2004, 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file atomicity.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr.h" 1 3
/* Threads compatibility routines for libgcc2. */
/* Compile this one with gcc. */
/* Copyright (C) 1997, 1998, 2004, 2008, 2009 Free Software Foundation, Inc.
#pragma empty_line
This file is part of GCC.
#pragma empty_line
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
#pragma empty_line
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
#pragma empty_line
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
#pragma empty_line
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
/* If this file is compiled with threads support, it must
#define __GTHREADS 1
to indicate that threads support is present. Also it has define
function
int __gthread_active_p ()
that returns 1 if thread system is active, 0 if not.
#pragma empty_line
The threads interface must define the following types:
__gthread_key_t
__gthread_once_t
__gthread_mutex_t
__gthread_recursive_mutex_t
#pragma empty_line
The threads interface must define the following macros:
#pragma empty_line
__GTHREAD_ONCE_INIT
to initialize __gthread_once_t
__GTHREAD_MUTEX_INIT
to initialize __gthread_mutex_t to get a fast
non-recursive mutex.
__GTHREAD_MUTEX_INIT_FUNCTION
some systems can't initialize a mutex without a
function call. On such systems, define this to a
function which looks like this:
void __GTHREAD_MUTEX_INIT_FUNCTION (__gthread_mutex_t *)
Don't define __GTHREAD_MUTEX_INIT in this case
__GTHREAD_RECURSIVE_MUTEX_INIT
__GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION
as above, but for a recursive mutex.
#pragma empty_line
The threads interface must define the following static functions:
#pragma empty_line
int __gthread_once (__gthread_once_t *once, void (*func) ())
#pragma empty_line
int __gthread_key_create (__gthread_key_t *keyp, void (*dtor) (void *))
int __gthread_key_delete (__gthread_key_t key)
#pragma empty_line
void *__gthread_getspecific (__gthread_key_t key)
int __gthread_setspecific (__gthread_key_t key, const void *ptr)
#pragma empty_line
int __gthread_mutex_destroy (__gthread_mutex_t *mutex);
#pragma empty_line
int __gthread_mutex_lock (__gthread_mutex_t *mutex);
int __gthread_mutex_trylock (__gthread_mutex_t *mutex);
int __gthread_mutex_unlock (__gthread_mutex_t *mutex);
#pragma empty_line
int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex);
int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex);
int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex);
#pragma empty_line
The following are supported in POSIX threads only. They are required to
fix a deadlock in static initialization inside libsupc++. The header file
gthr-posix.h defines a symbol __GTHREAD_HAS_COND to signify that these extra
features are supported.
#pragma empty_line
Types:
__gthread_cond_t
#pragma empty_line
Macros:
__GTHREAD_COND_INIT
__GTHREAD_COND_INIT_FUNCTION
#pragma empty_line
Interface:
int __gthread_cond_broadcast (__gthread_cond_t *cond);
int __gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex);
int __gthread_cond_wait_recursive (__gthread_cond_t *cond,
__gthread_recursive_mutex_t *mutex);
#pragma empty_line
All functions returning int should return zero on success or the error
number. If the operation is not supported, -1 is returned.
#pragma empty_line
If the following are also defined, you should
#define __GTHREADS_CXX0X 1
to enable the c++0x thread library.
#pragma empty_line
Types:
__gthread_t
__gthread_time_t
#pragma empty_line
Interface:
int __gthread_create (__gthread_t *thread, void *(*func) (void*),
void *args);
int __gthread_join (__gthread_t thread, void **value_ptr);
int __gthread_detach (__gthread_t thread);
int __gthread_equal (__gthread_t t1, __gthread_t t2);
__gthread_t __gthread_self (void);
int __gthread_yield (void);
#pragma empty_line
int __gthread_mutex_timedlock (__gthread_mutex_t *m,
const __gthread_time_t *abs_timeout);
int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *m,
const __gthread_time_t *abs_time);
#pragma empty_line
int __gthread_cond_signal (__gthread_cond_t *cond);
int __gthread_cond_timedwait (__gthread_cond_t *cond,
__gthread_mutex_t *mutex,
const __gthread_time_t *abs_timeout);
int __gthread_cond_timedwait_recursive (__gthread_cond_t *cond,
__gthread_recursive_mutex_t *mutex,
const __gthread_time_t *abs_time)
#pragma empty_line
Currently supported threads packages are
TPF threads with -D__tpf__
POSIX/Unix98 threads with -D_PTHREADS
POSIX/Unix95 threads with -D_PTHREADS95
DCE threads with -D_DCE_THREADS
Solaris/UI threads with -D_SOLARIS_THREADS
#pragma empty_line
*/
#pragma empty_line
/* Check first for thread specific defines. */
#pragma line 162 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr.h" 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr-default.h" 1 3
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
#pragma empty_line
/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009
Free Software Foundation, Inc.
Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
#pragma empty_line
This file is part of GCC.
#pragma empty_line
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
#pragma empty_line
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
#pragma empty_line
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
#pragma empty_line
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Make sure CONST_CAST2 (origin in system.h) is declared. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Windows32 threads specific definitions. The windows32 threading model
does not map well into pthread-inspired gcc's threading model, and so
there are caveats one needs to be aware of.
#pragma empty_line
1. The destructor supplied to __gthread_key_create is ignored for
generic x86-win32 ports. This will certainly cause memory leaks
due to unreclaimed eh contexts (sizeof (eh_context) is at least
24 bytes for x86 currently).
#pragma empty_line
This memory leak may be significant for long-running applications
that make heavy use of C++ EH.
#pragma empty_line
However, Mingw runtime (version 0.3 or newer) provides a mechanism
to emulate pthreads key dtors; the runtime provides a special DLL,
linked in if -mthreads option is specified, that runs the dtors in
the reverse order of registration when each thread exits. If
-mthreads option is not given, a stub is linked in instead of the
DLL, which results in memory leak. Other x86-win32 ports can use
the same technique of course to avoid the leak.
#pragma empty_line
2. The error codes returned are non-POSIX like, and cast into ints.
This may cause incorrect error return due to truncation values on
hw where sizeof (DWORD) > sizeof (int).
#pragma empty_line
3. We are currently using a special mutex instead of the Critical
Sections, since Win9x does not support TryEnterCriticalSection
(while NT does).
#pragma empty_line
The basic framework should work well enough. In the long term, GCC
needs to use Structured Exception Handling on Windows32. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\errno.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 9 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\errno.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) extern int * _errno(void);
#pragma empty_line
#pragma empty_line
errno_t _set_errno(int _Value);
errno_t _get_errno(int *_Value);
#pragma line 74 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\errno.h" 3
}
#pragma line 71 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr-default.h" 2 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 73 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr-default.h" 2 3
#pragma line 340 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr-default.h" 3
extern "C" {
#pragma empty_line
#pragma empty_line
typedef unsigned long __gthread_key_t;
#pragma empty_line
typedef struct {
int done;
long started;
} __gthread_once_t;
#pragma empty_line
typedef struct {
long counter;
void *sema;
} __gthread_mutex_t;
#pragma empty_line
typedef struct {
long counter;
long depth;
unsigned long owner;
void *sema;
} __gthread_recursive_mutex_t;
#pragma line 371 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr-default.h" 3
/* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
if -mthreads option was specified, or 0 otherwise. This is to get around
the lack of weak symbols in PE-COFF. */
extern int _CRT_MT;
extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
#pragma empty_line
#pragma empty_line
/* The Windows95 kernel does not export InterlockedCompareExchange.
This provides a substitute. When building apps that reference
gthread_mutex_try_lock, the __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
macro must be defined if Windows95 is a target. Currently
gthread_mutex_try_lock is not referenced by libgcc or libstdc++. */
#pragma line 401 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
#pragma empty_line
return _CRT_MT;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The implementations are in config/i386/gthr-win32.c in libgcc.a.
Only stubs are exposed to avoid polluting the C++ namespace with
windows api definitions. */
#pragma empty_line
extern int __gthr_win32_once (__gthread_once_t *, void (*) (void));
extern int __gthr_win32_key_create (__gthread_key_t *, void (*) (void*));
extern int __gthr_win32_key_delete (__gthread_key_t);
extern void * __gthr_win32_getspecific (__gthread_key_t);
extern int __gthr_win32_setspecific (__gthread_key_t, const void *);
extern void __gthr_win32_mutex_init_function (__gthread_mutex_t *);
extern int __gthr_win32_mutex_lock (__gthread_mutex_t *);
extern int __gthr_win32_mutex_trylock (__gthread_mutex_t *);
extern int __gthr_win32_mutex_unlock (__gthread_mutex_t *);
extern void
__gthr_win32_recursive_mutex_init_function (__gthread_recursive_mutex_t *);
extern int __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *);
extern int
__gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *);
extern int __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
extern void __gthr_win32_mutex_destroy (__gthread_mutex_t *);
#pragma empty_line
static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
return __gthr_win32_once (__once, __func);
else
return -1;
}
#pragma empty_line
static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
return __gthr_win32_key_create (__key, __dtor);
}
#pragma empty_line
static inline int
__gthread_key_delete (__gthread_key_t __key)
{
return __gthr_win32_key_delete (__key);
}
#pragma empty_line
static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
return __gthr_win32_getspecific (__key);
}
#pragma empty_line
static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
return __gthr_win32_setspecific (__key, __ptr);
}
#pragma empty_line
static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
__gthr_win32_mutex_init_function (__mutex);
}
#pragma empty_line
static inline void
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
__gthr_win32_mutex_destroy (__mutex);
}
#pragma empty_line
static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_win32_mutex_lock (__mutex);
else
return 0;
}
#pragma empty_line
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_win32_mutex_trylock (__mutex);
else
return 0;
}
#pragma empty_line
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_win32_mutex_unlock (__mutex);
else
return 0;
}
#pragma empty_line
static inline void
__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
__gthr_win32_recursive_mutex_init_function (__mutex);
}
#pragma empty_line
static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_win32_recursive_mutex_lock (__mutex);
else
return 0;
}
#pragma empty_line
static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_win32_recursive_mutex_trylock (__mutex);
else
return 0;
}
#pragma empty_line
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthr_win32_recursive_mutex_unlock (__mutex);
else
return 0;
}
#pragma line 767 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr-default.h" 3
}
#pragma line 163 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/gthr.h" 2 3
#pragma empty_line
/* Fallback to single thread definitions. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/atomicity.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/atomic_word.h" 1 3
// Low-level type for atomic operations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2004, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file atomic_word.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int _Atomic_word;
#pragma empty_line
// Define these two macros using the appropriate memory barrier for the target.
// The commented out versions below are the defaults.
// See ia64/atomic_word.h for an alternative approach.
#pragma empty_line
// This one prevents loads from being hoisted across the barrier;
// in other words, this is a Load-Load acquire barrier.
// This is necessary iff TARGET_RELAXED_ORDERING is defined in tm.h.
// #define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory")
#pragma empty_line
// This one prevents stores from being sunk across the barrier; in other
// words, a Store-Store release barrier.
// #define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory")
#pragma line 36 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/atomicity.h" 2 3
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
// Functions for portable atomic access.
// To abstract locking primitives across all thread policies, use:
// __exchange_and_add_dispatch
// __atomic_add_dispatch
#pragma empty_line
static inline _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
{ return __sync_fetch_and_add(__mem, __val); }
#pragma empty_line
static inline void
__atomic_add(volatile _Atomic_word* __mem, int __val)
{ __sync_fetch_and_add(__mem, __val); }
#pragma line 61 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/atomicity.h" 3
static inline _Atomic_word
__exchange_and_add_single(_Atomic_word* __mem, int __val)
{
_Atomic_word __result = *__mem;
*__mem += __val;
return __result;
}
#pragma empty_line
static inline void
__atomic_add_single(_Atomic_word* __mem, int __val)
{ *__mem += __val; }
#pragma empty_line
static inline _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
{
#pragma empty_line
if (__gthread_active_p())
return __exchange_and_add(__mem, __val);
else
return __exchange_and_add_single(__mem, __val);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
static inline void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
{
#pragma empty_line
if (__gthread_active_p())
__atomic_add(__mem, __val);
else
__atomic_add_single(__mem, __val);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
}
#pragma empty_line
// Even if the CPU doesn't need a memory barrier, we need to ensure
// that the compiler doesn't reorder memory accesses across the
// barriers.
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ios_base.h" 2 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_classes.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file locale_classes.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_classes.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\string" 1 3
// Components for manipulating sequences of characters -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
// 2005, 2006, 2007, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/string
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\string" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/allocator.h" 1 3
// Allocators -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
* Copyright (c) 1996-1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file allocator.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Define the base class to std::allocator.
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++allocator.h" 1 3
// Base to std::allocator -*- C++ -*-
#pragma empty_line
// Copyright (C) 2004, 2005, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file c++allocator.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Define new_allocator as the base class to std::allocator.
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/new_allocator.h" 1 3
// Allocator that wraps operator new -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ext/new_allocator.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\new" 1 3
// The -*- C++ -*- dynamic memory management header.
#pragma empty_line
// Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
// 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation
#pragma empty_line
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file new
* This is a Standard C++ Library header.
*
* The header @c new defines several functions to manage dynamic memory and
* handling memory allocation errors; see
* http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#4 for more.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\new" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cstddef
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.1 Types
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cstddef" 2 3
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\new" 2 3
#pragma empty_line
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
extern "C++" {
#pragma empty_line
namespace std
{
/**
* @brief Exception possibly thrown by @c new.
* @ingroup exceptions
*
* @c bad_alloc (or classes derived from it) is used to report allocation
* errors from the throwing forms of @c new. */
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
#pragma empty_line
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
virtual ~bad_alloc() throw();
#pragma empty_line
// See comment in eh_exception.cc.
virtual const char* what() const throw();
};
#pragma empty_line
struct nothrow_t { };
#pragma empty_line
extern const nothrow_t nothrow;
#pragma empty_line
/** If you write your own error handler to be called by @c new, it must
* be of this type. */
typedef void (*new_handler)();
#pragma empty_line
/// Takes a replacement handler as the argument, returns the
/// previous handler.
new_handler set_new_handler(new_handler) throw();
} // namespace std
#pragma empty_line
//@{
/** These are replaceable signatures:
* - normal single new and delete (no arguments, throw @c bad_alloc on error)
* - normal array new and delete (same)
* - @c nothrow single new and delete (take a @c nothrow argument, return
* @c NULL on error)
* - @c nothrow array new and delete (same)
*
* Placement new and delete signatures (take a memory address argument,
* does nothing) may not be replaced by a user's program.
*/
void* operator new(std::size_t) throw (std::bad_alloc);
void* operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void*) throw();
void operator delete[](void*) throw();
void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();
#pragma empty_line
// Default placement versions of operator new.
inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
#pragma empty_line
// Default placement versions of operator delete.
inline void operator delete (void*, void*) throw() { }
inline void operator delete[](void*, void*) throw() { }
//@}
} // extern "C++"
#pragma empty_line
#pragma GCC visibility pop
#pragma line 34 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/new_allocator.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx {
#pragma empty_line
using std::size_t;
using std::ptrdiff_t;
#pragma empty_line
/**
* @brief An allocator that uses global new, as per [20.4].
* @ingroup allocators
*
* This is precisely the allocator defined in the C++ Standard.
* - all allocation calls operator new
* - all deallocation calls operator delete
*/
template<typename _Tp>
class new_allocator
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
#pragma empty_line
template<typename _Tp1>
struct rebind
{ typedef new_allocator<_Tp1> other; };
#pragma empty_line
new_allocator() throw() { }
#pragma empty_line
new_allocator(const new_allocator&) throw() { }
#pragma empty_line
template<typename _Tp1>
new_allocator(const new_allocator<_Tp1>&) throw() { }
#pragma empty_line
~new_allocator() throw() { }
#pragma empty_line
pointer
address(reference __x) const { return &__x; }
#pragma empty_line
const_pointer
address(const_reference __x) const { return &__x; }
#pragma empty_line
// NB: __n is permitted to be 0. The C++ standard says nothing
// about what the return value is when __n == 0.
pointer
allocate(size_type __n, const void* = 0)
{
if (__n > this->max_size())
std::__throw_bad_alloc();
#pragma empty_line
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
}
#pragma empty_line
// __p is not permitted to be a null pointer.
void
deallocate(pointer __p, size_type)
{ ::operator delete(__p); }
#pragma empty_line
size_type
max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); }
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct
void
construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) _Tp(__val); }
#pragma line 114 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ext/new_allocator.h" 3
void
destroy(pointer __p) { __p->~_Tp(); }
};
#pragma empty_line
template<typename _Tp>
inline bool
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return true; }
#pragma empty_line
template<typename _Tp>
inline bool
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return false; }
#pragma empty_line
}
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/c++allocator.h" 2 3
#pragma line 49 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/allocator.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @defgroup allocators Allocators
* @ingroup memory
*
* Classes encapsulating memory operations.
*/
#pragma empty_line
template<typename _Tp>
class allocator;
#pragma empty_line
/// allocator<void> specialization.
template<>
class allocator<void>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
#pragma empty_line
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
};
#pragma empty_line
/**
* @brief The @a standard allocator, as per [20.4].
* @ingroup allocators
*
* Further details:
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
*/
template<typename _Tp>
class allocator: public __gnu_cxx::new_allocator<_Tp>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
#pragma empty_line
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
#pragma empty_line
allocator() throw() { }
#pragma empty_line
allocator(const allocator& __a) throw()
: __gnu_cxx::new_allocator<_Tp>(__a) { }
#pragma empty_line
template<typename _Tp1>
allocator(const allocator<_Tp1>&) throw() { }
#pragma empty_line
~allocator() throw() { }
#pragma empty_line
// Inherit everything else.
};
#pragma empty_line
template<typename _T1, typename _T2>
inline bool
operator==(const allocator<_T1>&, const allocator<_T2>&)
{ return true; }
#pragma empty_line
template<typename _Tp>
inline bool
operator==(const allocator<_Tp>&, const allocator<_Tp>&)
{ return true; }
#pragma empty_line
template<typename _T1, typename _T2>
inline bool
operator!=(const allocator<_T1>&, const allocator<_T2>&)
{ return false; }
#pragma empty_line
template<typename _Tp>
inline bool
operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
{ return false; }
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class allocator<char>;
extern template class allocator<wchar_t>;
#pragma empty_line
#pragma empty_line
// Undefine.
#pragma empty_line
#pragma empty_line
// To implement Option 3 of DR 431.
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_swap
{ static void _S_do_it(_Alloc&, _Alloc&) { } };
#pragma empty_line
template<typename _Alloc>
struct __alloc_swap<_Alloc, false>
{
static void
_S_do_it(_Alloc& __one, _Alloc& __two)
{
// Precondition: swappable allocators.
if (__one != __two)
swap(__one, __two);
}
};
#pragma empty_line
// Optimize for stateless allocators.
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_neq
{
static bool
_S_do_it(const _Alloc&, const _Alloc&)
{ return false; }
};
#pragma empty_line
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __two)
{ return __one != __two; }
};
#pragma line 204 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/allocator.h" 3
}
#pragma line 43 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\string" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ostream_insert.h" 1 3
// Helpers for ostream inserters -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ostream_insert.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ostream_insert.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cxxabi-forced.h" 1 3
// cxxabi.h subset for inclusion by other library headers -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file cxxabi-forced.h
* The header provides an interface to the C++ ABI.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cxxabi-forced.h" 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
namespace __cxxabiv1
{
/**
* @brief Thrown as part of forced unwinding.
* @ingroup exceptions
*
* A magic placeholder class that can be caught by reference to
* recognize forced unwinding.
*/
#define virtual
#pragma line 46 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cxxabi-forced.h"
class __forced_unwind
{
virtual ~__forced_unwind() throw();
#pragma empty_line
// Prevent catch by value.
#if 0
#pragma line 51 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cxxabi-forced.h"
virtual void __pure_dummy() = 0;
#endif
#pragma line 52 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cxxabi-forced.h"
};
#undef virtual
#pragma line 53 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cxxabi-forced.h"
}
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 36 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ostream_insert.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _CharT, typename _Traits>
inline void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
#pragma empty_line
const streamsize __put = __out.rdbuf()->sputn(__s, __n);
if (__put != __n)
__out.setstate(__ios_base::badbit);
}
#pragma empty_line
template<typename _CharT, typename _Traits>
inline void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
#pragma empty_line
const _CharT __c = __out.fill();
for (; __n > 0; --__n)
{
const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
if (_Traits::eq_int_type(__put, _Traits::eof()))
{
__out.setstate(__ios_base::badbit);
break;
}
}
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
#pragma empty_line
typename __ostream_type::sentry __cerb(__out);
if (__cerb)
{
if (true)
{
const streamsize __w = __out.width();
if (__w > __n)
{
const bool __left = ((__out.flags()
& __ios_base::adjustfield)
== __ios_base::left);
if (!__left)
__ostream_fill(__out, __w - __n);
if (__out.good())
__ostream_write(__out, __s, __n);
if (__left && __out.good())
__ostream_fill(__out, __w - __n);
}
else
__ostream_write(__out, __s, __n);
__out.width(0);
}
if (false)
{
__out._M_setstate(__ios_base::badbit);
;
}
if (false)
{ __out._M_setstate(__ios_base::badbit); }
}
return __out;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
#pragma empty_line
#pragma empty_line
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 46 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\string" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_function.h" 1 3
// Functor implementations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file stl_function.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
// 20.3.1 base classes
/** @defgroup functors Function Objects
* @ingroup utilities
*
* Function objects, or @e functors, are objects with an @c operator()
* defined and accessible. They can be passed as arguments to algorithm
* templates and used in place of a function pointer. Not only is the
* resulting expressiveness of the library increased, but the generated
* code can be more efficient than what you might write by hand. When we
* refer to @a functors, then, generally we include function pointers in
* the description as well.
*
* Often, functors are only created as temporaries passed to algorithm
* calls, rather than being created as named variables.
*
* Two examples taken from the standard itself follow. To perform a
* by-element addition of two vectors @c a and @c b containing @c double,
* and put the result in @c a, use
* \code
* transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
* \endcode
* To negate every element in @c a, use
* \code
* transform(a.begin(), a.end(), a.begin(), negate<double>());
* \endcode
* The addition and negation functions will be inlined directly.
*
* The standard functors are derived from structs named @c unary_function
* and @c binary_function. These two classes contain nothing but typedefs,
* to aid in generic (template) programming. If you write your own
* functors, you might consider doing the same.
*
* @{
*/
/**
* This is one of the @link functors functor base classes@endlink.
*/
template<typename _Arg, typename _Result>
struct unary_function
{
typedef _Arg argument_type; ///< @c argument_type is the type of the
/// argument (no surprises here)
#pragma empty_line
typedef _Result result_type; ///< @c result_type is the return type
};
#pragma empty_line
/**
* This is one of the @link functors functor base classes@endlink.
*/
template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function
{
typedef _Arg1 first_argument_type; ///< the type of the first argument
/// (no surprises here)
#pragma empty_line
typedef _Arg2 second_argument_type; ///< the type of the second argument
typedef _Result result_type; ///< type of the return type
};
/** @} */
#pragma empty_line
// 20.3.2 arithmetic
/** @defgroup arithmetic_functors Arithmetic Classes
* @ingroup functors
*
* Because basic math often needs to be done during an algorithm,
* the library provides functors for those operations. See the
* documentation for @link functors the base classes@endlink
* for examples of their use.
*
* @{
*/
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x + __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x - __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x * __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x / __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x % __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
{ return -__x; }
};
/** @} */
#pragma empty_line
// 20.3.3 comparisons
/** @defgroup comparison_functors Comparison Classes
* @ingroup functors
*
* The library provides six wrapper functors for all the basic comparisons
* in C++, like @c <.
*
* @{
*/
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x == __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x != __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x > __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x < __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x >= __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x <= __y; }
};
/** @} */
#pragma empty_line
// 20.3.4 logical operations
/** @defgroup logical_functors Boolean Operations Classes
* @ingroup functors
*
* Here are wrapper functors for Boolean operations: @c &&, @c ||,
* and @c !.
*
* @{
*/
/// One of the @link logical_functors Boolean operations functors@endlink.
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x && __y; }
};
#pragma empty_line
/// One of the @link logical_functors Boolean operations functors@endlink.
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x || __y; }
};
#pragma empty_line
/// One of the @link logical_functors Boolean operations functors@endlink.
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
bool
operator()(const _Tp& __x) const
{ return !__x; }
};
/** @} */
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 660. Missing Bitwise Operations.
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x & __y; }
};
#pragma empty_line
template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x | __y; }
};
#pragma empty_line
template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x ^ __y; }
};
#pragma empty_line
// 20.3.5 negators
/** @defgroup negators Negators
* @ingroup functors
*
* The functions @c not1 and @c not2 each take a predicate functor
* and return an instance of @c unary_negate or
* @c binary_negate, respectively. These classes are functors whose
* @c operator() performs the stored predicate function and then returns
* the negation of the result.
*
* For example, given a vector of integers and a trivial predicate,
* \code
* struct IntGreaterThanThree
* : public std::unary_function<int, bool>
* {
* bool operator() (int x) { return x > 3; }
* };
*
* std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
* \endcode
* The call to @c find_if will locate the first index (i) of @c v for which
* <code>!(v[i] > 3)</code> is true.
*
* The not1/unary_negate combination works on predicates taking a single
* argument. The not2/binary_negate combination works on predicates which
* take two arguments.
*
* @{
*/
/// One of the @link negators negation functors@endlink.
template<typename _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool>
{
protected:
_Predicate _M_pred;
#pragma empty_line
public:
explicit
unary_negate(const _Predicate& __x) : _M_pred(__x) { }
#pragma empty_line
bool
operator()(const typename _Predicate::argument_type& __x) const
{ return !_M_pred(__x); }
};
#pragma empty_line
/// One of the @link negators negation functors@endlink.
template<typename _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }
#pragma empty_line
/// One of the @link negators negation functors@endlink.
template<typename _Predicate>
class binary_negate
: public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type, bool>
{
protected:
_Predicate _M_pred;
#pragma empty_line
public:
explicit
binary_negate(const _Predicate& __x) : _M_pred(__x) { }
#pragma empty_line
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
{ return !_M_pred(__x, __y); }
};
#pragma empty_line
/// One of the @link negators negation functors@endlink.
template<typename _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }
/** @} */
#pragma empty_line
// 20.3.7 adaptors pointers functions
/** @defgroup pointer_adaptors Adaptors for pointers to functions
* @ingroup functors
*
* The advantage of function objects over pointers to functions is that
* the objects in the standard library declare nested typedefs describing
* their argument and result types with uniform names (e.g., @c result_type
* from the base classes @c unary_function and @c binary_function).
* Sometimes those typedefs are required, not just optional.
*
* Adaptors are provided to turn pointers to unary (single-argument) and
* binary (double-argument) functions into function objects. The
* long-winded functor @c pointer_to_unary_function is constructed with a
* function pointer @c f, and its @c operator() called with argument @c x
* returns @c f(x). The functor @c pointer_to_binary_function does the same
* thing, but with a double-argument @c f and @c operator().
*
* The function @c ptr_fun takes a pointer-to-function @c f and constructs
* an instance of the appropriate functor.
*
* @{
*/
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
template<typename _Arg, typename _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result>
{
protected:
_Result (*_M_ptr)(_Arg);
#pragma empty_line
public:
pointer_to_unary_function() { }
#pragma empty_line
explicit
pointer_to_unary_function(_Result (*__x)(_Arg))
: _M_ptr(__x) { }
#pragma empty_line
_Result
operator()(_Arg __x) const
{ return _M_ptr(__x); }
};
#pragma empty_line
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
template<typename _Arg, typename _Result>
inline pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
{ return pointer_to_unary_function<_Arg, _Result>(__x); }
#pragma empty_line
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
template<typename _Arg1, typename _Arg2, typename _Result>
class pointer_to_binary_function
: public binary_function<_Arg1, _Arg2, _Result>
{
protected:
_Result (*_M_ptr)(_Arg1, _Arg2);
#pragma empty_line
public:
pointer_to_binary_function() { }
#pragma empty_line
explicit
pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
: _M_ptr(__x) { }
#pragma empty_line
_Result
operator()(_Arg1 __x, _Arg2 __y) const
{ return _M_ptr(__x, __y); }
};
#pragma empty_line
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
template<typename _Arg1, typename _Arg2, typename _Result>
inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
/** @} */
#pragma empty_line
template<typename _Tp>
struct _Identity : public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
{ return __x; }
#pragma empty_line
const _Tp&
operator()(const _Tp& __x) const
{ return __x; }
};
#pragma empty_line
template<typename _Pair>
struct _Select1st : public unary_function<_Pair,
typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
{ return __x.first; }
#pragma empty_line
const typename _Pair::first_type&
operator()(const _Pair& __x) const
{ return __x.first; }
};
#pragma empty_line
template<typename _Pair>
struct _Select2nd : public unary_function<_Pair,
typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
{ return __x.second; }
#pragma empty_line
const typename _Pair::second_type&
operator()(const _Pair& __x) const
{ return __x.second; }
};
#pragma empty_line
// 20.3.8 adaptors pointers members
/** @defgroup memory_adaptors Adaptors for pointers to members
* @ingroup functors
*
* There are a total of 8 = 2^3 function objects in this family.
* (1) Member functions taking no arguments vs member functions taking
* one argument.
* (2) Call through pointer vs call through reference.
* (3) Const vs non-const member function.
*
* All of this complexity is in the function objects themselves. You can
* ignore it by using the helper function mem_fun and mem_fun_ref,
* which create whichever type of adaptor is appropriate.
*
* @{
*/
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(_Tp* __p) const
{ return (__p->*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)();
};
#pragma empty_line
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp>
class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
{
public:
explicit
const_mem_fun_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(const _Tp* __p) const
{ return (__p->*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)() const;
};
#pragma empty_line
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp>
class mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
mem_fun_ref_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(_Tp& __r) const
{ return (__r.*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)();
};
#pragma empty_line
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(const _Tp& __r) const
{ return (__r.*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)() const;
};
#pragma empty_line
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
{
public:
explicit
mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(_Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg);
};
#pragma empty_line
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(const _Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
#pragma empty_line
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(_Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg);
};
#pragma empty_line
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
template<typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }
#pragma empty_line
_Ret
operator()(const _Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
#pragma empty_line
// Mem_fun adaptor helper functions. There are only two:
// mem_fun and mem_fun_ref.
template<typename _Ret, typename _Tp>
inline mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
{ return mem_fun_t<_Ret, _Tp>(__f); }
#pragma empty_line
template<typename _Ret, typename _Tp>
inline const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_t<_Ret, _Tp>(__f); }
#pragma empty_line
template<typename _Ret, typename _Tp>
inline mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
{ return mem_fun_ref_t<_Ret, _Tp>(__f); }
#pragma empty_line
template<typename _Ret, typename _Tp>
inline const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
#pragma empty_line
template<typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
#pragma empty_line
template<typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
#pragma empty_line
template<typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
#pragma empty_line
template<typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
#pragma empty_line
/** @} */
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\backward/binders.h" 1 3
// Functor implementations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file backward/binders.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
// 20.3.6 binders
/** @defgroup binders Binder Classes
* @ingroup functors
*
* Binders turn functions/functors with two arguments into functors
* with a single argument, storing an argument to be applied later.
* For example, a variable @c B of type @c binder1st is constructed
* from a functor @c f and an argument @c x. Later, B's @c
* operator() is called with a single argument @c y. The return
* value is the value of @c f(x,y). @c B can be @a called with
* various arguments (y1, y2, ...) and will in turn call @c
* f(x,y1), @c f(x,y2), ...
*
* The function @c bind1st is provided to save some typing. It takes the
* function and an argument as parameters, and returns an instance of
* @c binder1st.
*
* The type @c binder2nd and its creator function @c bind2nd do the same
* thing, but the stored argument is passed as the second parameter instead
* of the first, e.g., @c bind2nd(std::minus<float>,1.3) will create a
* functor whose @c operator() accepts a floating-point number, subtracts
* 1.3 from it, and returns the result. (If @c bind1st had been used,
* the functor would perform <em>1.3 - x</em> instead.
*
* Creator-wrapper functions like @c bind1st are intended to be used in
* calling algorithms. Their return values will be temporary objects.
* (The goal is to not require you to type names like
* @c std::binder1st<std::plus<int>> for declaring a variable to hold the
* return value from @c bind1st(std::plus<int>,5).
*
* These become more useful when combined with the composition functions.
*
* @{
*/
/// One of the @link binders binder functors@endlink.
template<typename _Operation>
class binder1st
: public unary_function<typename _Operation::second_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::first_argument_type value;
#pragma empty_line
public:
binder1st(const _Operation& __x,
const typename _Operation::first_argument_type& __y)
: op(__x), value(__y) { }
#pragma empty_line
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 109. Missing binders for non-const sequence elements
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
} ;
#pragma empty_line
/// One of the @link binders binder functors@endlink.
template<typename _Operation, typename _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::first_argument_type _Arg1_type;
return binder1st<_Operation>(__fn, _Arg1_type(__x));
}
#pragma empty_line
/// One of the @link binders binder functors@endlink.
template<typename _Operation>
class binder2nd
: public unary_function<typename _Operation::first_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::second_argument_type value;
#pragma empty_line
public:
binder2nd(const _Operation& __x,
const typename _Operation::second_argument_type& __y)
: op(__x), value(__y) { }
#pragma empty_line
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 109. Missing binders for non-const sequence elements
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
} ;
#pragma empty_line
/// One of the @link binders binder functors@endlink.
template<typename _Operation, typename _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::second_argument_type _Arg2_type;
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}
/** @} */
#pragma empty_line
}
#pragma line 713 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/stl_function.h" 2 3
#pragma line 50 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\string" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 1 3
// Components for manipulating sequences of characters -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file basic_string.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\initializer_list" 1 3
// std::initializer_list support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file initializer_list
* This is a Standard C++ Library header.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\initializer_list" 3
#pragma line 43 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @class basic_string basic_string.h <string>
* @brief Managing sequences of characters and character-like objects.
*
* @ingroup strings
* @ingroup sequences
*
* Meets the requirements of a <a href="tables.html#65">container</a>, a
* <a href="tables.html#66">reversible container</a>, and a
* <a href="tables.html#67">sequence</a>. Of the
* <a href="tables.html#68">optional sequence requirements</a>, only
* @c push_back, @c at, and @c %array access are supported.
*
* @doctodo
*
*
* Documentation? What's that?
* Nathan Myers <ncm@cantrip.org>.
*
* A string looks like this:
*
* @code
* [_Rep]
* _M_length
* [basic_string<char_type>] _M_capacity
* _M_dataplus _M_refcount
* _M_p ----------------> unnamed array of char_type
* @endcode
*
* Where the _M_p points to the first character in the string, and
* you cast it to a pointer-to-_Rep and subtract 1 to get a
* pointer to the header.
*
* This approach has the enormous advantage that a string object
* requires only one allocation. All the ugliness is confined
* within a single %pair of inline functions, which each compile to
* a single @a add instruction: _Rep::_M_data(), and
* string::_M_rep(); and the allocation function which gets a
* block of raw bytes and with room enough and constructs a _Rep
* object at the front.
*
* The reason you want _M_data pointing to the character %array and
* not the _Rep is so that the debugger can see the string
* contents. (Probably we should add a non-inline member to get
* the _Rep for the debugger to use, so users can check the actual
* string length.)
*
* Note that the _Rep object is a POD so that you can have a
* static <em>empty string</em> _Rep object already @a constructed before
* static constructors have run. The reference-count encoding is
* chosen so that a 0 indicates one reference, so you never try to
* destroy the empty-string _Rep object.
*
* All but the last paragraph is considered pretty conventional
* for a C++ string implementation.
*/
// 21.3 Template class basic_string
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
#pragma empty_line
// Types:
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Alloc allocator_type;
typedef typename _CharT_alloc_type::size_type size_type;
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef typename _CharT_alloc_type::reference reference;
typedef typename _CharT_alloc_type::const_reference const_reference;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
#pragma empty_line
private:
// _Rep: string representation
// Invariants:
// 1. String really contains _M_length + 1 characters: due to 21.3.4
// must be kept null-terminated.
// 2. _M_capacity >= _M_length
// Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
// 3. _M_refcount has three states:
// -1: leaked, one reference, no ref-copies allowed, non-const.
// 0: one reference, non-const.
// n>0: n + 1 references, operations require a lock, const.
// 4. All fields==0 is an empty string, given the extra storage
// beyond-the-end for a null terminator; thus, the shared
// empty string representation needs no constructor.
#pragma empty_line
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
#pragma empty_line
struct _Rep : _Rep_base
{
// Types:
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
#pragma empty_line
// (Public) Data members:
#pragma empty_line
// The maximum number of individual char_type elements of an
// individual string is determined by _S_max_size. This is the
// value that will be returned by max_size(). (Whereas npos
// is the maximum number of bytes the allocator can allocate.)
// If one was to divvy up the theoretical largest size string,
// with a terminating character and m _CharT elements, it'd
// look like this:
// npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
// Solving for m:
// m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
// In addition, this implementation quarters this amount.
static const size_type _S_max_size;
static const _CharT _S_terminal;
#pragma empty_line
// The following storage is init'd to 0 by the linker, resulting
// (carefully) in an empty string with one reference.
static size_type _S_empty_rep_storage[];
#pragma empty_line
static _Rep&
_S_empty_rep()
{
// NB: Mild hack to avoid strict-aliasing warnings. Note that
// _S_empty_rep_storage is never modified and the punning should
// be reasonably safe in this case.
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
return *reinterpret_cast<_Rep*>(__p);
}
#pragma empty_line
bool
_M_is_leaked() const
{ return this->_M_refcount < 0; }
#pragma empty_line
bool
_M_is_shared() const
{ return this->_M_refcount > 0; }
#pragma empty_line
void
_M_set_leaked()
{ this->_M_refcount = -1; }
#pragma empty_line
void
_M_set_sharable()
{ this->_M_refcount = 0; }
#pragma empty_line
void
_M_set_length_and_sharable(size_type __n)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
this->_M_set_sharable(); // One reference.
this->_M_length = __n;
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
// grrr. (per 21.3.4)
// You cannot leave those LWG people alone for a second.
}
}
#pragma empty_line
_CharT*
_M_refdata() throw()
{ return reinterpret_cast<_CharT*>(this + 1); }
#pragma empty_line
_CharT*
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
{
return (!_M_is_leaked() && __alloc1 == __alloc2)
? _M_refcopy() : _M_clone(__alloc1);
}
#pragma empty_line
// Create & Destroy
static _Rep*
_S_create(size_type, size_type, const _Alloc&);
#pragma empty_line
void
_M_dispose(const _Alloc& __a)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
-1) <= 0)
_M_destroy(__a);
} // XXX MT
#pragma empty_line
void
_M_destroy(const _Alloc&) throw();
#pragma empty_line
_CharT*
_M_refcopy() throw()
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
__gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
return _M_refdata();
} // XXX MT
#pragma empty_line
_CharT*
_M_clone(const _Alloc&, size_type __res = 0);
};
#pragma empty_line
// Use empty-base optimization: http://www.cantrip.org/emptyopt.html
struct _Alloc_hider : _Alloc
{
_Alloc_hider(_CharT* __dat, const _Alloc& __a)
: _Alloc(__a), _M_p(__dat) { }
#pragma empty_line
_CharT* _M_p; // The actual data.
};
#pragma empty_line
public:
// Data Members (public):
// NB: This is an unsigned type, and thus represents the maximum
// size that the allocator can hold.
/// Value returned by various member functions when they fail.
static const size_type npos = static_cast<size_type>(-1);
#pragma empty_line
private:
// Data Members (private):
mutable _Alloc_hider _M_dataplus;
#pragma empty_line
_CharT*
_M_data() const
{ return _M_dataplus._M_p; }
#pragma empty_line
_CharT*
_M_data(_CharT* __p)
{ return (_M_dataplus._M_p = __p); }
#pragma empty_line
_Rep*
_M_rep() const
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
#pragma empty_line
// For the internal use we have functions similar to `begin'/`end'
// but they do not call _M_leak.
iterator
_M_ibegin() const
{ return iterator(_M_data()); }
#pragma empty_line
iterator
_M_iend() const
{ return iterator(_M_data() + this->size()); }
#pragma empty_line
void
_M_leak() // for use in begin() & non-const op[]
{
if (!_M_rep()->_M_is_leaked())
_M_leak_hard();
}
#pragma empty_line
size_type
_M_check(size_type __pos, const char* __s) const
{
if (__pos > this->size())
__throw_out_of_range((__s));
return __pos;
}
#pragma empty_line
void
_M_check_length(size_type __n1, size_type __n2, const char* __s) const
{
if (this->max_size() - (this->size() - __n1) < __n2)
__throw_length_error((__s));
}
#pragma empty_line
// NB: _M_limit doesn't check for a bad __pos value.
size_type
_M_limit(size_type __pos, size_type __off) const
{
const bool __testoff = __off < this->size() - __pos;
return __testoff ? __off : this->size() - __pos;
}
#pragma empty_line
// True if _Rep and source do not overlap.
bool
_M_disjunct(const _CharT* __s) const
{
return (less<const _CharT*>()(__s, _M_data())
|| less<const _CharT*>()(_M_data() + this->size(), __s));
}
#pragma empty_line
// When __n = 1 way faster than the general multichar
// traits_type::copy/move/assign.
static void
_M_copy(_CharT* __d, const _CharT* __s, size_type __n)
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::copy(__d, __s, __n);
}
#pragma empty_line
static void
_M_move(_CharT* __d, const _CharT* __s, size_type __n)
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::move(__d, __s, __n);
}
#pragma empty_line
static void
_M_assign(_CharT* __d, size_type __n, _CharT __c)
{
if (__n == 1)
traits_type::assign(*__d, __c);
else
traits_type::assign(__d, __n, __c);
}
#pragma empty_line
// _S_copy_chars is a separate template to permit specialization
// to optimize for the common case of pointers as iterators.
template<class _Iterator>
static void
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
{
for (; __k1 != __k2; ++__k1, ++__p)
traits_type::assign(*__p, *__k1); // These types are off.
}
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
{ _M_copy(__p, __k1, __k2 - __k1); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
{ _M_copy(__p, __k1, __k2 - __k1); }
#pragma empty_line
static int
_S_compare(size_type __n1, size_type __n2)
{
const difference_type __d = difference_type(__n1 - __n2);
#pragma empty_line
if (__d > __gnu_cxx::__numeric_traits<int>::__max)
return __gnu_cxx::__numeric_traits<int>::__max;
else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
return __gnu_cxx::__numeric_traits<int>::__min;
else
return int(__d);
}
#pragma empty_line
void
_M_mutate(size_type __pos, size_type __len1, size_type __len2);
#pragma empty_line
void
_M_leak_hard();
#pragma empty_line
static _Rep&
_S_empty_rep()
{ return _Rep::_S_empty_rep(); }
#pragma empty_line
public:
// Construct/copy/destroy:
// NB: We overload ctors in some cases instead of using default
// arguments, per 17.4.4.4 para. 2 item 2.
#pragma empty_line
/**
* @brief Default constructor creates an empty string.
*/
basic_string()
#pragma empty_line
#pragma empty_line
#pragma empty_line
: _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc()){ }
#pragma empty_line
#pragma empty_line
/**
* @brief Construct an empty string using allocator @a a.
*/
explicit
basic_string(const _Alloc& __a);
#pragma empty_line
// NB: per LWG issue 42, semantics different from IS:
/**
* @brief Construct string with copy of value of @a str.
* @param str Source string.
*/
basic_string(const basic_string& __str);
/**
* @brief Construct string as copy of a substring.
* @param str Source string.
* @param pos Index of first character to copy from.
* @param n Number of characters to copy (default remainder).
*/
basic_string(const basic_string& __str, size_type __pos,
size_type __n = npos);
/**
* @brief Construct string as copy of a substring.
* @param str Source string.
* @param pos Index of first character to copy from.
* @param n Number of characters to copy.
* @param a Allocator to use.
*/
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a);
#pragma empty_line
/**
* @brief Construct string initialized by a character %array.
* @param s Source character %array.
* @param n Number of characters to copy.
* @param a Allocator to use (default is default allocator).
*
* NB: @a s must have at least @a n characters, '\\0'
* has no special meaning.
*/
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc());
/**
* @brief Construct string as copy of a C string.
* @param s Source C string.
* @param a Allocator to use (default is default allocator).
*/
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
/**
* @brief Construct string as multiple characters.
* @param n Number of characters.
* @param c Character to use.
* @param a Allocator to use (default is default allocator).
*/
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
#pragma line 510 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
/**
* @brief Construct string as copy of a range.
* @param beg Start of range.
* @param end End of range.
* @param a Allocator to use (default is default allocator).
*/
template<class _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc());
#pragma empty_line
/**
* @brief Destroy the string instance.
*/
~basic_string()
{ _M_rep()->_M_dispose(this->get_allocator()); }
#pragma empty_line
/**
* @brief Assign the value of @a str to this string.
* @param str Source string.
*/
basic_string&
operator=(const basic_string& __str)
{ return this->assign(__str); }
#pragma empty_line
/**
* @brief Copy contents of @a s into this string.
* @param s Source null-terminated string.
*/
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
#pragma empty_line
/**
* @brief Set value to string of length 1.
* @param c Source character.
*
* Assigning to a character makes this string length 1 and
* (*this)[0] == @a c.
*/
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
#pragma line 584 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
// Iterators:
/**
* Returns a read/write iterator that points to the first character in
* the %string. Unshares the string.
*/
iterator
begin()
{
_M_leak();
return iterator(_M_data());
}
#pragma empty_line
/**
* Returns a read-only (constant) iterator that points to the first
* character in the %string.
*/
const_iterator
begin() const
{ return const_iterator(_M_data()); }
#pragma empty_line
/**
* Returns a read/write iterator that points one past the last
* character in the %string. Unshares the string.
*/
iterator
end()
{
_M_leak();
return iterator(_M_data() + this->size());
}
#pragma empty_line
/**
* Returns a read-only (constant) iterator that points one past the
* last character in the %string.
*/
const_iterator
end() const
{ return const_iterator(_M_data() + this->size()); }
#pragma empty_line
/**
* Returns a read/write reverse iterator that points to the last
* character in the %string. Iteration is done in reverse element
* order. Unshares the string.
*/
reverse_iterator
rbegin()
{ return reverse_iterator(this->end()); }
#pragma empty_line
/**
* Returns a read-only (constant) reverse iterator that points
* to the last character in the %string. Iteration is done in
* reverse element order.
*/
const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(this->end()); }
#pragma empty_line
/**
* Returns a read/write reverse iterator that points to one before the
* first character in the %string. Iteration is done in reverse
* element order. Unshares the string.
*/
reverse_iterator
rend()
{ return reverse_iterator(this->begin()); }
#pragma empty_line
/**
* Returns a read-only (constant) reverse iterator that points
* to one before the first character in the %string. Iteration
* is done in reverse element order.
*/
const_reverse_iterator
rend() const
{ return const_reverse_iterator(this->begin()); }
#pragma line 695 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
public:
// Capacity:
/// Returns the number of characters in the string, not including any
/// null-termination.
size_type
size() const
{ return _M_rep()->_M_length; }
#pragma empty_line
/// Returns the number of characters in the string, not including any
/// null-termination.
size_type
length() const
{ return _M_rep()->_M_length; }
#pragma empty_line
/// Returns the size() of the largest possible %string.
size_type
max_size() const
{ return _Rep::_S_max_size; }
#pragma empty_line
/**
* @brief Resizes the %string to the specified number of characters.
* @param n Number of characters the %string should contain.
* @param c Character to fill any new elements.
*
* This function will %resize the %string to the specified
* number of characters. If the number is smaller than the
* %string's current size the %string is truncated, otherwise
* the %string is extended and new elements are %set to @a c.
*/
void
resize(size_type __n, _CharT __c);
#pragma empty_line
/**
* @brief Resizes the %string to the specified number of characters.
* @param n Number of characters the %string should contain.
*
* This function will resize the %string to the specified length. If
* the new size is smaller than the %string's current size the %string
* is truncated, otherwise the %string is extended and new characters
* are default-constructed. For basic types such as char, this means
* setting them to 0.
*/
void
resize(size_type __n)
{ this->resize(__n, _CharT()); }
#pragma line 753 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
/**
* Returns the total number of characters that the %string can hold
* before needing to allocate more memory.
*/
size_type
capacity() const
{ return _M_rep()->_M_capacity; }
#pragma empty_line
/**
* @brief Attempt to preallocate enough memory for specified number of
* characters.
* @param res_arg Number of characters required.
* @throw std::length_error If @a res_arg exceeds @c max_size().
*
* This function attempts to reserve enough memory for the
* %string to hold the specified number of characters. If the
* number requested is more than max_size(), length_error is
* thrown.
*
* The advantage of this function is that if optimal code is a
* necessity and the user can determine the string length that will be
* required, the user can reserve the memory in %advance, and thus
* prevent a possible reallocation of memory and copying of %string
* data.
*/
void
reserve(size_type __res_arg = 0);
#pragma empty_line
/**
* Erases the string, making it empty.
*/
void
clear()
{ _M_mutate(0, this->size(), 0); }
#pragma empty_line
/**
* Returns true if the %string is empty. Equivalent to
* <code>*this == ""</code>.
*/
bool
empty() const
{ return this->size() == 0; }
#pragma empty_line
// Element access:
/**
* @brief Subscript access to the data contained in the %string.
* @param pos The index of the character to access.
* @return Read-only (constant) reference to the character.
*
* This operator allows for easy, array-style, data access.
* Note that data access with this operator is unchecked and
* out_of_range lookups are not defined. (For checked lookups
* see at().)
*/
const_reference
operator[] (size_type __pos) const
{
;
return _M_data()[__pos];
}
#pragma empty_line
/**
* @brief Subscript access to the data contained in the %string.
* @param pos The index of the character to access.
* @return Read/write reference to the character.
*
* This operator allows for easy, array-style, data access.
* Note that data access with this operator is unchecked and
* out_of_range lookups are not defined. (For checked lookups
* see at().) Unshares the string.
*/
reference
operator[](size_type __pos)
{
// allow pos == size() as v3 extension:
;
// but be strict in pedantic mode:
;
_M_leak();
return _M_data()[__pos];
}
#pragma empty_line
/**
* @brief Provides access to the data contained in the %string.
* @param n The index of the character to access.
* @return Read-only (const) reference to the character.
* @throw std::out_of_range If @a n is an invalid index.
*
* This function provides for safer data access. The parameter is
* first checked that it is in the range of the string. The function
* throws out_of_range if the check fails.
*/
const_reference
at(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range(("basic_string::at"));
return _M_data()[__n];
}
#pragma empty_line
/**
* @brief Provides access to the data contained in the %string.
* @param n The index of the character to access.
* @return Read/write reference to the character.
* @throw std::out_of_range If @a n is an invalid index.
*
* This function provides for safer data access. The parameter is
* first checked that it is in the range of the string. The function
* throws out_of_range if the check fails. Success results in
* unsharing the string.
*/
reference
at(size_type __n)
{
if (__n >= size())
__throw_out_of_range(("basic_string::at"));
_M_leak();
return _M_data()[__n];
}
#pragma empty_line
// Modifiers:
/**
* @brief Append a string to this string.
* @param str The string to append.
* @return Reference to this string.
*/
basic_string&
operator+=(const basic_string& __str)
{ return this->append(__str); }
#pragma empty_line
/**
* @brief Append a C string.
* @param s The C string to append.
* @return Reference to this string.
*/
basic_string&
operator+=(const _CharT* __s)
{ return this->append(__s); }
#pragma empty_line
/**
* @brief Append a character.
* @param c The character to append.
* @return Reference to this string.
*/
basic_string&
operator+=(_CharT __c)
{
this->push_back(__c);
return *this;
}
#pragma line 915 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
/**
* @brief Append a string to this string.
* @param str The string to append.
* @return Reference to this string.
*/
basic_string&
append(const basic_string& __str);
#pragma empty_line
/**
* @brief Append a substring.
* @param str The string to append.
* @param pos Index of the first character of str to append.
* @param n The number of characters to append.
* @return Reference to this string.
* @throw std::out_of_range if @a pos is not a valid index.
*
* This function appends @a n characters from @a str starting at @a pos
* to this string. If @a n is is larger than the number of available
* characters in @a str, the remainder of @a str is appended.
*/
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n);
#pragma empty_line
/**
* @brief Append a C substring.
* @param s The C string to append.
* @param n The number of characters to append.
* @return Reference to this string.
*/
basic_string&
append(const _CharT* __s, size_type __n);
#pragma empty_line
/**
* @brief Append a C string.
* @param s The C string to append.
* @return Reference to this string.
*/
basic_string&
append(const _CharT* __s)
{
;
return this->append(__s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Append multiple characters.
* @param n The number of characters to append.
* @param c The character to use.
* @return Reference to this string.
*
* Appends n copies of c to this string.
*/
basic_string&
append(size_type __n, _CharT __c);
#pragma line 981 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
/**
* @brief Append a range of characters.
* @param first Iterator referencing the first character to append.
* @param last Iterator marking the end of the range.
* @return Reference to this string.
*
* Appends characters in the range [first,last) to this string.
*/
template<class _InputIterator>
basic_string&
append(_InputIterator __first, _InputIterator __last)
{ return this->replace(_M_iend(), _M_iend(), __first, __last); }
#pragma empty_line
/**
* @brief Append a single character.
* @param c Character to append.
*/
void
push_back(_CharT __c)
{
const size_type __len = 1 + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
traits_type::assign(_M_data()[this->size()], __c);
_M_rep()->_M_set_length_and_sharable(__len);
}
#pragma empty_line
/**
* @brief Set value to contents of another string.
* @param str Source string to use.
* @return Reference to this string.
*/
basic_string&
assign(const basic_string& __str);
#pragma line 1033 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
/**
* @brief Set value to a substring of a string.
* @param str The string to use.
* @param pos Index of the first character of str.
* @param n Number of characters to use.
* @return Reference to this string.
* @throw std::out_of_range if @a pos is not a valid index.
*
* This function sets this string to the substring of @a str consisting
* of @a n characters at @a pos. If @a n is is larger than the number
* of available characters in @a str, the remainder of @a str is used.
*/
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
{ return this->assign(__str._M_data()
+ __str._M_check(__pos, "basic_string::assign"),
__str._M_limit(__pos, __n)); }
#pragma empty_line
/**
* @brief Set value to a C substring.
* @param s The C string to use.
* @param n Number of characters to use.
* @return Reference to this string.
*
* This function sets the value of this string to the first @a n
* characters of @a s. If @a n is is larger than the number of
* available characters in @a s, the remainder of @a s is used.
*/
basic_string&
assign(const _CharT* __s, size_type __n);
#pragma empty_line
/**
* @brief Set value to contents of a C string.
* @param s The C string to use.
* @return Reference to this string.
*
* This function sets the value of this string to the value of @a s.
* The data is copied, so there is no dependence on @a s once the
* function returns.
*/
basic_string&
assign(const _CharT* __s)
{
;
return this->assign(__s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Set value to multiple characters.
* @param n Length of the resulting string.
* @param c The character to use.
* @return Reference to this string.
*
* This function sets the value of this string to @a n copies of
* character @a c.
*/
basic_string&
assign(size_type __n, _CharT __c)
{ return _M_replace_aux(size_type(0), this->size(), __n, __c); }
#pragma empty_line
/**
* @brief Set value to a range of characters.
* @param first Iterator referencing the first character to append.
* @param last Iterator marking the end of the range.
* @return Reference to this string.
*
* Sets value of string to characters in the range [first,last).
*/
template<class _InputIterator>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
{ return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
#pragma line 1117 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
/**
* @brief Insert multiple characters.
* @param p Iterator referencing location in string to insert at.
* @param n Number of characters to insert
* @param c The character to insert.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts @a n copies of character @a c starting at the position
* referenced by iterator @a p. If adding characters causes the length
* to exceed max_size(), length_error is thrown. The value of the
* string doesn't change if an error is thrown.
*/
void
insert(iterator __p, size_type __n, _CharT __c)
{ this->replace(__p, __p, __n, __c); }
#pragma empty_line
/**
* @brief Insert a range of characters.
* @param p Iterator referencing location in string to insert at.
* @param beg Start of range.
* @param end End of range.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts characters in range [beg,end). If adding characters causes
* the length to exceed max_size(), length_error is thrown. The value
* of the string doesn't change if an error is thrown.
*/
template<class _InputIterator>
void
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
{ this->replace(__p, __p, __beg, __end); }
#pragma line 1164 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
/**
* @brief Insert value of a string.
* @param pos1 Iterator referencing location in string to insert at.
* @param str The string to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts value of @a str starting at @a pos1. If adding characters
* causes the length to exceed max_size(), length_error is thrown. The
* value of the string doesn't change if an error is thrown.
*/
basic_string&
insert(size_type __pos1, const basic_string& __str)
{ return this->insert(__pos1, __str, size_type(0), __str.size()); }
#pragma empty_line
/**
* @brief Insert a substring.
* @param pos1 Iterator referencing location in string to insert at.
* @param str The string to insert.
* @param pos2 Start of characters in str to insert.
* @param n Number of characters to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos1 > size() or
* @a pos2 > @a str.size().
*
* Starting at @a pos1, insert @a n character of @a str beginning with
* @a pos2. If adding characters causes the length to exceed
* max_size(), length_error is thrown. If @a pos1 is beyond the end of
* this string or @a pos2 is beyond the end of @a str, out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
{ return this->insert(__pos1, __str._M_data()
+ __str._M_check(__pos2, "basic_string::insert"),
__str._M_limit(__pos2, __n)); }
#pragma empty_line
/**
* @brief Insert a C substring.
* @param pos Iterator referencing location in string to insert at.
* @param s The C string to insert.
* @param n The number of characters to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Inserts the first @a n characters of @a s starting at @a pos. If
* adding characters causes the length to exceed max_size(),
* length_error is thrown. If @a pos is beyond end(), out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n);
#pragma empty_line
/**
* @brief Insert a C string.
* @param pos Iterator referencing location in string to insert at.
* @param s The C string to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Inserts the first @a n characters of @a s starting at @a pos. If
* adding characters causes the length to exceed max_size(),
* length_error is thrown. If @a pos is beyond end(), out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
basic_string&
insert(size_type __pos, const _CharT* __s)
{
;
return this->insert(__pos, __s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Insert multiple characters.
* @param pos Index in string to insert at.
* @param n Number of characters to insert
* @param c The character to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Inserts @a n copies of character @a c starting at index @a pos. If
* adding characters causes the length to exceed max_size(),
* length_error is thrown. If @a pos > length(), out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
size_type(0), __n, __c); }
#pragma empty_line
/**
* @brief Insert one character.
* @param p Iterator referencing position in string to insert at.
* @param c The character to insert.
* @return Iterator referencing newly inserted char.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts character @a c at position referenced by @a p. If adding
* character causes the length to exceed max_size(), length_error is
* thrown. If @a p is beyond end of string, out_of_range is thrown.
* The value of the string doesn't change if an error is thrown.
*/
iterator
insert(iterator __p, _CharT __c)
{
;
const size_type __pos = __p - _M_ibegin();
_M_replace_aux(__pos, size_type(0), size_type(1), __c);
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
#pragma empty_line
/**
* @brief Remove characters.
* @param pos Index of first character to remove (default 0).
* @param n Number of characters to remove (default remainder).
* @return Reference to this string.
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Removes @a n characters from this string starting at @a pos. The
* length of the string is reduced by @a n. If there are < @a n
* characters to remove, the remainder of the string is truncated. If
* @a p is beyond end of string, out_of_range is thrown. The value of
* the string doesn't change if an error is thrown.
*/
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
{
_M_mutate(_M_check(__pos, "basic_string::erase"),
_M_limit(__pos, __n), size_type(0));
return *this;
}
#pragma empty_line
/**
* @brief Remove one character.
* @param position Iterator referencing the character to remove.
* @return iterator referencing same location after removal.
*
* Removes the character at @a position from this string. The value
* of the string doesn't change if an error is thrown.
*/
iterator
erase(iterator __position)
{
#pragma empty_line
;
const size_type __pos = __position - _M_ibegin();
_M_mutate(__pos, size_type(1), size_type(0));
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
#pragma empty_line
/**
* @brief Remove a range of characters.
* @param first Iterator referencing the first character to remove.
* @param last Iterator referencing the end of the range.
* @return Iterator referencing location of first after removal.
*
* Removes the characters in the range [first,last) from this string.
* The value of the string doesn't change if an error is thrown.
*/
iterator
erase(iterator __first, iterator __last);
#pragma empty_line
/**
* @brief Replace characters with value from another string.
* @param pos Index of first character to replace.
* @param n Number of characters to be replaced.
* @param str String to insert.
* @return Reference to this string.
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos+n) from this string.
* In place, the value of @a str is inserted. If @a pos is beyond end
* of string, out_of_range is thrown. If the length of the result
* exceeds max_size(), length_error is thrown. The value of the string
* doesn't change if an error is thrown.
*/
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
{ return this->replace(__pos, __n, __str._M_data(), __str.size()); }
#pragma empty_line
/**
* @brief Replace characters with value from another string.
* @param pos1 Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param str String to insert.
* @param pos2 Index of first character of str to use.
* @param n2 Number of characters from str to use.
* @return Reference to this string.
* @throw std::out_of_range If @a pos1 > size() or @a pos2 >
* str.size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos1,pos1 + n) from this
* string. In place, the value of @a str is inserted. If @a pos is
* beyond end of string, out_of_range is thrown. If the length of the
* result exceeds max_size(), length_error is thrown. The value of the
* string doesn't change if an error is thrown.
*/
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
{ return this->replace(__pos1, __n1, __str._M_data()
+ __str._M_check(__pos2, "basic_string::replace"),
__str._M_limit(__pos2, __n2)); }
#pragma empty_line
/**
* @brief Replace characters with value of a C substring.
* @param pos Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param s C string to insert.
* @param n2 Number of characters from @a s to use.
* @return Reference to this string.
* @throw std::out_of_range If @a pos1 > size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos + n1) from this string.
* In place, the first @a n2 characters of @a s are inserted, or all
* of @a s if @a n2 is too large. If @a pos is beyond end of string,
* out_of_range is thrown. If the length of result exceeds max_size(),
* length_error is thrown. The value of the string doesn't change if
* an error is thrown.
*/
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2);
#pragma empty_line
/**
* @brief Replace characters with value of a C string.
* @param pos Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param s C string to insert.
* @return Reference to this string.
* @throw std::out_of_range If @a pos > size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos + n1) from this string.
* In place, the characters of @a s are inserted. If @a pos is beyond
* end of string, out_of_range is thrown. If the length of result
* exceeds max_size(), length_error is thrown. The value of the string
* doesn't change if an error is thrown.
*/
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
{
;
return this->replace(__pos, __n1, __s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Replace characters with multiple characters.
* @param pos Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param n2 Number of characters to insert.
* @param c Character to insert.
* @return Reference to this string.
* @throw std::out_of_range If @a pos > size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos + n1) from this string.
* In place, @a n2 copies of @a c are inserted. If @a pos is beyond
* end of string, out_of_range is thrown. If the length of result
* exceeds max_size(), length_error is thrown. The value of the string
* doesn't change if an error is thrown.
*/
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
_M_limit(__pos, __n1), __n2, __c); }
#pragma empty_line
/**
* @brief Replace range of characters with string.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param str String value to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, the value of
* @a str is inserted. If the length of result exceeds max_size(),
* length_error is thrown. The value of the string doesn't change if
* an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, const basic_string& __str)
{ return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
#pragma empty_line
/**
* @brief Replace range of characters with C substring.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param s C string value to insert.
* @param n Number of characters from s to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, the first @a
* n characters of @a s are inserted. If the length of result exceeds
* max_size(), length_error is thrown. The value of the string doesn't
* change if an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
{
#pragma empty_line
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
}
#pragma empty_line
/**
* @brief Replace range of characters with C string.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param s C string value to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, the
* characters of @a s are inserted. If the length of result exceeds
* max_size(), length_error is thrown. The value of the string doesn't
* change if an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s)
{
;
return this->replace(__i1, __i2, __s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Replace range of characters with multiple characters
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param n Number of characters to insert.
* @param c Character to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, @a n copies
* of @a c are inserted. If the length of result exceeds max_size(),
* length_error is thrown. The value of the string doesn't change if
* an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
{
#pragma empty_line
;
return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
}
#pragma empty_line
/**
* @brief Replace range of characters with range.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param k1 Iterator referencing start of range to insert.
* @param k2 Iterator referencing end of range to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, characters
* in the range [k1,k2) are inserted. If the length of result exceeds
* max_size(), length_error is thrown. The value of the string doesn't
* change if an error is thrown.
*/
template<class _InputIterator>
basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2)
{
#pragma empty_line
;
;
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
}
#pragma empty_line
// Specializations for the common case of pointer and iterator:
// useful to avoid the overhead of temporary buffering in _M_replace.
basic_string&
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1, __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(iterator __i1, iterator __i2,
const _CharT* __k1, const _CharT* __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1, __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(iterator __i1, iterator __i2,
const_iterator __k1, const_iterator __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
#pragma line 1620 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.h" 3
private:
template<class _Integer>
basic_string&
_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
_Integer __val, __true_type)
{ return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
#pragma empty_line
template<class _InputIterator>
basic_string&
_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
_InputIterator __k2, __false_type);
#pragma empty_line
basic_string&
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c);
#pragma empty_line
basic_string&
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2);
#pragma empty_line
// _S_construct_aux is used to implement the 21.3.1 para 15 which
// requires special behaviour if _InIter is an integral type
template<class _InIterator>
static _CharT*
_S_construct_aux(_InIterator __beg, _InIterator __end,
const _Alloc& __a, __false_type)
{
typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
return _S_construct(__beg, __end, __a, _Tag());
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 438. Ambiguity in the "do the right thing" clause
template<class _Integer>
static _CharT*
_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc& __a, __true_type)
{ return _S_construct_aux_2(static_cast<size_type>(__beg),
__end, __a); }
#pragma empty_line
static _CharT*
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
{ return _S_construct(__req, __c, __a); }
#pragma empty_line
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
{
typedef typename std::__is_integer<_InIterator>::__type _Integral;
return _S_construct_aux(__beg, __end, __a, _Integral());
}
#pragma empty_line
// For Input Iterators, used in istreambuf_iterators, etc.
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag);
#pragma empty_line
// For forward_iterators up to random_access_iterators, used for
// string::iterator, _CharT*, etc.
template<class _FwdIterator>
static _CharT*
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
forward_iterator_tag);
#pragma empty_line
static _CharT*
_S_construct(size_type __req, _CharT __c, const _Alloc& __a);
#pragma empty_line
public:
#pragma empty_line
/**
* @brief Copy substring into C string.
* @param s C string to copy value into.
* @param n Number of characters to copy.
* @param pos Index of first character to copy.
* @return Number of characters actually copied
* @throw std::out_of_range If pos > size().
*
* Copies up to @a n characters starting at @a pos into the C string @a
* s. If @a pos is %greater than size(), out_of_range is thrown.
*/
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
#pragma empty_line
/**
* @brief Swap contents with another string.
* @param s String to swap with.
*
* Exchanges the contents of this string with that of @a s in constant
* time.
*/
void
swap(basic_string& __s);
#pragma empty_line
// String operations:
/**
* @brief Return const pointer to null-terminated contents.
*
* This is a handle to internal data. Do not modify or dire things may
* happen.
*/
const _CharT*
c_str() const
{ return _M_data(); }
#pragma empty_line
/**
* @brief Return const pointer to contents.
*
* This is a handle to internal data. Do not modify or dire things may
* happen.
*/
const _CharT*
data() const
{ return _M_data(); }
#pragma empty_line
/**
* @brief Return copy of allocator used to construct this string.
*/
allocator_type
get_allocator() const
{ return _M_dataplus; }
#pragma empty_line
/**
* @brief Find position of a C substring.
* @param s C string to locate.
* @param pos Index of character to search from.
* @param n Number of characters from @a s to search for.
* @return Index of start of first occurrence.
*
* Starting from @a pos, searches forward for the first @a n characters
* in @a s within this string. If found, returns the index where it
* begins. If not found, returns npos.
*/
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find position of a string.
* @param str String to locate.
* @param pos Index of character to search from (default 0).
* @return Index of start of first occurrence.
*
* Starting from @a pos, searches forward for value of @a str within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
find(const basic_string& __str, size_type __pos = 0) const
{ return this->find(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find position of a C string.
* @param s C string to locate.
* @param pos Index of character to search from (default 0).
* @return Index of start of first occurrence.
*
* Starting from @a pos, searches forward for the value of @a s within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
find(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find position of a character.
* @param c Character to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for @a c within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*/
size_type
find(_CharT __c, size_type __pos = 0) const;
#pragma empty_line
/**
* @brief Find last position of a string.
* @param str String to locate.
* @param pos Index of character to search back from (default end).
* @return Index of start of last occurrence.
*
* Starting from @a pos, searches backward for value of @a str within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
{ return this->rfind(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find last position of a C substring.
* @param s C string to locate.
* @param pos Index of character to search back from.
* @param n Number of characters from s to search for.
* @return Index of start of last occurrence.
*
* Starting from @a pos, searches backward for the first @a n
* characters in @a s within this string. If found, returns the index
* where it begins. If not found, returns npos.
*/
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find last position of a C string.
* @param s C string to locate.
* @param pos Index of character to start search at (default end).
* @return Index of start of last occurrence.
*
* Starting from @a pos, searches backward for the value of @a s within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
{
;
return this->rfind(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find last position of a character.
* @param c Character to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for @a c within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*/
size_type
rfind(_CharT __c, size_type __pos = npos) const;
#pragma empty_line
/**
* @brief Find position of a character of string.
* @param str String containing characters to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for one of the characters of
* @a str within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_first_of(const basic_string& __str, size_type __pos = 0) const
{ return this->find_first_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find position of a character of C substring.
* @param s String containing characters to locate.
* @param pos Index of character to search from.
* @param n Number of characters from s to search for.
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for one of the first @a n
* characters of @a s within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find position of a character of C string.
* @param s String containing characters to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for one of the characters of
* @a s within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find_first_of(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find position of a character.
* @param c Character to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for the character @a c within
* this string. If found, returns the index where it was found. If
* not found, returns npos.
*
* Note: equivalent to find(c, pos).
*/
size_type
find_first_of(_CharT __c, size_type __pos = 0) const
{ return this->find(__c, __pos); }
#pragma empty_line
/**
* @brief Find last position of a character of string.
* @param str String containing characters to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for one of the characters of
* @a str within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_last_of(const basic_string& __str, size_type __pos = npos) const
{ return this->find_last_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find last position of a character of C substring.
* @param s C string containing characters to locate.
* @param pos Index of character to search back from.
* @param n Number of characters from s to search for.
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for one of the first @a n
* characters of @a s within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find last position of a character of C string.
* @param s C string containing characters to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for one of the characters of
* @a s within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
{
;
return this->find_last_of(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find last position of a character.
* @param c Character to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for @a c within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*
* Note: equivalent to rfind(c, pos).
*/
size_type
find_last_of(_CharT __c, size_type __pos = npos) const
{ return this->rfind(__c, __pos); }
#pragma empty_line
/**
* @brief Find position of a character not in string.
* @param str String containing characters to avoid.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character not contained
* in @a str within this string. If found, returns the index where it
* was found. If not found, returns npos.
*/
size_type
find_first_not_of(const basic_string& __str, size_type __pos = 0) const
{ return this->find_first_not_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find position of a character not in C substring.
* @param s C string containing characters to avoid.
* @param pos Index of character to search from.
* @param n Number of characters from s to consider.
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character not contained
* in the first @a n characters of @a s within this string. If found,
* returns the index where it was found. If not found, returns npos.
*/
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
#pragma empty_line
/**
* @brief Find position of a character not in C string.
* @param s C string containing characters to avoid.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character not contained
* in @a s within this string. If found, returns the index where it
* was found. If not found, returns npos.
*/
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find_first_not_of(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find position of a different character.
* @param c Character to avoid.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character other than @a c
* within this string. If found, returns the index where it was found.
* If not found, returns npos.
*/
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const;
#pragma empty_line
/**
* @brief Find last position of a character not in string.
* @param str String containing characters to avoid.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character not
* contained in @a str within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
size_type
find_last_not_of(const basic_string& __str, size_type __pos = npos) const
{ return this->find_last_not_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find last position of a character not in C substring.
* @param s C string containing characters to avoid.
* @param pos Index of character to search back from.
* @param n Number of characters from s to consider.
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character not
* contained in the first @a n characters of @a s within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*/
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
/**
* @brief Find last position of a character not in C string.
* @param s C string containing characters to avoid.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character not
* contained in @a s within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
{
;
return this->find_last_not_of(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find last position of a different character.
* @param c Character to avoid.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character other than
* @a c within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const;
#pragma empty_line
/**
* @brief Get a substring.
* @param pos Index of first character (default 0).
* @param n Number of characters in substring (default remainder).
* @return The new string.
* @throw std::out_of_range If pos > size().
*
* Construct and return a new string using the @a n characters starting
* at @a pos. If the string is too short, use the remainder of the
* characters. If @a pos is beyond the end of the string, out_of_range
* is thrown.
*/
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
{ return basic_string(*this,
_M_check(__pos, "basic_string::substr"), __n); }
#pragma empty_line
/**
* @brief Compare to a string.
* @param str String to compare against.
* @return Integer < 0, 0, or > 0.
*
* Returns an integer < 0 if this string is ordered before @a str, 0 if
* their values are equivalent, or > 0 if this string is ordered after
* @a str. Determines the effective length rlen of the strings to
* compare as the smallest of size() and str.size(). The function
* then compares the two strings by calling traits::compare(data(),
* str.data(),rlen). If the result of the comparison is nonzero returns
* it, otherwise the shorter one is ordered first.
*/
int
compare(const basic_string& __str) const
{
const size_type __size = this->size();
const size_type __osize = __str.size();
const size_type __len = std::min(__size, __osize);
#pragma empty_line
int __r = traits_type::compare(_M_data(), __str.data(), __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
#pragma empty_line
/**
* @brief Compare substring to a string.
* @param pos Index of first character of substring.
* @param n Number of characters in substring.
* @param str String to compare against.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n characters starting
* at @a pos. Returns an integer < 0 if the substring is ordered
* before @a str, 0 if their values are equivalent, or > 0 if the
* substring is ordered after @a str. Determines the effective length
* rlen of the strings to compare as the smallest of the length of the
* substring and @a str.size(). The function then compares the two
* strings by calling traits::compare(substring.data(),str.data(),rlen).
* If the result of the comparison is nonzero returns it, otherwise the
* shorter one is ordered first.
*/
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
#pragma empty_line
/**
* @brief Compare substring to a substring.
* @param pos1 Index of first character of substring.
* @param n1 Number of characters in substring.
* @param str String to compare against.
* @param pos2 Index of first character of substring of str.
* @param n2 Number of characters in substring of str.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n1 characters starting
* at @a pos1. Form the substring of @a str from the @a n2 characters
* starting at @a pos2. Returns an integer < 0 if this substring is
* ordered before the substring of @a str, 0 if their values are
* equivalent, or > 0 if this substring is ordered after the substring
* of @a str. Determines the effective length rlen of the strings
* to compare as the smallest of the lengths of the substrings. The
* function then compares the two strings by calling
* traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
* If the result of the comparison is nonzero returns it, otherwise the
* shorter one is ordered first.
*/
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
#pragma empty_line
/**
* @brief Compare to a C string.
* @param s C string to compare against.
* @return Integer < 0, 0, or > 0.
*
* Returns an integer < 0 if this string is ordered before @a s, 0 if
* their values are equivalent, or > 0 if this string is ordered after
* @a s. Determines the effective length rlen of the strings to
* compare as the smallest of size() and the length of a string
* constructed from @a s. The function then compares the two strings
* by calling traits::compare(data(),s,rlen). If the result of the
* comparison is nonzero returns it, otherwise the shorter one is
* ordered first.
*/
int
compare(const _CharT* __s) const;
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 5 String::compare specification questionable
/**
* @brief Compare substring to a C string.
* @param pos Index of first character of substring.
* @param n1 Number of characters in substring.
* @param s C string to compare against.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n1 characters starting
* at @a pos. Returns an integer < 0 if the substring is ordered
* before @a s, 0 if their values are equivalent, or > 0 if the
* substring is ordered after @a s. Determines the effective length
* rlen of the strings to compare as the smallest of the length of the
* substring and the length of a string constructed from @a s. The
* function then compares the two string by calling
* traits::compare(substring.data(),s,rlen). If the result of the
* comparison is nonzero returns it, otherwise the shorter one is
* ordered first.
*/
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
#pragma empty_line
/**
* @brief Compare substring against a character %array.
* @param pos1 Index of first character of substring.
* @param n1 Number of characters in substring.
* @param s character %array to compare against.
* @param n2 Number of characters of s.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n1 characters starting
* at @a pos1. Form a string from the first @a n2 characters of @a s.
* Returns an integer < 0 if this substring is ordered before the string
* from @a s, 0 if their values are equivalent, or > 0 if this substring
* is ordered after the string from @a s. Determines the effective
* length rlen of the strings to compare as the smallest of the length
* of the substring and @a n2. The function then compares the two
* strings by calling traits::compare(substring.data(),s,rlen). If the
* result of the comparison is nonzero returns it, otherwise the shorter
* one is ordered first.
*
* NB: s must have at least n2 characters, '\\0' has
* no special meaning.
*/
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
#pragma empty_line
// operator+
/**
* @brief Concatenate two strings.
* @param lhs First string.
* @param rhs Last string.
* @return New string with value of @a lhs followed by @a rhs.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
#pragma empty_line
/**
* @brief Concatenate C string and string.
* @param lhs First string.
* @param rhs Last string.
* @return New string with value of @a lhs followed by @a rhs.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT,_Traits,_Alloc>& __rhs);
#pragma empty_line
/**
* @brief Concatenate character and string.
* @param lhs First string.
* @param rhs Last string.
* @return New string with @a lhs followed by @a rhs.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
#pragma empty_line
/**
* @brief Concatenate string and C string.
* @param lhs First string.
* @param rhs Last string.
* @return New string with @a lhs followed by @a rhs.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
#pragma empty_line
/**
* @brief Concatenate string and character.
* @param lhs First string.
* @param rhs Last string.
* @return New string with @a lhs followed by @a rhs.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str(__lhs);
__str.append(__size_type(1), __rhs);
return __str;
}
#pragma empty_line
// operator ==
/**
* @brief Test equivalence of two strings.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs.compare(@a rhs) == 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) == 0; }
#pragma empty_line
template<typename _CharT>
inline
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs)
{ return (__lhs.size() == __rhs.size()
&& !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
__lhs.size())); }
#pragma empty_line
/**
* @brief Test equivalence of C string and string.
* @param lhs C string.
* @param rhs String.
* @return True if @a rhs.compare(@a lhs) == 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) == 0; }
#pragma empty_line
/**
* @brief Test equivalence of string and C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs.compare(@a rhs) == 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) == 0; }
#pragma empty_line
// operator !=
/**
* @brief Test difference of two strings.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs.compare(@a rhs) != 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return !(__lhs == __rhs); }
#pragma empty_line
/**
* @brief Test difference of C string and string.
* @param lhs C string.
* @param rhs String.
* @return True if @a rhs.compare(@a lhs) != 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return !(__lhs == __rhs); }
#pragma empty_line
/**
* @brief Test difference of string and C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs.compare(@a rhs) != 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return !(__lhs == __rhs); }
#pragma empty_line
// operator <
/**
* @brief Test if string precedes string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs precedes @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) < 0; }
#pragma empty_line
/**
* @brief Test if string precedes C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs precedes @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) < 0; }
#pragma empty_line
/**
* @brief Test if C string precedes string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs precedes @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) > 0; }
#pragma empty_line
// operator >
/**
* @brief Test if string follows string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs follows @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) > 0; }
#pragma empty_line
/**
* @brief Test if string follows C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs follows @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) > 0; }
#pragma empty_line
/**
* @brief Test if C string follows string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs follows @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) < 0; }
#pragma empty_line
// operator <=
/**
* @brief Test if string doesn't follow string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs doesn't follow @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) <= 0; }
#pragma empty_line
/**
* @brief Test if string doesn't follow C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs doesn't follow @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) <= 0; }
#pragma empty_line
/**
* @brief Test if C string doesn't follow string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs doesn't follow @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) >= 0; }
#pragma empty_line
// operator >=
/**
* @brief Test if string doesn't precede string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs doesn't precede @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) >= 0; }
#pragma empty_line
/**
* @brief Test if string doesn't precede C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs doesn't precede @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) >= 0; }
#pragma empty_line
/**
* @brief Test if C string doesn't precede string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs doesn't precede @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) <= 0; }
#pragma empty_line
/**
* @brief Swap contents of two strings.
* @param lhs First string.
* @param rhs Second string.
*
* Exchanges the contents of @a lhs and @a rhs in constant time.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ __lhs.swap(__rhs); }
#pragma empty_line
/**
* @brief Read stream into a string.
* @param is Input stream.
* @param str Buffer to store into.
* @return Reference to the input stream.
*
* Stores characters from @a is into @a str until whitespace is found, the
* end of the stream is encountered, or str.max_size() is reached. If
* is.width() is non-zero, that is the limit on the number of characters
* stored into @a str. Any previous contents of @a str are erased.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str);
#pragma empty_line
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __is, basic_string<char>& __str);
#pragma empty_line
/**
* @brief Write string to a stream.
* @param os Output stream.
* @param str String to write out.
* @return Reference to the output stream.
*
* Output characters of @a str into os following the same rules as for
* writing a C string.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 586. string inserter not a formatted function
return __ostream_insert(__os, __str.data(), __str.size());
}
#pragma empty_line
/**
* @brief Read a line from stream into a string.
* @param is Input stream.
* @param str Buffer to store into.
* @param delim Character marking end of line.
* @return Reference to the input stream.
*
* Stores characters from @a is into @a str until @a delim is found, the
* end of the stream is encountered, or str.max_size() is reached. If
* is.width() is non-zero, that is the limit on the number of characters
* stored into @a str. Any previous contents of @a str are erased. If @a
* delim was encountered, it is extracted but not stored into @a str.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
#pragma empty_line
/**
* @brief Read a line from stream into a string.
* @param is Input stream.
* @param str Buffer to store into.
* @return Reference to the input stream.
*
* Stores characters from is into @a str until '\n' is
* found, the end of the stream is encountered, or str.max_size()
* is reached. If is.width() is non-zero, that is the limit on the
* number of characters stored into @a str. Any previous contents
* of @a str are erased. If end of line was encountered, it is
* extracted but not stored into @a str.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
{ return getline(__is, __str, __is.widen('\n')); }
#pragma empty_line
template<>
basic_istream<char>&
getline(basic_istream<char>& __in, basic_string<char>& __str,
char __delim);
#pragma empty_line
#pragma empty_line
template<>
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
wchar_t __delim);
#pragma empty_line
#pragma empty_line
}
#pragma line 53 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\string" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.tcc" 1 3
// Components for manipulating sequences of characters -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file basic_string.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
// Written by Jason Merrill based upon the specification by Takanori Adachi
// in ANSI X3J16/94-0013R2. Rewritten by Nathan Myers to ISO-14882.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.tcc" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
const _CharT
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_terminal = _CharT();
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::npos;
#pragma empty_line
// Linker sets _S_empty_rep_storage to all 0s (one reference, empty string)
// at static init time (before static ctors are run).
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
sizeof(size_type)];
#pragma empty_line
// NB: This is the special case for Input Iterators, used in
// istreambuf_iterators, etc.
// Input Iterators have a cost structure very different from
// pointers, calling for a different coding style.
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InIterator>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Avoid reallocation for common case.
_CharT __buf[128];
size_type __len = 0;
while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
{
__buf[__len++] = *__beg;
++__beg;
}
_Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
_M_copy(__r->_M_refdata(), __buf, __len);
if (true)
{
while (__beg != __end)
{
if (__len == __r->_M_capacity)
{
// Allocate more space.
_Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
_M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
__r->_M_destroy(__a);
__r = __another;
}
__r->_M_refdata()[__len++] = *__beg;
++__beg;
}
}
if (false)
{
__r->_M_destroy(__a);
;
}
__r->_M_set_length_and_sharable(__len);
return __r->_M_refdata();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
template <typename _InIterator>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
forward_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// NB: Not required, but considered best practice.
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
__throw_logic_error(("basic_string::_S_construct NULL not valid"));
#pragma empty_line
const size_type __dnew = static_cast<size_type>(std::distance(__beg,
__end));
// Check for out_of_range and length_error exceptions.
_Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
if (true)
{ _S_copy_chars(__r->_M_refdata(), __beg, __end); }
if (false)
{
__r->_M_destroy(__a);
;
}
__r->_M_set_length_and_sharable(__dnew);
return __r->_M_refdata();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::
_S_construct(size_type __n, _CharT __c, const _Alloc& __a)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Check for out_of_range and length_error exceptions.
_Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
if (__n)
_M_assign(__r->_M_refdata(), __n, __c);
#pragma empty_line
__r->_M_set_length_and_sharable(__n);
return __r->_M_refdata();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const basic_string& __str)
: _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
__str.get_allocator()),
__str.get_allocator())
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const _Alloc& __a)
: _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const basic_string& __str, size_type __pos, size_type __n)
: _M_dataplus(_S_construct(__str._M_data()
+ __str._M_check(__pos,
"basic_string::basic_string"),
__str._M_data() + __str._M_limit(__pos, __n)
+ __pos, _Alloc()), _Alloc())
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a)
: _M_dataplus(_S_construct(__str._M_data()
+ __str._M_check(__pos,
"basic_string::basic_string"),
__str._M_data() + __str._M_limit(__pos, __n)
+ __pos, __a), __a)
{ }
#pragma empty_line
// TBD: DPG annotate
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
: _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
{ }
#pragma empty_line
// TBD: DPG annotate
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const _CharT* __s, const _Alloc& __a)
: _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
__s + npos, __a), __a)
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(size_type __n, _CharT __c, const _Alloc& __a)
: _M_dataplus(_S_construct(__n, __c, __a), __a)
{ }
#pragma empty_line
// TBD: DPG annotate
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InputIterator>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
: _M_dataplus(_S_construct(__beg, __end, __a), __a)
{ }
#pragma line 239 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_string.tcc" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
assign(const basic_string& __str)
{
if (_M_rep() != __str._M_rep())
{
// XXX MT
const allocator_type __a = this->get_allocator();
_CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
_M_rep()->_M_dispose(__a);
_M_data(__tmp);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
assign(const _CharT* __s, size_type __n)
{
;
_M_check_length(this->size(), __n, "basic_string::assign");
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(size_type(0), this->size(), __s, __n);
else
{
// Work in-place.
const size_type __pos = __s - _M_data();
if (__pos >= __n)
_M_copy(_M_data(), __s, __n);
else if (__pos)
_M_move(_M_data(), __s, __n);
_M_rep()->_M_set_length_and_sharable(__n);
return *this;
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(size_type __n, _CharT __c)
{
if (__n)
{
_M_check_length(size_type(0), __n, "basic_string::append");
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_assign(_M_data() + this->size(), __n, __c);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(const _CharT* __s, size_type __n)
{
;
if (__n)
{
_M_check_length(size_type(0), __n, "basic_string::append");
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
{
if (_M_disjunct(__s))
this->reserve(__len);
else
{
const size_type __off = __s - _M_data();
this->reserve(__len);
__s = _M_data() + __off;
}
}
_M_copy(_M_data() + this->size(), __s, __n);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(const basic_string& __str)
{
const size_type __size = __str.size();
if (__size)
{
const size_type __len = __size + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_copy(_M_data() + this->size(), __str._M_data(), __size);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(const basic_string& __str, size_type __pos, size_type __n)
{
__str._M_check(__pos, "basic_string::append");
__n = __str._M_limit(__pos, __n);
if (__n)
{
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
insert(size_type __pos, const _CharT* __s, size_type __n)
{
;
_M_check(__pos, "basic_string::insert");
_M_check_length(size_type(0), __n, "basic_string::insert");
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(__pos, size_type(0), __s, __n);
else
{
// Work in-place.
const size_type __off = __s - _M_data();
_M_mutate(__pos, 0, __n);
__s = _M_data() + __off;
_CharT* __p = _M_data() + __pos;
if (__s + __n <= __p)
_M_copy(__p, __s, __n);
else if (__s >= __p)
_M_copy(__p, __s + __n, __n);
else
{
const size_type __nleft = __p - __s;
_M_copy(__p, __s, __nleft);
_M_copy(__p + __nleft, __p + __n, __n - __nleft);
}
return *this;
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::iterator
basic_string<_CharT, _Traits, _Alloc>::
erase(iterator __first, iterator __last)
{
#pragma empty_line
;
#pragma empty_line
// NB: This isn't just an optimization (bail out early when
// there is nothing to do, really), it's also a correctness
// issue vs MT, see libstdc++/40518.
const size_type __size = __last - __first;
if (__size)
{
const size_type __pos = __first - _M_ibegin();
_M_mutate(__pos, __size, size_type(0));
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
else
return __first;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2)
{
;
_M_check(__pos, "basic_string::replace");
__n1 = _M_limit(__pos, __n1);
_M_check_length(__n1, __n2, "basic_string::replace");
bool __left;
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(__pos, __n1, __s, __n2);
else if ((__left = __s + __n2 <= _M_data() + __pos)
|| _M_data() + __pos + __n1 <= __s)
{
// Work in-place: non-overlapping case.
size_type __off = __s - _M_data();
__left ? __off : (__off += __n2 - __n1);
_M_mutate(__pos, __n1, __n2);
_M_copy(_M_data() + __pos, _M_data() + __off, __n2);
return *this;
}
else
{
// Todo: overlapping case.
const basic_string __tmp(__s, __n2);
return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::_Rep::
_M_destroy(const _Alloc& __a) throw ()
{
const size_type __size = sizeof(_Rep_base) +
(this->_M_capacity + 1) * sizeof(_CharT);
_Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_leak_hard()
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (_M_rep()->_M_is_shared())
_M_mutate(0, 0, 0);
_M_rep()->_M_set_leaked();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_mutate(size_type __pos, size_type __len1, size_type __len2)
{
const size_type __old_size = this->size();
const size_type __new_size = __old_size + __len2 - __len1;
const size_type __how_much = __old_size - __pos - __len1;
#pragma empty_line
if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
{
// Must reallocate.
const allocator_type __a = get_allocator();
_Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
#pragma empty_line
if (__pos)
_M_copy(__r->_M_refdata(), _M_data(), __pos);
if (__how_much)
_M_copy(__r->_M_refdata() + __pos + __len2,
_M_data() + __pos + __len1, __how_much);
#pragma empty_line
_M_rep()->_M_dispose(__a);
_M_data(__r->_M_refdata());
}
else if (__how_much && __len1 != __len2)
{
// Work in-place.
_M_move(_M_data() + __pos + __len2,
_M_data() + __pos + __len1, __how_much);
}
_M_rep()->_M_set_length_and_sharable(__new_size);
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
reserve(size_type __res)
{
if (__res != this->capacity() || _M_rep()->_M_is_shared())
{
// Make sure we don't shrink below the current size
if (__res < this->size())
__res = this->size();
const allocator_type __a = get_allocator();
_CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
_M_rep()->_M_dispose(__a);
_M_data(__tmp);
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
swap(basic_string& __s)
{
if (_M_rep()->_M_is_leaked())
_M_rep()->_M_set_sharable();
if (__s._M_rep()->_M_is_leaked())
__s._M_rep()->_M_set_sharable();
if (this->get_allocator() == __s.get_allocator())
{
_CharT* __tmp = _M_data();
_M_data(__s._M_data());
__s._M_data(__tmp);
}
// The code below can usually be optimized away.
else
{
const basic_string __tmp1(_M_ibegin(), _M_iend(),
__s.get_allocator());
const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
this->get_allocator());
*this = __tmp2;
__s = __tmp1;
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
basic_string<_CharT, _Traits, _Alloc>::_Rep::
_S_create(size_type __capacity, size_type __old_capacity,
const _Alloc& __alloc)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 83. String::npos vs. string::max_size()
if (__capacity > _S_max_size)
__throw_length_error(("basic_string::_S_create"));
#pragma empty_line
// The standard places no restriction on allocating more memory
// than is strictly needed within this layer at the moment or as
// requested by an explicit application call to reserve().
#pragma empty_line
// Many malloc implementations perform quite poorly when an
// application attempts to allocate memory in a stepwise fashion
// growing each allocation size by only 1 char. Additionally,
// it makes little sense to allocate less linear memory than the
// natural blocking size of the malloc implementation.
// Unfortunately, we would need a somewhat low-level calculation
// with tuned parameters to get this perfect for any particular
// malloc implementation. Fortunately, generalizations about
// common features seen among implementations seems to suffice.
#pragma empty_line
// __pagesize need not match the actual VM page size for good
// results in practice, thus we pick a common value on the low
// side. __malloc_header_size is an estimate of the amount of
// overhead per memory allocation (in practice seen N * sizeof
// (void*) where N is 0, 2 or 4). According to folklore,
// picking this value on the high side is better than
// low-balling it (especially when this algorithm is used with
// malloc implementations that allocate memory blocks rounded up
// to a size which is a power of 2).
const size_type __pagesize = 4096;
const size_type __malloc_header_size = 4 * sizeof(void*);
#pragma empty_line
// The below implements an exponential growth policy, necessary to
// meet amortized linear time requirements of the library: see
// http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
// It's active for allocations requiring an amount of memory above
// system pagesize. This is consistent with the requirements of the
// standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
__capacity = 2 * __old_capacity;
#pragma empty_line
// NB: Need an array of char_type[__capacity], plus a terminating
// null char_type() element, plus enough for the _Rep data structure.
// Whew. Seemingly so needy, yet so elemental.
size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
#pragma empty_line
const size_type __adj_size = __size + __malloc_header_size;
if (__adj_size > __pagesize && __capacity > __old_capacity)
{
const size_type __extra = __pagesize - __adj_size % __pagesize;
__capacity += __extra / sizeof(_CharT);
// Never allocate a string bigger than _S_max_size.
if (__capacity > _S_max_size)
__capacity = _S_max_size;
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
}
#pragma empty_line
// NB: Might throw, but no worries about a leak, mate: _Rep()
// does not throw.
void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
_Rep *__p = new (__place) _Rep;
__p->_M_capacity = __capacity;
// ABI compatibility - 3.4.x set in _S_create both
// _M_refcount and _M_length. All callers of _S_create
// in basic_string.tcc then set just _M_length.
// In 4.0.x and later both _M_refcount and _M_length
// are initialized in the callers, unfortunately we can
// have 3.4.x compiled code with _S_create callers inlined
// calling 4.0.x+ _S_create.
__p->_M_set_sharable();
return __p;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::_Rep::
_M_clone(const _Alloc& __alloc, size_type __res)
{
// Requested capacity of the clone.
const size_type __requested_cap = this->_M_length + __res;
_Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
__alloc);
if (this->_M_length)
_M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
#pragma empty_line
__r->_M_set_length_and_sharable(this->_M_length);
return __r->_M_refdata();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
resize(size_type __n, _CharT __c)
{
const size_type __size = this->size();
_M_check_length(__size, __n, "basic_string::resize");
if (__size < __n)
this->append(__n - __size, __c);
else if (__n < __size)
this->erase(__n);
// else nothing (in particular, avoid calling _M_mutate() unnecessarily.)
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InputIterator>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
_InputIterator __k2, __false_type)
{
const basic_string __s(__k1, __k2);
const size_type __n1 = __i2 - __i1;
_M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
__s.size());
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c)
{
_M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
_M_mutate(__pos1, __n1, __n2);
if (__n2)
_M_assign(_M_data() + __pos1, __n2, __c);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2)
{
_M_mutate(__pos1, __n1, __n2);
if (__n2)
_M_copy(_M_data() + __pos1, __s, __n2);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
const __size_type __len = _Traits::length(__lhs);
__string_type __str;
__str.reserve(__len + __rhs.size());
__str.append(__lhs, __len);
__str.append(__rhs);
return __str;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str;
const __size_type __len = __rhs.size();
__str.reserve(__len + 1);
__str.append(__size_type(1), __lhs);
__str.append(__rhs);
return __str;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
copy(_CharT* __s, size_type __n, size_type __pos) const
{
_M_check(__pos, "basic_string::copy");
__n = _M_limit(__pos, __n);
;
if (__n)
_M_copy(__s, _M_data() + __pos, __n);
// 21.3.5.7 par 3: do not append null. (good.)
return __n;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(const _CharT* __s, size_type __pos, size_type __n) const
{
;
const size_type __size = this->size();
const _CharT* __data = _M_data();
#pragma empty_line
if (__n == 0)
return __pos <= __size ? __pos : npos;
#pragma empty_line
if (__n <= __size)
{
for (; __pos <= __size - __n; ++__pos)
if (traits_type::eq(__data[__pos], __s[0])
&& traits_type::compare(__data + __pos + 1,
__s + 1, __n - 1) == 0)
return __pos;
}
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(_CharT __c, size_type __pos) const
{
size_type __ret = npos;
const size_type __size = this->size();
if (__pos < __size)
{
const _CharT* __data = _M_data();
const size_type __n = __size - __pos;
const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
if (__p)
__ret = __p - __data;
}
return __ret;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(const _CharT* __s, size_type __pos, size_type __n) const
{
;
const size_type __size = this->size();
if (__n <= __size)
{
__pos = std::min(size_type(__size - __n), __pos);
const _CharT* __data = _M_data();
do
{
if (traits_type::compare(__data + __pos, __s, __n) == 0)
return __pos;
}
while (__pos-- > 0);
}
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(_CharT __c, size_type __pos) const
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
for (++__size; __size-- > 0; )
if (traits_type::eq(_M_data()[__size], __c))
return __size;
}
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
for (; __n && __pos < this->size(); ++__pos)
{
const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
if (__p)
return __pos;
}
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
size_type __size = this->size();
if (__size && __n)
{
if (--__size > __pos)
__size = __pos;
do
{
if (traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size-- != 0);
}
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
for (; __pos < this->size(); ++__pos)
if (!traits_type::find(__s, __n, _M_data()[__pos]))
return __pos;
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(_CharT __c, size_type __pos) const
{
for (; __pos < this->size(); ++__pos)
if (!traits_type::eq(_M_data()[__pos], __c))
return __pos;
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size--);
}
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(_CharT __c, size_type __pos) const
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::eq(_M_data()[__size], __c))
return __size;
}
while (__size--);
}
return npos;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n, const basic_string& __str) const
{
_M_check(__pos, "basic_string::compare");
__n = _M_limit(__pos, __n);
const size_type __osize = __str.size();
const size_type __len = std::min(__n, __osize);
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
if (!__r)
__r = _S_compare(__n, __osize);
return __r;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const
{
_M_check(__pos1, "basic_string::compare");
__str._M_check(__pos2, "basic_string::compare");
__n1 = _M_limit(__pos1, __n1);
__n2 = __str._M_limit(__pos2, __n2);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos1,
__str.data() + __pos2, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(const _CharT* __s) const
{
;
const size_type __size = this->size();
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __s, __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string <_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n1, const _CharT* __s) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__n1, __osize);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __osize);
return __r;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string <_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
#pragma empty_line
// 21.3.7.9 basic_string::getline and operators
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
typedef ctype<_CharT> __ctype_type;
typedef typename __ctype_type::ctype_base __ctype_base;
#pragma empty_line
__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
if (true)
{
// Avoid reallocation for common case.
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
const streamsize __w = __in.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();
#pragma empty_line
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(__ctype_base::space,
_Traits::to_char_type(__c)))
{
if (__len == sizeof(__buf) / sizeof(_CharT))
{
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
__str.append(__buf, __len);
#pragma empty_line
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
__in.width(0);
}
if (false)
{
__in._M_setstate(__ios_base::badbit);
;
}
if (false)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
__in._M_setstate(__ios_base::badbit);
}
}
// 211. operator>>(istream&, string&) doesn't set failbit
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
#pragma empty_line
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, true);
if (__cerb)
{
if (true)
{
__str.erase();
const __int_type __idelim = _Traits::to_int_type(__delim);
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();
#pragma empty_line
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
&& !_Traits::eq_int_type(__c, __idelim))
{
__str += _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
#pragma empty_line
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
else if (_Traits::eq_int_type(__c, __idelim))
{
++__extracted;
__in.rdbuf()->sbumpc();
}
else
__err |= __ios_base::failbit;
}
if (false)
{
__in._M_setstate(__ios_base::badbit);
;
}
if (false)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class basic_string<char>;
extern template
basic_istream<char>&
operator>>(basic_istream<char>&, string&);
extern template
basic_ostream<char>&
operator<<(basic_ostream<char>&, const string&);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&, char);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&);
#pragma empty_line
#pragma empty_line
extern template class basic_string<wchar_t>;
extern template
basic_istream<wchar_t>&
operator>>(basic_istream<wchar_t>&, wstring&);
extern template
basic_ostream<wchar_t>&
operator<<(basic_ostream<wchar_t>&, const wstring&);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&, wchar_t);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 56 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\string" 2 3
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_classes.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
// 22.1.1 Class locale
/**
* @brief Container class for localization functionality.
* @ingroup locales
*
* The locale class is first a class wrapper for C library locales. It is
* also an extensible container for user-defined localization. A locale is
* a collection of facets that implement various localization features such
* as money, time, and number printing.
*
* Constructing C++ locales does not change the C library locale.
*
* This library supports efficient construction and copying of locales
* through a reference counting implementation of the locale class.
*/
class locale
{
public:
// Types:
/// Definition of locale::category.
typedef int category;
#pragma empty_line
// Forward decls and friends:
class facet;
class id;
class _Impl;
#pragma empty_line
friend class facet;
friend class _Impl;
#pragma empty_line
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
#pragma empty_line
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
#pragma empty_line
template<typename _Cache>
friend struct __use_cache;
#pragma empty_line
//@{
/**
* @brief Category values.
*
* The standard category values are none, ctype, numeric, collate, time,
* monetary, and messages. They form a bitmask that supports union and
* intersection. The category all is the union of these values.
*
* NB: Order must match _S_facet_categories definition in locale.cc
*/
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
time | monetary | messages);
//@}
#pragma empty_line
// Construct/copy/destroy:
#pragma empty_line
/**
* @brief Default constructor.
*
* Constructs a copy of the global locale. If no locale has been
* explicitly set, this is the C locale.
*/
locale() throw();
#pragma empty_line
/**
* @brief Copy constructor.
*
* Constructs a copy of @a other.
*
* @param other The locale to copy.
*/
locale(const locale& __other) throw();
#pragma empty_line
/**
* @brief Named locale constructor.
*
* Constructs a copy of the named C library locale.
*
* @param s Name of the locale to construct.
* @throw std::runtime_error if s is null or an undefined locale.
*/
explicit
locale(const char* __s);
#pragma empty_line
/**
* @brief Construct locale with facets from another locale.
*
* Constructs a copy of the locale @a base. The facets specified by @a
* cat are replaced with those from the locale named by @a s. If base is
* named, this locale instance will also be named.
*
* @param base The locale to copy.
* @param s Name of the locale to use facets from.
* @param cat Set of categories defining the facets to use from s.
* @throw std::runtime_error if s is null or an undefined locale.
*/
locale(const locale& __base, const char* __s, category __cat);
#pragma empty_line
/**
* @brief Construct locale with facets from another locale.
*
* Constructs a copy of the locale @a base. The facets specified by @a
* cat are replaced with those from the locale @a add. If @a base and @a
* add are named, this locale instance will also be named.
*
* @param base The locale to copy.
* @param add The locale to use facets from.
* @param cat Set of categories defining the facets to use from add.
*/
locale(const locale& __base, const locale& __add, category __cat);
#pragma empty_line
/**
* @brief Construct locale with another facet.
*
* Constructs a copy of the locale @a other. The facet @f is added to
* @other, replacing an existing facet of type Facet if there is one. If
* @f is null, this locale is a copy of @a other.
*
* @param other The locale to copy.
* @param f The facet to add in.
*/
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
#pragma empty_line
/// Locale destructor.
~locale() throw();
#pragma empty_line
/**
* @brief Assignment operator.
*
* Set this locale to be a copy of @a other.
*
* @param other The locale to copy.
* @return A reference to this locale.
*/
const locale&
operator=(const locale& __other) throw();
#pragma empty_line
/**
* @brief Construct locale with another facet.
*
* Constructs and returns a new copy of this locale. Adds or replaces an
* existing facet of type Facet from the locale @a other into the new
* locale.
*
* @param Facet The facet type to copy from other
* @param other The locale to copy from.
* @return Newly constructed locale.
* @throw std::runtime_error if other has no facet of type Facet.
*/
template<typename _Facet>
locale
combine(const locale& __other) const;
#pragma empty_line
// Locale operations:
/**
* @brief Return locale name.
* @return Locale name or "*" if unnamed.
*/
string
name() const;
#pragma empty_line
/**
* @brief Locale equality.
*
* @param other The locale to compare against.
* @return True if other and this refer to the same locale instance, are
* copies, or have the same name. False otherwise.
*/
bool
operator==(const locale& __other) const throw();
#pragma empty_line
/**
* @brief Locale inequality.
*
* @param other The locale to compare against.
* @return ! (*this == other)
*/
bool
operator!=(const locale& __other) const throw()
{ return !(this->operator==(__other)); }
#pragma empty_line
/**
* @brief Compare two strings according to collate.
*
* Template operator to compare two strings using the compare function of
* the collate facet in this locale. One use is to provide the locale to
* the sort function. For example, a vector v of strings could be sorted
* according to locale loc by doing:
* @code
* std::sort(v.begin(), v.end(), loc);
* @endcode
*
* @param s1 First string to compare.
* @param s2 Second string to compare.
* @return True if collate<Char> facet compares s1 < s2, else false.
*/
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
#pragma empty_line
// Global locale objects:
/**
* @brief Set global locale
*
* This function sets the global locale to the argument and returns a
* copy of the previous global locale. If the argument has a name, it
* will also call std::setlocale(LC_ALL, loc.name()).
*
* @param locale The new locale to make global.
* @return Copy of the old global locale.
*/
static locale
global(const locale&);
#pragma empty_line
/**
* @brief Return reference to the C locale.
*/
static const locale&
classic();
#pragma empty_line
private:
// The (shared) implementation
_Impl* _M_impl;
#pragma empty_line
// The "C" reference locale
static _Impl* _S_classic;
#pragma empty_line
// Current global locale
static _Impl* _S_global;
#pragma empty_line
// Names of underlying locale categories.
// NB: locale::global() has to know how to modify all the
// underlying categories, not just the ones required by the C++
// standard.
static const char* const* const _S_categories;
#pragma empty_line
// Number of standard categories. For C++, these categories are
// collate, ctype, monetary, numeric, time, and messages. These
// directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
// LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
// 1003.1-2001) specifies LC_MESSAGES.
// In addition to the standard categories, the underlying
// operating system is allowed to define extra LC_*
// macros. For GNU systems, the following are also valid:
// LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
// and LC_IDENTIFICATION.
enum { _S_categories_size = 6 + 0 };
#pragma empty_line
#pragma empty_line
static __gthread_once_t _S_once;
#pragma empty_line
#pragma empty_line
explicit
locale(_Impl*) throw();
#pragma empty_line
static void
_S_initialize();
#pragma empty_line
static void
_S_initialize_once() throw();
#pragma empty_line
static category
_S_normalize_category(category);
#pragma empty_line
void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
};
#pragma empty_line
#pragma empty_line
// 22.1.1.1.2 Class locale::facet
/**
* @brief Localization functionality base class.
* @ingroup locales
*
* The facet class is the base class for a localization feature, such as
* money, time, and number printing. It provides common support for facets
* and reference management.
*
* Facets may not be copied or assigned.
*/
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;
#pragma empty_line
mutable _Atomic_word _M_refcount;
#pragma empty_line
// Contains data from the underlying "C" library for the classic locale.
static __c_locale _S_c_locale;
#pragma empty_line
// String literal for the name of the classic locale.
static const char _S_c_name[2];
#pragma empty_line
#pragma empty_line
static __gthread_once_t _S_once;
#pragma empty_line
#pragma empty_line
static void
_S_initialize_once();
#pragma empty_line
protected:
/**
* @brief Facet constructor.
*
* This is the constructor provided by the standard. If refs is 0, the
* facet is destroyed when the last referencing locale is destroyed.
* Otherwise the facet will never be destroyed.
*
* @param refs The initial value for reference count.
*/
explicit
facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
{ }
#pragma empty_line
/// Facet destructor.
virtual
~facet();
#pragma empty_line
static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);
#pragma empty_line
static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();
#pragma empty_line
static void
_S_destroy_c_locale(__c_locale& __cloc);
#pragma empty_line
static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
#pragma empty_line
// Returns data from the underlying "C" library data for the
// classic locale.
static __c_locale
_S_get_c_locale();
#pragma empty_line
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
#pragma empty_line
private:
void
_M_add_reference() const throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
#pragma empty_line
void
_M_remove_reference() const throw()
{
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
if (true)
{ delete this; }
if (false)
{ }
}
}
#pragma empty_line
facet(const facet&); // Not defined.
#pragma empty_line
facet&
operator=(const facet&); // Not defined.
};
#pragma empty_line
#pragma empty_line
// 22.1.1.1.3 Class locale::id
/**
* @brief Facet ID class.
* @ingroup locales
*
* The ID class provides facets with an index used to identify them.
* Every facet class must define a public static member locale::id, or be
* derived from a facet that provides this member, otherwise the facet
* cannot be used in a locale. The locale::id ensures that each class
* type gets a unique identifier.
*/
class locale::id
{
private:
friend class locale;
friend class locale::_Impl;
#pragma empty_line
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
#pragma empty_line
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
#pragma empty_line
// NB: There is no accessor for _M_index because it may be used
// before the constructor is run; the effect of calling a member
// function (even an inline) would be undefined.
mutable size_t _M_index;
#pragma empty_line
// Last id number assigned.
static _Atomic_word _S_refcount;
#pragma empty_line
void
operator=(const id&); // Not defined.
#pragma empty_line
id(const id&); // Not defined.
#pragma empty_line
public:
// NB: This class is always a static data member, and thus can be
// counted on to be zero-initialized.
/// Constructor.
id() { }
#pragma empty_line
size_t
_M_id() const throw();
};
#pragma empty_line
#pragma empty_line
// Implementation object for locale.
class locale::_Impl
{
public:
// Friends.
friend class locale;
friend class locale::facet;
#pragma empty_line
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
#pragma empty_line
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
#pragma empty_line
template<typename _Cache>
friend struct __use_cache;
#pragma empty_line
private:
// Data Members.
_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];
#pragma empty_line
void
_M_add_reference() throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
#pragma empty_line
void
_M_remove_reference() throw()
{
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
if (true)
{ delete this; }
if (false)
{ }
}
}
#pragma empty_line
_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();
#pragma empty_line
~_Impl() throw();
#pragma empty_line
_Impl(const _Impl&); // Not defined.
#pragma empty_line
void
operator=(const _Impl&); // Not defined.
#pragma empty_line
bool
_M_check_same_name()
{
bool __ret = true;
if (_M_names[1])
// We must actually compare all the _M_names: can be all equal!
for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
__ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
return __ret;
}
#pragma empty_line
void
_M_replace_categories(const _Impl*, category);
#pragma empty_line
void
_M_replace_category(const _Impl*, const locale::id* const*);
#pragma empty_line
void
_M_replace_facet(const _Impl*, const locale::id*);
#pragma empty_line
void
_M_install_facet(const locale::id*, const facet*);
#pragma empty_line
template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
{ _M_install_facet(&_Facet::id, __facet); }
#pragma empty_line
void
_M_install_cache(const facet*, size_t);
};
#pragma empty_line
#pragma empty_line
/**
* @brief Test for the presence of a facet.
*
* has_facet tests the locale argument for the presence of the facet type
* provided as the template parameter. Facets derived from the facet
* parameter will also return true.
*
* @param Facet The facet type to test the presence of.
* @param locale The locale to test.
* @return true if locale contains a facet of type Facet, else false.
*/
template<typename _Facet>
bool
has_facet(const locale& __loc) throw();
#pragma empty_line
/**
* @brief Return a facet.
*
* use_facet looks for and returns a reference to a facet of type Facet
* where Facet is the template parameter. If has_facet(locale) is true,
* there is a suitable facet to return. It throws std::bad_cast if the
* locale doesn't contain a facet of type Facet.
*
* @param Facet The facet type to access.
* @param locale The locale to use.
* @return Reference to facet of type Facet.
* @throw std::bad_cast if locale doesn't contain a facet of type Facet.
*/
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc);
#pragma empty_line
#pragma empty_line
/**
* @brief Facet for localized string comparison.
*
* This facet encapsulates the code to compare strings in a localized
* manner.
*
* The collate template uses protected virtual functions to provide
* the actual results. The public accessors forward the call to
* the virtual functions. These virtual functions are hooks for
* developers to implement the behavior they require from the
* collate facet.
*/
template<typename _CharT>
class collate : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
//@}
#pragma empty_line
protected:
// Underlying "C" library locale information saved from
// initialization, needed by collate_byname as well.
__c_locale _M_c_locale_collate;
#pragma empty_line
public:
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
collate(size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_get_c_locale())
{ }
#pragma empty_line
/**
* @brief Internal constructor. Not for general use.
*
* This is a constructor for use by the library itself to set up new
* locales.
*
* @param cloc The C locale.
* @param refs Passed to the base facet class.
*/
explicit
collate(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
{ }
#pragma empty_line
/**
* @brief Compare two strings.
*
* This function compares two strings and returns the result by calling
* collate::do_compare().
*
* @param lo1 Start of string 1.
* @param hi1 End of string 1.
* @param lo2 Start of string 2.
* @param hi2 End of string 2.
* @return 1 if string1 > string2, -1 if string1 < string2, else 0.
*/
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{ return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
#pragma empty_line
/**
* @brief Transform string to comparable form.
*
* This function is a wrapper for strxfrm functionality. It takes the
* input string and returns a modified string that can be directly
* compared to other transformed strings. In the C locale, this
* function just returns a copy of the input string. In some other
* locales, it may replace two chars with one, change a char for
* another, etc. It does so by returning collate::do_transform().
*
* @param lo Start of string.
* @param hi End of string.
* @return Transformed string_type.
*/
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_transform(__lo, __hi); }
#pragma empty_line
/**
* @brief Return hash of a string.
*
* This function computes and returns a hash on the input string. It
* does so by returning collate::do_hash().
*
* @param lo Start of string.
* @param hi End of string.
* @return Hash value.
*/
long
hash(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_hash(__lo, __hi); }
#pragma empty_line
// Used to abstract out _CharT bits in virtual member functions, below.
int
_M_compare(const _CharT*, const _CharT*) const throw();
#pragma empty_line
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
#pragma empty_line
protected:
/// Destructor.
virtual
~collate()
{ _S_destroy_c_locale(_M_c_locale_collate); }
#pragma empty_line
/**
* @brief Compare two strings.
*
* This function is a hook for derived classes to change the value
* returned. @see compare().
*
* @param lo1 Start of string 1.
* @param hi1 End of string 1.
* @param lo2 Start of string 2.
* @param hi2 End of string 2.
* @return 1 if string1 > string2, -1 if string1 < string2, else 0.
*/
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
#pragma empty_line
/**
* @brief Transform string to comparable form.
*
* This function is a hook for derived classes to change the value
* returned.
*
* @param lo1 Start of string 1.
* @param hi1 End of string 1.
* @param lo2 Start of string 2.
* @param hi2 End of string 2.
* @return 1 if string1 > string2, -1 if string1 < string2, else 0.
*/
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
#pragma empty_line
/**
* @brief Return hash of a string.
*
* This function computes and returns a hash on the input string. This
* function is a hook for derived classes to change the value returned.
*
* @param lo Start of string.
* @param hi End of string.
* @return Hash value.
*/
virtual long
do_hash(const _CharT* __lo, const _CharT* __hi) const;
};
#pragma empty_line
template<typename _CharT>
locale::id collate<_CharT>::id;
#pragma empty_line
// Specializations.
template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();
#pragma empty_line
template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();
#pragma empty_line
#pragma empty_line
template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
#pragma empty_line
template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
#pragma empty_line
#pragma empty_line
/// class collate_byname [22.2.4.2].
template<typename _CharT>
class collate_byname : public collate<_CharT>
{
public:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
//@}
#pragma empty_line
explicit
collate_byname(const char* __s, size_t __refs = 0)
: collate<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_collate);
this->_S_create_c_locale(this->_M_c_locale_collate, __s);
}
}
#pragma empty_line
protected:
virtual
~collate_byname() { }
};
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_classes.tcc" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file locale_classes.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_classes.tcc" 3
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _Facet>
locale::
locale(const locale& __other, _Facet* __f)
{
_M_impl = new _Impl(*__other._M_impl, 1);
#pragma empty_line
if (true)
{ _M_impl->_M_install_facet(&_Facet::id, __f); }
if (false)
{
_M_impl->_M_remove_reference();
;
}
delete [] _M_impl->_M_names[0];
_M_impl->_M_names[0] = 0; // Unnamed.
}
#pragma empty_line
template<typename _Facet>
locale
locale::
combine(const locale& __other) const
{
_Impl* __tmp = new _Impl(*_M_impl, 1);
if (true)
{
__tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
}
if (false)
{
__tmp->_M_remove_reference();
;
}
return locale(__tmp);
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
bool
locale::
operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
const basic_string<_CharT, _Traits, _Alloc>& __s2) const
{
typedef std::collate<_CharT> __collate_type;
const __collate_type& __collate = use_facet<__collate_type>(*this);
return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
__s2.data(), __s2.data() + __s2.length()) < 0);
}
#pragma empty_line
#pragma empty_line
template<typename _Facet>
bool
has_facet(const locale& __loc) throw()
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;
return (__i < __loc._M_impl->_M_facets_size
#pragma empty_line
&& dynamic_cast<const _Facet*>(__facets[__i]));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc)
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;
if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
__throw_bad_cast();
#pragma empty_line
return dynamic_cast<const _Facet&>(*__facets[__i]);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
// Generic version does nothing.
template<typename _CharT>
int
collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
{ return 0; }
#pragma empty_line
// Generic version does nothing.
template<typename _CharT>
size_t
collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
{ return 0; }
#pragma empty_line
template<typename _CharT>
int
collate<_CharT>::
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{
// strcoll assumes zero-terminated strings so we make a copy
// and then put a zero at the end.
const string_type __one(__lo1, __hi1);
const string_type __two(__lo2, __hi2);
#pragma empty_line
const _CharT* __p = __one.c_str();
const _CharT* __pend = __one.data() + __one.length();
const _CharT* __q = __two.c_str();
const _CharT* __qend = __two.data() + __two.length();
#pragma empty_line
// strcoll stops when it sees a nul character so we break
// the strings into zero-terminated substrings and pass those
// to strcoll.
for (;;)
{
const int __res = _M_compare(__p, __q);
if (__res)
return __res;
#pragma empty_line
__p += char_traits<_CharT>::length(__p);
__q += char_traits<_CharT>::length(__q);
if (__p == __pend && __q == __qend)
return 0;
else if (__p == __pend)
return -1;
else if (__q == __qend)
return 1;
#pragma empty_line
__p++;
__q++;
}
}
#pragma empty_line
template<typename _CharT>
typename collate<_CharT>::string_type
collate<_CharT>::
do_transform(const _CharT* __lo, const _CharT* __hi) const
{
string_type __ret;
#pragma empty_line
// strxfrm assumes zero-terminated strings so we make a copy
const string_type __str(__lo, __hi);
#pragma empty_line
const _CharT* __p = __str.c_str();
const _CharT* __pend = __str.data() + __str.length();
#pragma empty_line
size_t __len = (__hi - __lo) * 2;
#pragma empty_line
_CharT* __c = new _CharT[__len];
#pragma empty_line
if (true)
{
// strxfrm stops when it sees a nul character so we break
// the string into zero-terminated substrings and pass those
// to strxfrm.
for (;;)
{
// First try a buffer perhaps big enough.
size_t __res = _M_transform(__c, __p, __len);
// If the buffer was not large enough, try again with the
// correct size.
if (__res >= __len)
{
__len = __res + 1;
delete [] __c, __c = 0;
__c = new _CharT[__len];
__res = _M_transform(__c, __p, __len);
}
#pragma empty_line
__ret.append(__c, __res);
__p += char_traits<_CharT>::length(__p);
if (__p == __pend)
break;
#pragma empty_line
__p++;
__ret.push_back(_CharT());
}
}
if (false)
{
delete [] __c;
;
}
#pragma empty_line
delete [] __c;
#pragma empty_line
return __ret;
}
#pragma empty_line
template<typename _CharT>
long
collate<_CharT>::
do_hash(const _CharT* __lo, const _CharT* __hi) const
{
unsigned long __val = 0;
for (; __lo < __hi; ++__lo)
__val =
*__lo + ((__val << 7)
| (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
__digits - 7)));
return static_cast<long>(__val);
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class collate<char>;
extern template class collate_byname<char>;
#pragma empty_line
extern template
const collate<char>&
use_facet<collate<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<collate<char> >(const locale&);
#pragma empty_line
#pragma empty_line
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
#pragma empty_line
extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<collate<wchar_t> >(const locale&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 815 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_classes.h" 2 3
#pragma line 43 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ios_base.h" 2 3
#pragma line 53 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ios_base.h" 3
namespace std {
#pragma empty_line
// The following definitions of bitmask types are enums, not ints,
// as permitted (but not required) in the standard, in order to provide
// better type safety in iostream calls. A side effect is that
// expressions involving them are no longer compile-time constants.
enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16
};
#pragma empty_line
inline _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a | __b; }
#pragma empty_line
inline _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a & __b; }
#pragma empty_line
inline _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a ^ __b; }
#pragma empty_line
inline _Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
#pragma empty_line
#pragma empty_line
enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16
};
#pragma empty_line
inline _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a | __b; }
#pragma empty_line
inline _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a & __b; }
#pragma empty_line
inline _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a ^ __b; }
#pragma empty_line
inline _Ios_Openmode
operator~(_Ios_Openmode __a)
{ return _Ios_Openmode(~static_cast<int>(__a)); }
#pragma empty_line
#pragma empty_line
enum _Ios_Iostate
{
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16
};
#pragma empty_line
inline _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a | __b; }
#pragma empty_line
inline _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a & __b; }
#pragma empty_line
inline _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a ^ __b; }
#pragma empty_line
inline _Ios_Iostate
operator~(_Ios_Iostate __a)
{ return _Ios_Iostate(~static_cast<int>(__a)); }
#pragma empty_line
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
#pragma empty_line
// 27.4.2 Class ios_base
/**
* @brief The base of the I/O class hierarchy.
* @ingroup io
*
* This class defines everything that can be defined about I/O that does
* not depend on the type of characters being input or output. Most
* people will only see @c ios_base when they need to specify the full
* name of the various I/O flags (e.g., the openmodes).
*/
class ios_base
{
public:
#pragma empty_line
/**
* @brief These are thrown to indicate problems with io.
* @ingroup exceptions
*
* 27.4.2.1.1 Class ios_base::failure
*/
class failure : public exception
{
public:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 48. Use of non-existent exception constructor
explicit
failure(const string& __str) throw();
#pragma empty_line
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Vague-Linkage.html
virtual
~failure() throw();
#pragma empty_line
virtual const char*
what() const throw();
#pragma empty_line
private:
string _M_msg;
};
#pragma empty_line
// 27.4.2.1.2 Type ios_base::fmtflags
/**
* @brief This is a bitmask type.
*
* @c @a _Ios_Fmtflags is implementation-defined, but it is valid to
* perform bitwise operations on these values and expect the Right
* Thing to happen. Defined objects of type fmtflags are:
* - boolalpha
* - dec
* - fixed
* - hex
* - internal
* - left
* - oct
* - right
* - scientific
* - showbase
* - showpoint
* - showpos
* - skipws
* - unitbuf
* - uppercase
* - adjustfield
* - basefield
* - floatfield
*/
typedef _Ios_Fmtflags fmtflags;
#pragma empty_line
/// Insert/extract @c bool in alphabetic rather than numeric format.
static const fmtflags boolalpha = _S_boolalpha;
#pragma empty_line
/// Converts integer input or generates integer output in decimal base.
static const fmtflags dec = _S_dec;
#pragma empty_line
/// Generate floating-point output in fixed-point notation.
static const fmtflags fixed = _S_fixed;
#pragma empty_line
/// Converts integer input or generates integer output in hexadecimal base.
static const fmtflags hex = _S_hex;
#pragma empty_line
/// Adds fill characters at a designated internal point in certain
/// generated output, or identical to @c right if no such point is
/// designated.
static const fmtflags internal = _S_internal;
#pragma empty_line
/// Adds fill characters on the right (final positions) of certain
/// generated output. (I.e., the thing you print is flush left.)
static const fmtflags left = _S_left;
#pragma empty_line
/// Converts integer input or generates integer output in octal base.
static const fmtflags oct = _S_oct;
#pragma empty_line
/// Adds fill characters on the left (initial positions) of certain
/// generated output. (I.e., the thing you print is flush right.)
static const fmtflags right = _S_right;
#pragma empty_line
/// Generates floating-point output in scientific notation.
static const fmtflags scientific = _S_scientific;
#pragma empty_line
/// Generates a prefix indicating the numeric base of generated integer
/// output.
static const fmtflags showbase = _S_showbase;
#pragma empty_line
/// Generates a decimal-point character unconditionally in generated
/// floating-point output.
static const fmtflags showpoint = _S_showpoint;
#pragma empty_line
/// Generates a + sign in non-negative generated numeric output.
static const fmtflags showpos = _S_showpos;
#pragma empty_line
/// Skips leading white space before certain input operations.
static const fmtflags skipws = _S_skipws;
#pragma empty_line
/// Flushes output after each output operation.
static const fmtflags unitbuf = _S_unitbuf;
#pragma empty_line
/// Replaces certain lowercase letters with their uppercase equivalents
/// in generated output.
static const fmtflags uppercase = _S_uppercase;
#pragma empty_line
/// A mask of left|right|internal. Useful for the 2-arg form of @c setf.
static const fmtflags adjustfield = _S_adjustfield;
#pragma empty_line
/// A mask of dec|oct|hex. Useful for the 2-arg form of @c setf.
static const fmtflags basefield = _S_basefield;
#pragma empty_line
/// A mask of scientific|fixed. Useful for the 2-arg form of @c setf.
static const fmtflags floatfield = _S_floatfield;
#pragma empty_line
// 27.4.2.1.3 Type ios_base::iostate
/**
* @brief This is a bitmask type.
*
* @c @a _Ios_Iostate is implementation-defined, but it is valid to
* perform bitwise operations on these values and expect the Right
* Thing to happen. Defined objects of type iostate are:
* - badbit
* - eofbit
* - failbit
* - goodbit
*/
typedef _Ios_Iostate iostate;
#pragma empty_line
/// Indicates a loss of integrity in an input or output sequence (such
/// as an irrecoverable read error from a file).
static const iostate badbit = _S_badbit;
#pragma empty_line
/// Indicates that an input operation reached the end of an input sequence.
static const iostate eofbit = _S_eofbit;
#pragma empty_line
/// Indicates that an input operation failed to read the expected
/// characters, or that an output operation failed to generate the
/// desired characters.
static const iostate failbit = _S_failbit;
#pragma empty_line
/// Indicates all is well.
static const iostate goodbit = _S_goodbit;
#pragma empty_line
// 27.4.2.1.4 Type ios_base::openmode
/**
* @brief This is a bitmask type.
*
* @c @a _Ios_Openmode is implementation-defined, but it is valid to
* perform bitwise operations on these values and expect the Right
* Thing to happen. Defined objects of type openmode are:
* - app
* - ate
* - binary
* - in
* - out
* - trunc
*/
typedef _Ios_Openmode openmode;
#pragma empty_line
/// Seek to end before each write.
static const openmode app = _S_app;
#pragma empty_line
/// Open and seek to end immediately after opening.
static const openmode ate = _S_ate;
#pragma empty_line
/// Perform input and output in binary mode (as opposed to text mode).
/// This is probably not what you think it is; see
/// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch27s02.html
static const openmode binary = _S_bin;
#pragma empty_line
/// Open for input. Default for @c ifstream and fstream.
static const openmode in = _S_in;
#pragma empty_line
/// Open for output. Default for @c ofstream and fstream.
static const openmode out = _S_out;
#pragma empty_line
/// Open for input. Default for @c ofstream.
static const openmode trunc = _S_trunc;
#pragma empty_line
// 27.4.2.1.5 Type ios_base::seekdir
/**
* @brief This is an enumerated type.
*
* @c @a _Ios_Seekdir is implementation-defined. Defined values
* of type seekdir are:
* - beg
* - cur, equivalent to @c SEEK_CUR in the C standard library.
* - end, equivalent to @c SEEK_END in the C standard library.
*/
typedef _Ios_Seekdir seekdir;
#pragma empty_line
/// Request a seek relative to the beginning of the stream.
static const seekdir beg = _S_beg;
#pragma empty_line
/// Request a seek relative to the current position within the sequence.
static const seekdir cur = _S_cur;
#pragma empty_line
/// Request a seek relative to the current end of the sequence.
static const seekdir end = _S_end;
#pragma empty_line
// Annex D.6
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
#pragma empty_line
typedef std::streampos streampos;
typedef std::streamoff streamoff;
#pragma empty_line
// Callbacks;
/**
* @brief The set of events that may be passed to an event callback.
*
* erase_event is used during ~ios() and copyfmt(). imbue_event is used
* during imbue(). copyfmt_event is used during copyfmt().
*/
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
#pragma empty_line
/**
* @brief The type of an event callback function.
* @param event One of the members of the event enum.
* @param ios_base Reference to the ios_base object.
* @param int The integer provided when the callback was registered.
*
* Event callbacks are user defined functions that get called during
* several ios_base and basic_ios functions, specifically imbue(),
* copyfmt(), and ~ios().
*/
typedef void (*event_callback) (event, ios_base&, int);
#pragma empty_line
/**
* @brief Add the callback __fn with parameter __index.
* @param __fn The function to add.
* @param __index The integer to pass to the function when invoked.
*
* Registers a function as an event callback with an integer parameter to
* be passed to the function when invoked. Multiple copies of the
* function are allowed. If there are multiple callbacks, they are
* invoked in the order they were registered.
*/
void
register_callback(event_callback __fn, int __index);
#pragma empty_line
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
#pragma empty_line
// 27.4.2.6 Members for callbacks
// 27.4.2.6 ios_base callbacks
struct _Callback_list
{
// Data Members
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount; // 0 means one reference.
#pragma empty_line
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list* __cb)
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
#pragma empty_line
void
_M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
#pragma empty_line
// 0 => OK to delete.
int
_M_remove_reference()
{ return __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); }
};
#pragma empty_line
_Callback_list* _M_callbacks;
#pragma empty_line
void
_M_call_callbacks(event __ev) throw();
#pragma empty_line
void
_M_dispose_callbacks(void) throw();
#pragma empty_line
// 27.4.2.5 Members for iword/pword storage
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) { }
};
#pragma empty_line
// Only for failed iword/pword calls.
_Words _M_word_zero;
#pragma empty_line
// Guaranteed storage.
// The first 5 iword and pword slots are reserved for internal use.
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
#pragma empty_line
// Allocated storage.
int _M_word_size;
_Words* _M_word;
#pragma empty_line
_Words&
_M_grow_words(int __index, bool __iword);
#pragma empty_line
// Members for locale and locale caching.
locale _M_ios_locale;
#pragma empty_line
void
_M_init() throw();
#pragma empty_line
public:
#pragma empty_line
// 27.4.2.1.6 Class ios_base::Init
// Used to initialize standard streams. In theory, g++ could use
// -finit-priority to order this stuff correctly without going
// through these machinations.
class Init
{
friend class ios_base;
public:
Init();
~Init();
#pragma empty_line
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
#pragma empty_line
// [27.4.2.2] fmtflags state functions
/**
* @brief Access to format flags.
* @return The format control flags for both input and output.
*/
fmtflags
flags() const
{ return _M_flags; }
#pragma empty_line
/**
* @brief Setting new format flags all at once.
* @param fmtfl The new flags to set.
* @return The previous format control flags.
*
* This function overwrites all the format flags with @a fmtfl.
*/
fmtflags
flags(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags = __fmtfl;
return __old;
}
#pragma empty_line
/**
* @brief Setting new format flags.
* @param fmtfl Additional flags to set.
* @return The previous format control flags.
*
* This function sets additional flags in format control. Flags that
* were previously set remain set.
*/
fmtflags
setf(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags |= __fmtfl;
return __old;
}
#pragma empty_line
/**
* @brief Setting new format flags.
* @param fmtfl Additional flags to set.
* @param mask The flags mask for @a fmtfl.
* @return The previous format control flags.
*
* This function clears @a mask in the format flags, then sets
* @a fmtfl @c & @a mask. An example mask is @c ios_base::adjustfield.
*/
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
{
fmtflags __old = _M_flags;
_M_flags &= ~__mask;
_M_flags |= (__fmtfl & __mask);
return __old;
}
#pragma empty_line
/**
* @brief Clearing format flags.
* @param mask The flags to unset.
*
* This function clears @a mask in the format flags.
*/
void
unsetf(fmtflags __mask)
{ _M_flags &= ~__mask; }
#pragma empty_line
/**
* @brief Flags access.
* @return The precision to generate on certain output operations.
*
* Be careful if you try to give a definition of @a precision here; see
* DR 189.
*/
streamsize
precision() const
{ return _M_precision; }
#pragma empty_line
/**
* @brief Changing flags.
* @param prec The new precision value.
* @return The previous value of precision().
*/
streamsize
precision(streamsize __prec)
{
streamsize __old = _M_precision;
_M_precision = __prec;
return __old;
}
#pragma empty_line
/**
* @brief Flags access.
* @return The minimum field width to generate on output operations.
*
* <em>Minimum field width</em> refers to the number of characters.
*/
streamsize
width() const
{ return _M_width; }
#pragma empty_line
/**
* @brief Changing flags.
* @param wide The new width value.
* @return The previous value of width().
*/
streamsize
width(streamsize __wide)
{
streamsize __old = _M_width;
_M_width = __wide;
return __old;
}
#pragma empty_line
// [27.4.2.4] ios_base static members
/**
* @brief Interaction with the standard C I/O objects.
* @param sync Whether to synchronize or not.
* @return True if the standard streams were previously synchronized.
*
* The synchronization referred to is @e only that between the standard
* C facilities (e.g., stdout) and the standard C++ objects (e.g.,
* cout). User-declared streams are unaffected. See
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch28s02.html
*/
static bool
sync_with_stdio(bool __sync = true);
#pragma empty_line
// [27.4.2.3] ios_base locale functions
/**
* @brief Setting a new locale.
* @param loc The new locale.
* @return The previous locale.
*
* Sets the new locale for this stream, and then invokes each callback
* with imbue_event.
*/
locale
imbue(const locale& __loc) throw();
#pragma empty_line
/**
* @brief Locale access
* @return A copy of the current locale.
*
* If @c imbue(loc) has previously been called, then this function
* returns @c loc. Otherwise, it returns a copy of @c std::locale(),
* the global C++ locale.
*/
locale
getloc() const
{ return _M_ios_locale; }
#pragma empty_line
/**
* @brief Locale access
* @return A reference to the current locale.
*
* Like getloc above, but returns a reference instead of
* generating a copy.
*/
const locale&
_M_getloc() const
{ return _M_ios_locale; }
#pragma empty_line
// [27.4.2.5] ios_base storage functions
/**
* @brief Access to unique indices.
* @return An integer different from all previous calls.
*
* This function returns a unique integer every time it is called. It
* can be used for any purpose, but is primarily intended to be a unique
* index for the iword and pword functions. The expectation is that an
* application calls xalloc in order to obtain an index in the iword and
* pword arrays that can be used without fear of conflict.
*
* The implementation maintains a static variable that is incremented and
* returned on each invocation. xalloc is guaranteed to return an index
* that is safe to use in the iword and pword arrays.
*/
static int
xalloc() throw();
#pragma empty_line
/**
* @brief Access to integer array.
* @param __ix Index into the array.
* @return A reference to an integer associated with the index.
*
* The iword function provides access to an array of integers that can be
* used for any purpose. The array grows as required to hold the
* supplied index. All integers in the array are initialized to 0.
*
* The implementation reserves several indices. You should use xalloc to
* obtain an index that is safe to use. Also note that since the array
* can grow dynamically, it is not safe to hold onto the reference.
*/
long&
iword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, true);
return __word._M_iword;
}
#pragma empty_line
/**
* @brief Access to void pointer array.
* @param __ix Index into the array.
* @return A reference to a void* associated with the index.
*
* The pword function provides access to an array of pointers that can be
* used for any purpose. The array grows as required to hold the
* supplied index. All pointers in the array are initialized to 0.
*
* The implementation reserves several indices. You should use xalloc to
* obtain an index that is safe to use. Also note that since the array
* can grow dynamically, it is not safe to hold onto the reference.
*/
void*&
pword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, false);
return __word._M_pword;
}
#pragma empty_line
// Destructor
/**
* Invokes each callback with erase_event. Destroys local storage.
*
* Note that the ios_base object for the standard streams never gets
* destroyed. As a result, any callbacks registered with the standard
* streams will not get invoked with erase_event (unless copyfmt is
* used).
*/
virtual ~ios_base();
#pragma empty_line
protected:
ios_base() throw ();
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 50. Copy constructor and assignment operator of ios_base
private:
ios_base(const ios_base&);
#pragma empty_line
ios_base&
operator=(const ios_base&);
};
#pragma empty_line
// [27.4.5.1] fmtflags manipulators
/// Calls base.setf(ios_base::boolalpha).
inline ios_base&
boolalpha(ios_base& __base)
{
__base.setf(ios_base::boolalpha);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::boolalpha).
inline ios_base&
noboolalpha(ios_base& __base)
{
__base.unsetf(ios_base::boolalpha);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::showbase).
inline ios_base&
showbase(ios_base& __base)
{
__base.setf(ios_base::showbase);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::showbase).
inline ios_base&
noshowbase(ios_base& __base)
{
__base.unsetf(ios_base::showbase);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::showpoint).
inline ios_base&
showpoint(ios_base& __base)
{
__base.setf(ios_base::showpoint);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::showpoint).
inline ios_base&
noshowpoint(ios_base& __base)
{
__base.unsetf(ios_base::showpoint);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::showpos).
inline ios_base&
showpos(ios_base& __base)
{
__base.setf(ios_base::showpos);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::showpos).
inline ios_base&
noshowpos(ios_base& __base)
{
__base.unsetf(ios_base::showpos);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::skipws).
inline ios_base&
skipws(ios_base& __base)
{
__base.setf(ios_base::skipws);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::skipws).
inline ios_base&
noskipws(ios_base& __base)
{
__base.unsetf(ios_base::skipws);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::uppercase).
inline ios_base&
uppercase(ios_base& __base)
{
__base.setf(ios_base::uppercase);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::uppercase).
inline ios_base&
nouppercase(ios_base& __base)
{
__base.unsetf(ios_base::uppercase);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::unitbuf).
inline ios_base&
unitbuf(ios_base& __base)
{
__base.setf(ios_base::unitbuf);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::unitbuf).
inline ios_base&
nounitbuf(ios_base& __base)
{
__base.unsetf(ios_base::unitbuf);
return __base;
}
#pragma empty_line
// [27.4.5.2] adjustfield manipulators
/// Calls base.setf(ios_base::internal, ios_base::adjustfield).
inline ios_base&
internal(ios_base& __base)
{
__base.setf(ios_base::internal, ios_base::adjustfield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::left, ios_base::adjustfield).
inline ios_base&
left(ios_base& __base)
{
__base.setf(ios_base::left, ios_base::adjustfield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::right, ios_base::adjustfield).
inline ios_base&
right(ios_base& __base)
{
__base.setf(ios_base::right, ios_base::adjustfield);
return __base;
}
#pragma empty_line
// [27.4.5.3] basefield manipulators
/// Calls base.setf(ios_base::dec, ios_base::basefield).
inline ios_base&
dec(ios_base& __base)
{
__base.setf(ios_base::dec, ios_base::basefield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::hex, ios_base::basefield).
inline ios_base&
hex(ios_base& __base)
{
__base.setf(ios_base::hex, ios_base::basefield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::oct, ios_base::basefield).
inline ios_base&
oct(ios_base& __base)
{
__base.setf(ios_base::oct, ios_base::basefield);
return __base;
}
#pragma empty_line
// [27.4.5.4] floatfield manipulators
/// Calls base.setf(ios_base::fixed, ios_base::floatfield).
inline ios_base&
fixed(ios_base& __base)
{
__base.setf(ios_base::fixed, ios_base::floatfield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::scientific, ios_base::floatfield).
inline ios_base&
scientific(ios_base& __base)
{
__base.setf(ios_base::scientific, ios_base::floatfield);
return __base;
}
#pragma empty_line
}
#pragma line 43 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\streambuf" 1 3
// Stream buffer classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file streambuf
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.5 Stream buffers
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\streambuf" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
#pragma empty_line
/**
* @brief The actual work of input and output (interface).
* @ingroup io
*
* This is a base class. Derived stream buffers each control a
* pair of character sequences: one for input, and one for output.
*
* Section [27.5.1] of the standard describes the requirements and
* behavior of stream buffer classes. That section (three paragraphs)
* is reproduced here, for simplicity and accuracy.
*
* -# Stream buffers can impose various constraints on the sequences
* they control. Some constraints are:
* - The controlled input sequence can be not readable.
* - The controlled output sequence can be not writable.
* - The controlled sequences can be associated with the contents of
* other representations for character sequences, such as external
* files.
* - The controlled sequences can support operations @e directly to or
* from associated sequences.
* - The controlled sequences can impose limitations on how the
* program can read characters from a sequence, write characters to
* a sequence, put characters back into an input sequence, or alter
* the stream position.
* .
* -# Each sequence is characterized by three pointers which, if non-null,
* all point into the same @c charT array object. The array object
* represents, at any moment, a (sub)sequence of characters from the
* sequence. Operations performed on a sequence alter the values
* stored in these pointers, perform reads and writes directly to or
* from associated sequences, and alter <em>the stream position</em> and
* conversion state as needed to maintain this subsequence relationship.
* The three pointers are:
* - the <em>beginning pointer</em>, or lowest element address in the
* array (called @e xbeg here);
* - the <em>next pointer</em>, or next element address that is a
* current candidate for reading or writing (called @e xnext here);
* - the <em>end pointer</em>, or first element address beyond the
* end of the array (called @e xend here).
* .
* -# The following semantic constraints shall always apply for any set
* of three pointers for a sequence, using the pointer names given
* immediately above:
* - If @e xnext is not a null pointer, then @e xbeg and @e xend shall
* also be non-null pointers into the same @c charT array, as
* described above; otherwise, @e xbeg and @e xend shall also be null.
* - If @e xnext is not a null pointer and @e xnext < @e xend for an
* output sequence, then a <em>write position</em> is available.
* In this case, @e *xnext shall be assignable as the next element
* to write (to put, or to store a character value, into the sequence).
* - If @e xnext is not a null pointer and @e xbeg < @e xnext for an
* input sequence, then a <em>putback position</em> is available.
* In this case, @e xnext[-1] shall have a defined value and is the
* next (preceding) element to store a character that is put back
* into the input sequence.
* - If @e xnext is not a null pointer and @e xnext< @e xend for an
* input sequence, then a <em>read position</em> is available.
* In this case, @e *xnext shall have a defined value and is the
* next element to read (to get, or to obtain a character value,
* from the sequence).
*/
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
//@{
/**
* These are standard types. They permit a standardized way of
* referring to names of (or names dependant on) the template
* parameters, which are specific to the implementation.
*/
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
//@}
#pragma empty_line
//@{
/// This is a non-standard type.
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
//@}
#pragma empty_line
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;
#pragma empty_line
friend streamsize
__copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);
#pragma empty_line
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
#pragma empty_line
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
#pragma empty_line
template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
#pragma empty_line
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
#pragma empty_line
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
#pragma empty_line
protected:
//@{
/**
* This is based on _IO_FILE, just reordered to be more consistent,
* and is intended to be the most minimal abstraction for an
* internal buffer.
* - get == input == read
* - put == output == write
*/
char_type* _M_in_beg; // Start of get area.
char_type* _M_in_cur; // Current read area.
char_type* _M_in_end; // End of get area.
char_type* _M_out_beg; // Start of put area.
char_type* _M_out_cur; // Current put area.
char_type* _M_out_end; // End of put area.
#pragma empty_line
/// Current locale setting.
locale _M_buf_locale;
#pragma empty_line
public:
/// Destructor deallocates no buffer space.
virtual
~basic_streambuf()
{ }
#pragma empty_line
// [27.5.2.2.1] locales
/**
* @brief Entry point for imbue().
* @param loc The new locale.
* @return The previous locale.
*
* Calls the derived imbue(loc).
*/
locale
pubimbue(const locale &__loc)
{
locale __tmp(this->getloc());
this->imbue(__loc);
_M_buf_locale = __loc;
return __tmp;
}
#pragma empty_line
/**
* @brief Locale access.
* @return The current locale in effect.
*
* If pubimbue(loc) has been called, then the most recent @c loc
* is returned. Otherwise the global locale in effect at the time
* of construction is returned.
*/
locale
getloc() const
{ return _M_buf_locale; }
#pragma empty_line
// [27.5.2.2.2] buffer management and positioning
//@{
/**
* @brief Entry points for derived buffer functions.
*
* The public versions of @c pubfoo dispatch to the protected
* derived @c foo member functions, passing the arguments (if any)
* and returning the result unchanged.
*/
__streambuf_type*
pubsetbuf(char_type* __s, streamsize __n)
{ return this->setbuf(__s, __n); }
#pragma empty_line
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekoff(__off, __way, __mode); }
#pragma empty_line
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekpos(__sp, __mode); }
#pragma empty_line
int
pubsync() { return this->sync(); }
//@}
#pragma empty_line
// [27.5.2.2.3] get area
/**
* @brief Looking ahead into the stream.
* @return The number of characters available.
*
* If a read position is available, returns the number of characters
* available for reading before the buffer must be refilled.
* Otherwise returns the derived @c showmanyc().
*/
streamsize
in_avail()
{
const streamsize __ret = this->egptr() - this->gptr();
return __ret ? __ret : this->showmanyc();
}
#pragma empty_line
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* Calls @c sbumpc(), and if that function returns
* @c traits::eof(), so does this function. Otherwise, @c sgetc().
*/
int_type
snextc()
{
int_type __ret = traits_type::eof();
if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
__ret), true))
__ret = this->sgetc();
return __ret;
}
#pragma empty_line
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* If the input read position is available, returns that character
* and increments the read pointer, otherwise calls and returns
* @c uflow().
*/
int_type
sbumpc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
else
__ret = this->uflow();
return __ret;
}
#pragma empty_line
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* If the input read position is available, returns that character,
* otherwise calls and returns @c underflow(). Does not move the
* read position after fetching the character.
*/
int_type
sgetc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
__ret = traits_type::to_int_type(*this->gptr());
else
__ret = this->underflow();
return __ret;
}
#pragma empty_line
/**
* @brief Entry point for xsgetn.
* @param s A buffer area.
* @param n A count.
*
* Returns xsgetn(s,n). The effect is to fill @a s[0] through
* @a s[n-1] with characters from the input sequence, if possible.
*/
streamsize
sgetn(char_type* __s, streamsize __n)
{ return this->xsgetn(__s, __n); }
#pragma empty_line
// [27.5.2.2.4] putback
/**
* @brief Pushing characters back into the input stream.
* @param c The character to push back.
* @return The previous character, if possible.
*
* Similar to sungetc(), but @a c is pushed onto the stream
* instead of <em>the previous character.</em> If successful,
* the next character fetched from the input stream will be @a
* c.
*/
int_type
sputbackc(char_type __c)
{
int_type __ret;
const bool __testpos = this->eback() < this->gptr();
if (__builtin_expect(!__testpos ||
!traits_type::eq(__c, this->gptr()[-1]), false))
__ret = this->pbackfail(traits_type::to_int_type(__c));
else
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
#pragma empty_line
/**
* @brief Moving backwards in the input stream.
* @return The previous character, if possible.
*
* If a putback position is available, this function decrements
* the input pointer and returns that character. Otherwise,
* calls and returns pbackfail(). The effect is to @a unget
* the last character @a gotten.
*/
int_type
sungetc()
{
int_type __ret;
if (__builtin_expect(this->eback() < this->gptr(), true))
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
else
__ret = this->pbackfail();
return __ret;
}
#pragma empty_line
// [27.5.2.2.5] put area
/**
* @brief Entry point for all single-character output functions.
* @param c A character to output.
* @return @a c, if possible.
*
* One of two public output functions.
*
* If a write position is available for the output sequence (i.e.,
* the buffer is not full), stores @a c in that position, increments
* the position, and returns @c traits::to_int_type(c). If a write
* position is not available, returns @c overflow(c).
*/
int_type
sputc(char_type __c)
{
int_type __ret;
if (__builtin_expect(this->pptr() < this->epptr(), true))
{
*this->pptr() = __c;
this->pbump(1);
__ret = traits_type::to_int_type(__c);
}
else
__ret = this->overflow(traits_type::to_int_type(__c));
return __ret;
}
#pragma empty_line
/**
* @brief Entry point for all single-character output functions.
* @param s A buffer read area.
* @param n A count.
*
* One of two public output functions.
*
*
* Returns xsputn(s,n). The effect is to write @a s[0] through
* @a s[n-1] to the output sequence, if possible.
*/
streamsize
sputn(const char_type* __s, streamsize __n)
{ return this->xsputn(__s, __n); }
#pragma empty_line
protected:
/**
* @brief Base constructor.
*
* Only called from derived constructors, and sets up all the
* buffer data to zero, including the pointers described in the
* basic_streambuf class description. Note that, as a result,
* - the class starts with no read nor write positions available,
* - this is not an error
*/
basic_streambuf()
: _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
_M_out_beg(0), _M_out_cur(0), _M_out_end(0),
_M_buf_locale(locale())
{ }
#pragma empty_line
// [27.5.2.3.1] get area access
//@{
/**
* @brief Access to the get area.
*
* These functions are only available to other protected functions,
* including derived classes.
*
* - eback() returns the beginning pointer for the input sequence
* - gptr() returns the next pointer for the input sequence
* - egptr() returns the end pointer for the input sequence
*/
char_type*
eback() const { return _M_in_beg; }
#pragma empty_line
char_type*
gptr() const { return _M_in_cur; }
#pragma empty_line
char_type*
egptr() const { return _M_in_end; }
//@}
#pragma empty_line
/**
* @brief Moving the read position.
* @param n The delta by which to move.
*
* This just advances the read position without returning any data.
*/
void
gbump(int __n) { _M_in_cur += __n; }
#pragma empty_line
/**
* @brief Setting the three read area pointers.
* @param gbeg A pointer.
* @param gnext A pointer.
* @param gend A pointer.
* @post @a gbeg == @c eback(), @a gnext == @c gptr(), and
* @a gend == @c egptr()
*/
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
{
_M_in_beg = __gbeg;
_M_in_cur = __gnext;
_M_in_end = __gend;
}
#pragma empty_line
// [27.5.2.3.2] put area access
//@{
/**
* @brief Access to the put area.
*
* These functions are only available to other protected functions,
* including derived classes.
*
* - pbase() returns the beginning pointer for the output sequence
* - pptr() returns the next pointer for the output sequence
* - epptr() returns the end pointer for the output sequence
*/
char_type*
pbase() const { return _M_out_beg; }
#pragma empty_line
char_type*
pptr() const { return _M_out_cur; }
#pragma empty_line
char_type*
epptr() const { return _M_out_end; }
//@}
#pragma empty_line
/**
* @brief Moving the write position.
* @param n The delta by which to move.
*
* This just advances the write position without returning any data.
*/
void
pbump(int __n) { _M_out_cur += __n; }
#pragma empty_line
/**
* @brief Setting the three write area pointers.
* @param pbeg A pointer.
* @param pend A pointer.
* @post @a pbeg == @c pbase(), @a pbeg == @c pptr(), and
* @a pend == @c epptr()
*/
void
setp(char_type* __pbeg, char_type* __pend)
{
_M_out_beg = _M_out_cur = __pbeg;
_M_out_end = __pend;
}
#pragma empty_line
// [27.5.2.4] virtual functions
// [27.5.2.4.1] locales
/**
* @brief Changes translations.
* @param loc A new locale.
*
* Translations done during I/O which depend on the current
* locale are changed by this call. The standard adds,
* <em>Between invocations of this function a class derived
* from streambuf can safely cache results of calls to locale
* functions and to members of facets so obtained.</em>
*
* @note Base class version does nothing.
*/
virtual void
imbue(const locale&)
{ }
#pragma empty_line
// [27.5.2.4.2] buffer management and positioning
/**
* @brief Manipulates the buffer.
*
* Each derived class provides its own appropriate behavior. See
* the next-to-last paragraph of
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
* for more on this function.
*
* @note Base class version does nothing, returns @c this.
*/
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
{ return this; }
#pragma empty_line
/**
* @brief Alters the stream positions.
*
* Each derived class provides its own appropriate behavior.
* @note Base class version does nothing, returns a @c pos_type
* that represents an invalid stream position.
*/
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
#pragma empty_line
/**
* @brief Alters the stream positions.
*
* Each derived class provides its own appropriate behavior.
* @note Base class version does nothing, returns a @c pos_type
* that represents an invalid stream position.
*/
virtual pos_type
seekpos(pos_type,
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
#pragma empty_line
/**
* @brief Synchronizes the buffer arrays with the controlled sequences.
* @return -1 on failure.
*
* Each derived class provides its own appropriate behavior,
* including the definition of @a failure.
* @note Base class version does nothing, returns zero.
*/
virtual int
sync() { return 0; }
#pragma empty_line
// [27.5.2.4.3] get area
/**
* @brief Investigating the data available.
* @return An estimate of the number of characters available in the
* input sequence, or -1.
*
* <em>If it returns a positive value, then successive calls to
* @c underflow() will not return @c traits::eof() until at
* least that number of characters have been supplied. If @c
* showmanyc() returns -1, then calls to @c underflow() or @c
* uflow() will fail.</em> [27.5.2.4.3]/1
*
* @note Base class version does nothing, returns zero.
* @note The standard adds that <em>the intention is not only that the
* calls [to underflow or uflow] will not return @c eof() but
* that they will return immediately.</em>
* @note The standard adds that <em>the morphemes of @c showmanyc are
* @b es-how-many-see, not @b show-manic.</em>
*/
virtual streamsize
showmanyc() { return 0; }
#pragma empty_line
/**
* @brief Multiple character extraction.
* @param s A buffer area.
* @param n Maximum number of characters to assign.
* @return The number of characters assigned.
*
* Fills @a s[0] through @a s[n-1] with characters from the input
* sequence, as if by @c sbumpc(). Stops when either @a n characters
* have been copied, or when @c traits::eof() would be copied.
*
* It is expected that derived classes provide a more efficient
* implementation by overriding this definition.
*/
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Fetches more data from the controlled sequence.
* @return The first character from the <em>pending sequence</em>.
*
* Informally, this function is called when the input buffer is
* exhausted (or does not exist, as buffering need not actually be
* done). If a buffer exists, it is @a refilled. In either case, the
* next available character is returned, or @c traits::eof() to
* indicate a null pending sequence.
*
* For a formal definition of the pending sequence, see a good text
* such as Langer & Kreft, or [27.5.2.4.3]/7-14.
*
* A functioning input streambuf can be created by overriding only
* this function (no buffer area will be used). For an example, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25.html
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
underflow()
{ return traits_type::eof(); }
#pragma empty_line
/**
* @brief Fetches more data from the controlled sequence.
* @return The first character from the <em>pending sequence</em>.
*
* Informally, this function does the same thing as @c underflow(),
* and in fact is required to call that function. It also returns
* the new character, like @c underflow() does. However, this
* function also moves the read position forward by one.
*/
virtual int_type
uflow()
{
int_type __ret = traits_type::eof();
const bool __testeof = traits_type::eq_int_type(this->underflow(),
__ret);
if (!__testeof)
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
return __ret;
}
#pragma empty_line
// [27.5.2.4.4] putback
/**
* @brief Tries to back up the input sequence.
* @param c The character to be inserted back into the sequence.
* @return eof() on failure, <em>some other value</em> on success
* @post The constraints of @c gptr(), @c eback(), and @c pptr()
* are the same as for @c underflow().
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
pbackfail(int_type /* __c */ = traits_type::eof())
{ return traits_type::eof(); }
#pragma empty_line
// Put area:
/**
* @brief Multiple character insertion.
* @param s A buffer area.
* @param n Maximum number of characters to write.
* @return The number of characters written.
*
* Writes @a s[0] through @a s[n-1] to the output sequence, as if
* by @c sputc(). Stops when either @a n characters have been
* copied, or when @c sputc() would return @c traits::eof().
*
* It is expected that derived classes provide a more efficient
* implementation by overriding this definition.
*/
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Consumes data from the buffer; writes to the
* controlled sequence.
* @param c An additional character to consume.
* @return eof() to indicate failure, something else (usually
* @a c, or not_eof())
*
* Informally, this function is called when the output buffer
* is full (or does not exist, as buffering need not actually
* be done). If a buffer exists, it is @a consumed, with
* <em>some effect</em> on the controlled sequence.
* (Typically, the buffer is written out to the sequence
* verbatim.) In either case, the character @a c is also
* written out, if @a c is not @c eof().
*
* For a formal definition of this function, see a good text
* such as Langer & Kreft, or [27.5.2.4.5]/3-7.
*
* A functioning output streambuf can be created by overriding only
* this function (no buffer area will be used).
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
overflow(int_type /* __c */ = traits_type::eof())
{ return traits_type::eof(); }
#pragma empty_line
#pragma empty_line
// Annex D.6
public:
/**
* @brief Tosses a character.
*
* Advances the read pointer, ignoring the character that would have
* been read.
*
* See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html
*/
void
stossc()
{
if (this->gptr() < this->egptr())
this->gbump(1);
else
this->uflow();
}
#pragma empty_line
#pragma empty_line
private:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// Side effect of DR 50.
basic_streambuf(const __streambuf_type& __sb)
: _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
_M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
_M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
_M_buf_locale(__sb._M_buf_locale)
{ }
#pragma empty_line
__streambuf_type&
operator=(const __streambuf_type&) { return *this; };
};
#pragma empty_line
// Explicit specialization declarations, defined in src/streambuf.cc.
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);
#pragma empty_line
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/streambuf.tcc" 1 3
// Stream buffer classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file streambuf.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.5 Stream buffers
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/streambuf.tcc" 3
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _CharT, typename _Traits>
streamsize
basic_streambuf<_CharT, _Traits>::
xsgetn(char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->egptr() - this->gptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(__s, this->gptr(), __len);
__ret += __len;
__s += __len;
this->gbump(__len);
}
#pragma empty_line
if (__ret < __n)
{
const int_type __c = this->uflow();
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
traits_type::assign(*__s++, traits_type::to_char_type(__c));
++__ret;
}
else
break;
}
}
return __ret;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
streamsize
basic_streambuf<_CharT, _Traits>::
xsputn(const char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->epptr() - this->pptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(this->pptr(), __s, __len);
__ret += __len;
__s += __len;
this->pbump(__len);
}
#pragma empty_line
if (__ret < __n)
{
int_type __c = this->overflow(traits_type::to_int_type(*__s));
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
++__ret;
++__s;
}
else
break;
}
}
return __ret;
}
#pragma empty_line
// Conceivably, this could be used to implement buffer-to-buffer
// copies, if this was ever desired in an un-ambiguous way by the
// standard.
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
{
streamsize __ret = 0;
__ineof = true;
typename _Traits::int_type __c = __sbin->sgetc();
while (!_Traits::eq_int_type(__c, _Traits::eof()))
{
__c = __sbout->sputc(_Traits::to_char_type(__c));
if (_Traits::eq_int_type(__c, _Traits::eof()))
{
__ineof = false;
break;
}
++__ret;
__c = __sbin->snextc();
}
return __ret;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
inline streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
{
bool __ineof;
return __copy_streambufs_eof(__sbin, __sbout, __ineof);
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class basic_streambuf<char>;
extern template
streamsize
__copy_streambufs(basic_streambuf<char>*,
basic_streambuf<char>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<char>*,
basic_streambuf<char>*, bool&);
#pragma empty_line
#pragma empty_line
extern template class basic_streambuf<wchar_t>;
extern template
streamsize
__copy_streambufs(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*, bool&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 799 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\streambuf" 2 3
#pragma line 44 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_ios.h" 1 3
// Iostreams base classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file basic_ios.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_ios.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file locale_facets.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 3
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwctype" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cwctype
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c wctype.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: <cwctype>
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwctype" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wctype.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 13 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wctype.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma line 166 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\wctype.h" 3
typedef wchar_t wctrans_t;
wint_t towctrans(wint_t,wctrans_t);
wctrans_t wctrans(const char *);
wctype_t wctype(const char *);
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma line 46 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwctype" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Get rid of those macros defined in <wctype.h> in lieu of real functions.
#pragma line 75 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cwctype" 3
namespace std {
#pragma empty_line
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
#pragma empty_line
using ::iswalnum;
using ::iswalpha;
#pragma empty_line
using ::iswblank;
#pragma empty_line
using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
#pragma empty_line
}
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cctype" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cctype
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c ctype.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: <ccytpe>
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\cctype" 3
#pragma line 42 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/ctype_base.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2007, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
// We don't use the C-locale masks defined in mingw/include/ctype.h
// because those masks do not conform to the requirements of 22.2.1.
// In particular, a separate 'print' bitmask does not exist (isprint(c)
// relies on a combination of flags) and the '_ALPHA' mask is also a
// combination of simple bitmasks. Thus, we define libstdc++-specific
// masks here, based on the generic masks, and the corresponding
// classic_table in ctype_noninline.h.
#pragma empty_line
namespace std {
#pragma empty_line
/// @brief Base class for ctype.
struct ctype_base
{
// Non-standard typedefs.
typedef const int* __to_type;
#pragma empty_line
// NB: Offsets into ctype<char>::_M_table force a particular size
// on the mask type. Because of this, we don't use an enum.
typedef unsigned short mask;
static const mask upper = 1 << 0;
static const mask lower = 1 << 1;
static const mask alpha = 1 << 2;
static const mask digit = 1 << 3;
static const mask xdigit = 1 << 4;
static const mask space = 1 << 5;
static const mask print = 1 << 6;
static const mask graph = (1 << 2) | (1 << 3) | (1 << 9); // alnum|punct
static const mask cntrl = 1 << 8;
static const mask punct = 1 << 9;
static const mask alnum = (1 << 2) | (1 << 3); // alpha|digit
};
#pragma empty_line
}
#pragma line 43 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/streambuf_iterator.h" 1 3
// Streambuf iterators
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file streambuf_iterator.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/streambuf_iterator.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @addtogroup iterators
* @{
*/
#pragma empty_line
// 24.5.3 Template class istreambuf_iterator
/// Provides input iterator semantics for streambufs.
template<typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*, _CharT&>
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
//@}
#pragma empty_line
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
#pragma empty_line
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
#pragma empty_line
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
#pragma empty_line
private:
// 24.5.3 istreambuf_iterator
// p 1
// If the end of stream is reached (streambuf_type::sgetc()
// returns traits_type::eof()), the iterator becomes equal to
// the "end of stream" iterator value.
// NB: This implementation assumes the "end of stream" value
// is EOF, or -1.
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
#pragma empty_line
public:
/// Construct end of input stream iterator.
istreambuf_iterator() throw()
: _M_sbuf(0), _M_c(traits_type::eof()) { }
#pragma empty_line
/// Construct start of input stream iterator.
istreambuf_iterator(istream_type& __s) throw()
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
#pragma empty_line
/// Construct start of streambuf iterator.
istreambuf_iterator(streambuf_type* __s) throw()
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
#pragma empty_line
/// Return the current character pointed to by iterator. This returns
/// streambuf.sgetc(). It cannot be assigned. NB: The result of
/// operator*() on an end of stream is undefined.
char_type
operator*() const
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return traits_type::to_char_type(_M_get());
}
#pragma empty_line
/// Advance the iterator. Calls streambuf.sbumpc().
istreambuf_iterator&
operator++()
{
#pragma empty_line
#pragma empty_line
;
if (_M_sbuf)
{
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
#pragma empty_line
/// Advance the iterator. Calls streambuf.sbumpc().
istreambuf_iterator
operator++(int)
{
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
istreambuf_iterator __old = *this;
if (_M_sbuf)
{
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 110 istreambuf_iterator::equal not const
// NB: there is also number 111 (NAD, Future) pending on this function.
/// Return true both iterators are end or both are not end.
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }
#pragma empty_line
private:
int_type
_M_get() const
{
const int_type __eof = traits_type::eof();
int_type __ret = __eof;
if (_M_sbuf)
{
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
__eof))
_M_c = __ret;
else
_M_sbuf = 0;
}
return __ret;
}
#pragma empty_line
bool
_M_at_eof() const
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
#pragma empty_line
template<typename _CharT, typename _Traits>
inline bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return __a.equal(__b); }
#pragma empty_line
template<typename _CharT, typename _Traits>
inline bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return !__a.equal(__b); }
#pragma empty_line
/// Provides output iterator semantics for streambufs.
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
//@}
#pragma empty_line
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
#pragma empty_line
private:
streambuf_type* _M_sbuf;
bool _M_failed;
#pragma empty_line
public:
/// Construct output iterator from ostream.
ostreambuf_iterator(ostream_type& __s) throw ()
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
#pragma empty_line
/// Construct output iterator from streambuf.
ostreambuf_iterator(streambuf_type* __s) throw ()
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
#pragma empty_line
/// Write character to streambuf. Calls streambuf.sputc().
ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
#pragma empty_line
/// Return *this.
ostreambuf_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Return *this.
ostreambuf_iterator&
operator++(int)
{ return *this; }
#pragma empty_line
/// Return *this.
ostreambuf_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Return true if previous operator=() failed.
bool
failed() const throw()
{ return _M_failed; }
#pragma empty_line
ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
};
#pragma empty_line
// Overloads for streambuf iterators.
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result)
{
if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
{
bool __ineof;
__copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
if (!__ineof)
__result._M_failed = true;
}
return __result;
}
#pragma empty_line
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT* __first, _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
#pragma empty_line
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT* __first, const _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
#pragma empty_line
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT* __result)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
#pragma empty_line
if (__first._M_sbuf && !__last._M_sbuf)
{
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof()))
{
const streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
traits_type::copy(__result, __sb->gptr(), __n);
__sb->gbump(__n);
__result += __n;
__c = __sb->underflow();
}
else
{
*__result++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
}
}
}
return __result;
}
#pragma empty_line
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, const _CharT& __val)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
#pragma empty_line
if (__first._M_sbuf && !__last._M_sbuf)
{
const int_type __ival = traits_type::to_int_type(__val);
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof())
&& !traits_type::eq_int_type(__c, __ival))
{
streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
const _CharT* __p = traits_type::find(__sb->gptr(),
__n, __val);
if (__p)
__n = __p - __sb->gptr();
__sb->gbump(__n);
__c = __sb->sgetc();
}
else
__c = __sb->snextc();
}
#pragma empty_line
if (!traits_type::eq_int_type(__c, traits_type::eof()))
__first._M_c = __c;
else
__first._M_sbuf = 0;
}
return __first;
}
#pragma empty_line
// @} group iterators
#pragma empty_line
}
#pragma line 50 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
// NB: Don't instantiate required wchar_t facets if no wchar_t support.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Convert string to numeric value of type _Tp and store results.
// NB: This is specialized for all required types, there is no
// generic definition.
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
// Explicit specializations for required types.
template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
// NB: __pad is a struct, rather than a function, so it can be
// partially-specialized.
template<typename _CharT, typename _Traits>
struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
};
#pragma empty_line
// Used by both numeric and monetary facets.
// Inserts "group separator" characters into an array of characters.
// It's recursive, one iteration per group. It moves the characters
// in the buffer this way: "xxxx12345" -> "12,345xxx". Call this
// only with __gsize != 0.
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);
#pragma empty_line
// This template permits specializing facet output code for
// ostreambuf_iterator. For ostreambuf_iterator, sputn is
// significantly more efficient than incrementing iterators.
template<typename _CharT>
inline
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
{
__s._M_put(__ws, __len);
return __s;
}
#pragma empty_line
// This is the unspecialized form of the template.
template<typename _CharT, typename _OutIter>
inline
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
{
for (int __j = 0; __j < __len; __j++, ++__s)
*__s = __ws[__j];
return __s;
}
#pragma empty_line
#pragma empty_line
// 22.2.1.1 Template class ctype
// Include host and configuration specific ctype enums for ctype_base.
#pragma empty_line
/**
* @brief Common base for ctype facet
*
* This template class provides implementations of the public functions
* that forward to the protected virtual functions.
*
* This template also provides abstract stubs for the protected virtual
* functions.
*/
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
// Types:
/// Typedef for the template parameter
typedef _CharT char_type;
#pragma empty_line
/**
* @brief Test char_type classification.
*
* This function finds a mask M for @a c and compares it to mask @a m.
* It does so by returning the value of ctype<char_type>::do_is().
*
* @param c The char_type to compare the mask of.
* @param m The mask to compare against.
* @return (M & m) != 0.
*/
bool
is(mask __m, char_type __c) const
{ return this->do_is(__m, __c); }
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each char_type in the range [lo,hi)
* and successively writes it to vec. vec must have as many elements
* as the char array. It does so by returning the value of
* ctype<char_type>::do_is().
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
{ return this->do_is(__lo, __hi, __vec); }
#pragma empty_line
/**
* @brief Find char_type matching a mask
*
* This function searches for and returns the first char_type c in
* [lo,hi) for which is(m,c) is true. It does so by returning
* ctype<char_type>::do_scan_is().
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to matching char_type if found, else @a hi.
*/
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_is(__m, __lo, __hi); }
#pragma empty_line
/**
* @brief Find char_type not matching a mask
*
* This function searches for and returns the first char_type c in
* [lo,hi) for which is(m,c) is false. It does so by returning
* ctype<char_type>::do_scan_not().
*
* @param m The mask to compare against.
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return Pointer to non-matching char if found, else @a hi.
*/
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_not(__m, __lo, __hi); }
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This function converts the argument to uppercase if possible.
* If not possible (for example, '2'), returns the argument. It does
* so by returning ctype<char_type>::do_toupper().
*
* @param c The char_type to convert.
* @return The uppercase char_type if convertible, else @a c.
*/
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This function converts each char_type in the range [lo,hi) to
* uppercase if possible. Other elements remain untouched. It does so
* by returning ctype<char_type>:: do_toupper(lo, hi).
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This function converts the argument to lowercase if possible. If
* not possible (for example, '2'), returns the argument. It does so
* by returning ctype<char_type>::do_tolower(c).
*
* @param c The char_type to convert.
* @return The lowercase char_type if convertible, else @a c.
*/
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This function converts each char_type in the range [lo,hi) to
* lowercase if possible. Other elements remain untouched. It does so
* by returning ctype<char_type>:: do_tolower(lo, hi).
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
#pragma empty_line
/**
* @brief Widen char to char_type
*
* This function converts the char argument to char_type using the
* simplest reasonable transformation. It does so by returning
* ctype<char_type>::do_widen(c).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted char_type.
*/
char_type
widen(char __c) const
{ return this->do_widen(__c); }
#pragma empty_line
/**
* @brief Widen array to char_type
*
* This function converts each char in the input to char_type using the
* simplest reasonable transformation. It does so by returning
* ctype<char_type>::do_widen(c).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{ return this->do_widen(__lo, __hi, __to); }
#pragma empty_line
/**
* @brief Narrow char_type to char
*
* This function converts the char_type to char using the simplest
* reasonable transformation. If the conversion fails, dfault is
* returned instead. It does so by returning
* ctype<char_type>::do_narrow(c).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char_type to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
char
narrow(char_type __c, char __dfault) const
{ return this->do_narrow(__c, __dfault); }
#pragma empty_line
/**
* @brief Narrow array to char array
*
* This function converts each char_type in the input to char using the
* simplest reasonable transformation and writes the results to the
* destination array. For any char_type in the input that cannot be
* converted, @a dfault is used instead. It does so by returning
* ctype<char_type>::do_narrow(lo, hi, dfault, to).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char *__to) const
{ return this->do_narrow(__lo, __hi, __dfault, __to); }
#pragma empty_line
protected:
explicit
__ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
#pragma empty_line
virtual
~__ctype_abstract_base() { }
#pragma empty_line
/**
* @brief Test char_type classification.
*
* This function finds a mask M for @a c and compares it to mask @a m.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param c The char_type to find the mask of.
* @param m The mask to compare against.
* @return (M & m) != 0.
*/
virtual bool
do_is(mask __m, char_type __c) const = 0;
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each char_type in the range [lo,hi)
* and successively writes it to vec. vec must have as many elements
* as the input.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
#pragma empty_line
/**
* @brief Find char_type matching mask
*
* This function searches for and returns the first char_type c in
* [lo,hi) for which is(m,c) is true.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a matching char_type if found, else @a hi.
*/
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Find char_type not matching mask
*
* This function searches for and returns a pointer to the first
* char_type c of [lo,hi) for which is(m,c) is false.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a non-matching char_type if found, else @a hi.
*/
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This virtual function converts the char_type argument to uppercase
* if possible. If not possible (for example, '2'), returns the
* argument.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param c The char_type to convert.
* @return The uppercase char_type if convertible, else @a c.
*/
virtual char_type
do_toupper(char_type) const = 0;
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This virtual function converts each char_type in the range [lo,hi)
* to uppercase if possible. Other elements remain untouched.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This virtual function converts the argument to lowercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param c The char_type to convert.
* @return The lowercase char_type if convertible, else @a c.
*/
virtual char_type
do_tolower(char_type) const = 0;
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This virtual function converts each char_type in the range [lo,hi)
* to lowercase if possible. Other elements remain untouched.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Widen char
*
* This virtual function converts the char to char_type using the
* simplest reasonable transformation.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted char_type
*/
virtual char_type
do_widen(char) const = 0;
#pragma empty_line
/**
* @brief Widen char array
*
* This function converts each char in the input to char_type using the
* simplest reasonable transformation.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char*
do_widen(const char* __lo, const char* __hi,
char_type* __dest) const = 0;
#pragma empty_line
/**
* @brief Narrow char_type to char
*
* This virtual function converts the argument to char using the
* simplest reasonable transformation. If the conversion fails, dfault
* is returned instead.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char_type to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
virtual char
do_narrow(char_type, char __dfault) const = 0;
#pragma empty_line
/**
* @brief Narrow char_type array to char
*
* This virtual function converts each char_type in the range [lo,hi) to
* char using the simplest reasonable transformation and writes the
* results to the destination array. For any element in the input that
* cannot be converted, @a dfault is used instead.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const = 0;
};
#pragma empty_line
/**
* @brief Primary class template ctype facet.
* @ingroup locales
*
* This template class defines classification and conversion functions for
* character sets. It wraps cctype functionality. Ctype gets used by
* streams for many I/O operations.
*
* This template provides the protected virtual functions the developer
* will have to replace in a derived class or specialization to make a
* working facet. The public functions that access them are defined in
* __ctype_abstract_base, to allow for implementation flexibility. See
* ctype<wchar_t> for an example. The functions are documented in
* __ctype_abstract_base.
*
* Note: implementations are provided for all the protected virtual
* functions, but will likely not be useful.
*/
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
public:
// Types:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
#pragma empty_line
/// The facet id for ctype<char_type>
static locale::id id;
#pragma empty_line
explicit
ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
#pragma empty_line
protected:
virtual
~ctype();
#pragma empty_line
virtual bool
do_is(mask __m, char_type __c) const;
#pragma empty_line
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
#pragma empty_line
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
#pragma empty_line
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
#pragma empty_line
virtual char_type
do_toupper(char_type __c) const;
#pragma empty_line
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
virtual char_type
do_tolower(char_type __c) const;
#pragma empty_line
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
virtual char_type
do_widen(char __c) const;
#pragma empty_line
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
#pragma empty_line
virtual char
do_narrow(char_type, char __dfault) const;
#pragma empty_line
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const;
};
#pragma empty_line
template<typename _CharT>
locale::id ctype<_CharT>::id;
#pragma empty_line
/**
* @brief The ctype<char> specialization.
* @ingroup locales
*
* This class defines classification and conversion functions for
* the char type. It gets used by char streams for many I/O
* operations. The char specialization provides a number of
* optimizations as well.
*/
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:
// Types:
/// Typedef for the template parameter char.
typedef char char_type;
#pragma empty_line
protected:
// Data Members:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask* _M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok; // 0 uninitialized, 1 init,
// 2 memcpy can't be used
#pragma empty_line
public:
/// The facet id for ctype<char>
static locale::id id;
/// The size of the mask table. It is SCHAR_MAX + 1.
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param table If non-zero, table is used as the per-char mask.
* Else classic_table() is used.
* @param del If true, passes ownership of table to this facet.
* @param refs Passed to the base facet class.
*/
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
#pragma empty_line
/**
* @brief Constructor performs static initialization.
*
* This constructor is used to construct the initial C locale facet.
*
* @param cloc Handle to C locale data.
* @param table If non-zero, table is used as the per-char mask.
* @param del If true, passes ownership of table to this facet.
* @param refs Passed to the base facet class.
*/
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
#pragma empty_line
/**
* @brief Test char classification.
*
* This function compares the mask table[c] to @a m.
*
* @param c The char to compare the mask of.
* @param m The mask to compare against.
* @return True if m & table[c] is true, false otherwise.
*/
inline bool
is(mask __m, char __c) const;
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each char in the range [lo, hi) and
* successively writes it to vec. vec must have as many elements as
* the char array.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
#pragma empty_line
/**
* @brief Find char matching a mask
*
* This function searches for and returns the first char in [lo,hi) for
* which is(m,char) is true.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a matching char if found, else @a hi.
*/
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
#pragma empty_line
/**
* @brief Find char not matching a mask
*
* This function searches for and returns a pointer to the first char
* in [lo,hi) for which is(m,char) is false.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a non-matching char if found, else @a hi.
*/
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This function converts the char argument to uppercase if possible.
* If not possible (for example, '2'), returns the argument.
*
* toupper() acts as if it returns ctype<char>::do_toupper(c).
* do_toupper() must always return the same result for the same input.
*
* @param c The char to convert.
* @return The uppercase char if convertible, else @a c.
*/
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This function converts each char in the range [lo,hi) to uppercase
* if possible. Other chars remain untouched.
*
* toupper() acts as if it returns ctype<char>:: do_toupper(lo, hi).
* do_toupper() must always return the same result for the same input.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This function converts the char argument to lowercase if possible.
* If not possible (for example, '2'), returns the argument.
*
* tolower() acts as if it returns ctype<char>::do_tolower(c).
* do_tolower() must always return the same result for the same input.
*
* @param c The char to convert.
* @return The lowercase char if convertible, else @a c.
*/
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This function converts each char in the range [lo,hi) to lowercase
* if possible. Other chars remain untouched.
*
* tolower() acts as if it returns ctype<char>:: do_tolower(lo, hi).
* do_tolower() must always return the same result for the same input.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
#pragma empty_line
/**
* @brief Widen char
*
* This function converts the char to char_type using the simplest
* reasonable transformation. For an underived ctype<char> facet, the
* argument will be returned unchanged.
*
* This function works as if it returns ctype<char>::do_widen(c).
* do_widen() must always return the same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted character.
*/
char_type
widen(char __c) const
{
if (_M_widen_ok)
return _M_widen[static_cast<unsigned char>(__c)];
this->_M_widen_init();
return this->do_widen(__c);
}
#pragma empty_line
/**
* @brief Widen char array
*
* This function converts each char in the input to char using the
* simplest reasonable transformation. For an underived ctype<char>
* facet, the argument will be copied unchanged.
*
* This function works as if it returns ctype<char>::do_widen(c).
* do_widen() must always return the same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{
if (_M_widen_ok == 1)
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_widen_ok)
_M_widen_init();
return this->do_widen(__lo, __hi, __to);
}
#pragma empty_line
/**
* @brief Narrow char
*
* This function converts the char to char using the simplest
* reasonable transformation. If the conversion fails, dfault is
* returned instead. For an underived ctype<char> facet, @a c
* will be returned unchanged.
*
* This function works as if it returns ctype<char>::do_narrow(c).
* do_narrow() must always return the same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @param dfault Char to return if conversion fails.
* @return The converted character.
*/
char
narrow(char_type __c, char __dfault) const
{
if (_M_narrow[static_cast<unsigned char>(__c)])
return _M_narrow[static_cast<unsigned char>(__c)];
const char __t = do_narrow(__c, __dfault);
if (__t != __dfault)
_M_narrow[static_cast<unsigned char>(__c)] = __t;
return __t;
}
#pragma empty_line
/**
* @brief Narrow char array
*
* This function converts each char in the input to char using the
* simplest reasonable transformation and writes the results to the
* destination array. For any char in the input that cannot be
* converted, @a dfault is used instead. For an underived ctype<char>
* facet, the argument will be copied unchanged.
*
* This function works as if it returns ctype<char>::do_narrow(lo, hi,
* dfault, to). do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char *__to) const
{
if (__builtin_expect(_M_narrow_ok == 1, true))
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_narrow_ok)
_M_narrow_init();
return this->do_narrow(__lo, __hi, __dfault, __to);
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 695. ctype<char>::classic_table() not accessible.
/// Returns a pointer to the mask table provided to the constructor, or
/// the default from classic_table() if none was provided.
const mask*
table() const throw()
{ return _M_table; }
#pragma empty_line
/// Returns a pointer to the C locale mask table.
static const mask*
classic_table() throw();
protected:
#pragma empty_line
/**
* @brief Destructor.
*
* This function deletes table() if @a del was true in the
* constructor.
*/
virtual
~ctype();
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This virtual function converts the char argument to uppercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param c The char to convert.
* @return The uppercase char if convertible, else @a c.
*/
virtual char_type
do_toupper(char_type) const;
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This virtual function converts each char in the range [lo,hi) to
* uppercase if possible. Other chars remain untouched.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This virtual function converts the char argument to lowercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param c The char to convert.
* @return The lowercase char if convertible, else @a c.
*/
virtual char_type
do_tolower(char_type) const;
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This virtual function converts each char in the range [lo,hi) to
* lowercase if possible. Other chars remain untouched.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Widen char
*
* This virtual function converts the char to char using the simplest
* reasonable transformation. For an underived ctype<char> facet, the
* argument will be returned unchanged.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted character.
*/
virtual char_type
do_widen(char __c) const
{ return __c; }
#pragma empty_line
/**
* @brief Widen char array
*
* This function converts each char in the range [lo,hi) to char using
* the simplest reasonable transformation. For an underived
* ctype<char> facet, the argument will be copied unchanged.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const
{
__builtin_memcpy(__dest, __lo, __hi - __lo);
return __hi;
}
#pragma empty_line
/**
* @brief Narrow char
*
* This virtual function converts the char to char using the simplest
* reasonable transformation. If the conversion fails, dfault is
* returned instead. For an underived ctype<char> facet, @a c will be
* returned unchanged.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
virtual char
do_narrow(char_type __c, char) const
{ return __c; }
#pragma empty_line
/**
* @brief Narrow char array to char array
*
* This virtual function converts each char in the range [lo,hi) to
* char using the simplest reasonable transformation and writes the
* results to the destination array. For any char in the input that
* cannot be converted, @a dfault is used instead. For an underived
* ctype<char> facet, the argument will be copied unchanged.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char, char* __dest) const
{
__builtin_memcpy(__dest, __lo, __hi - __lo);
return __hi;
}
#pragma empty_line
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
#pragma empty_line
#pragma empty_line
/**
* @brief The ctype<wchar_t> specialization.
* @ingroup locales
*
* This class defines classification and conversion functions for the
* wchar_t type. It gets used by wchar_t streams for many I/O operations.
* The wchar_t specialization provides a number of optimizations as well.
*
* ctype<wchar_t> inherits its public methods from
* __ctype_abstract_base<wchar_t>.
*/
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:
// Types:
/// Typedef for the template parameter wchar_t.
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
#pragma empty_line
protected:
__c_locale _M_c_locale_ctype;
#pragma empty_line
// Pre-computed narrowed and widened chars.
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
#pragma empty_line
// Pre-computed elements for do_is.
mask _M_bit[16];
__wmask_type _M_wmask[16];
#pragma empty_line
public:
// Data Members:
/// The facet id for ctype<wchar_t>
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
ctype(size_t __refs = 0);
#pragma empty_line
/**
* @brief Constructor performs static initialization.
*
* This constructor is used to construct the initial C locale facet.
*
* @param cloc Handle to C locale data.
* @param refs Passed to the base facet class.
*/
explicit
ctype(__c_locale __cloc, size_t __refs = 0);
#pragma empty_line
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
#pragma empty_line
/// Destructor
virtual
~ctype();
#pragma empty_line
/**
* @brief Test wchar_t classification.
*
* This function finds a mask M for @a c and compares it to mask @a m.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param c The wchar_t to find the mask of.
* @param m The mask to compare against.
* @return (M & m) != 0.
*/
virtual bool
do_is(mask __m, char_type __c) const;
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each wchar_t in the range [lo,hi)
* and successively writes it to vec. vec must have as many elements
* as the input.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
#pragma empty_line
/**
* @brief Find wchar_t matching mask
*
* This function searches for and returns the first wchar_t c in
* [lo,hi) for which is(m,c) is true.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a matching wchar_t if found, else @a hi.
*/
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Find wchar_t not matching mask
*
* This function searches for and returns a pointer to the first
* wchar_t c of [lo,hi) for which is(m,c) is false.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a non-matching wchar_t if found, else @a hi.
*/
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This virtual function converts the wchar_t argument to uppercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param c The wchar_t to convert.
* @return The uppercase wchar_t if convertible, else @a c.
*/
virtual char_type
do_toupper(char_type) const;
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This virtual function converts each wchar_t in the range [lo,hi) to
* uppercase if possible. Other elements remain untouched.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This virtual function converts the argument to lowercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param c The wchar_t to convert.
* @return The lowercase wchar_t if convertible, else @a c.
*/
virtual char_type
do_tolower(char_type) const;
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This virtual function converts each wchar_t in the range [lo,hi) to
* lowercase if possible. Other elements remain untouched.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Widen char to wchar_t
*
* This virtual function converts the char to wchar_t using the
* simplest reasonable transformation. For an underived ctype<wchar_t>
* facet, the argument will be cast to wchar_t.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted wchar_t.
*/
virtual char_type
do_widen(char) const;
#pragma empty_line
/**
* @brief Widen char array to wchar_t array
*
* This function converts each char in the input to wchar_t using the
* simplest reasonable transformation. For an underived ctype<wchar_t>
* facet, the argument will be copied, casting each element to wchar_t.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
#pragma empty_line
/**
* @brief Narrow wchar_t to char
*
* This virtual function converts the argument to char using
* the simplest reasonable transformation. If the conversion
* fails, dfault is returned instead. For an underived
* ctype<wchar_t> facet, @a c will be cast to char and
* returned.
*
* do_narrow() is a hook for a derived facet to change the
* behavior of narrowing. do_narrow() must always return the
* same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The wchar_t to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
virtual char
do_narrow(char_type, char __dfault) const;
#pragma empty_line
/**
* @brief Narrow wchar_t array to char array
*
* This virtual function converts each wchar_t in the range [lo,hi) to
* char using the simplest reasonable transformation and writes the
* results to the destination array. For any wchar_t in the input that
* cannot be converted, @a dfault is used instead. For an underived
* ctype<wchar_t> facet, the argument will be copied, casting each
* element to char.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const;
#pragma empty_line
// For use at construction time only.
void
_M_initialize_ctype() throw();
};
#pragma empty_line
#pragma empty_line
/// class ctype_byname [22.2.1.2].
template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;
#pragma empty_line
explicit
ctype_byname(const char* __s, size_t __refs = 0);
#pragma empty_line
protected:
virtual
~ctype_byname() { };
};
#pragma empty_line
/// 22.2.1.4 Class ctype_byname specializations.
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
#pragma empty_line
protected:
virtual
~ctype_byname();
};
#pragma empty_line
#pragma empty_line
template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
#pragma empty_line
protected:
virtual
~ctype_byname();
};
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
// Include host and configuration specific ctype inlines.
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2/x86_64-w64-mingw32\\bits/ctype_inline.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2000, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ctype_inline.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
#pragma empty_line
namespace std {
#pragma empty_line
bool
ctype<char>::
is(mask __m, char __c) const
{ return (_M_table[static_cast<unsigned char>(__c) ] & __m); }
#pragma empty_line
#pragma empty_line
const char*
ctype<char>::
is(const char* __low, const char* __high, mask* __vec) const
{
while (__low < __high)
*__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
return __high;
}
#pragma empty_line
const char*
ctype<char>::
scan_is(mask __m, const char* __low, const char* __high) const
{
while (__low < __high && !this->is(__m, *__low))
++__low;
return __low;
}
#pragma empty_line
const char*
ctype<char>::
scan_not(mask __m, const char* __low, const char* __high) const
{
while (__low < __high && this->is(__m, *__low) != 0)
++__low;
return __low;
}
#pragma empty_line
}
#pragma line 1509 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
// 22.2.2 The numeric category.
class __num_base
{
public:
// NB: Code depends on the order of _S_atoms_out elements.
// Below are the indices into _S_atoms_out.
enum
{
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14, // For scientific notation, 'e'
_S_oE = _S_oudigits + 14, // For scientific notation, 'E'
_S_oend = _S_oudigits_end
};
#pragma empty_line
// A list of valid numeric literals for output. This array
// contains chars that will be passed through the current locale's
// ctype<_CharT>.widen() and then used to render numbers.
// For the standard "C" locale, this is
// "-+xX0123456789abcdef0123456789ABCDEF".
static const char* _S_atoms_out;
#pragma empty_line
// String literal of acceptable (narrow) input, for num_get.
// "-+xX0123456789abcdefABCDEF"
static const char* _S_atoms_in;
#pragma empty_line
enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
#pragma empty_line
// num_put
// Construct and return valid scanf format for floating point types.
static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};
#pragma empty_line
template<typename _CharT>
struct __numpunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT* _M_truename;
size_t _M_truename_size;
const _CharT* _M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
#pragma empty_line
// A list of valid numeric literals for output: in the standard
// "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
// This array contains the chars after having been passed
// through the current locale's ctype<_CharT>.widen().
_CharT _M_atoms_out[__num_base::_S_oend];
#pragma empty_line
// A list of valid numeric literals for input: in the standard
// "C" locale, this is "-+xX0123456789abcdefABCDEF"
// This array contains the chars after having been passed
// through the current locale's ctype<_CharT>.widen().
_CharT _M_atoms_in[__num_base::_S_iend];
#pragma empty_line
bool _M_allocated;
#pragma empty_line
__numpunct_cache(size_t __refs = 0) : facet(__refs),
_M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
_M_truename(__null), _M_truename_size(0), _M_falsename(__null),
_M_falsename_size(0), _M_decimal_point(_CharT()),
_M_thousands_sep(_CharT()), _M_allocated(false)
{ }
#pragma empty_line
~__numpunct_cache();
#pragma empty_line
void
_M_cache(const locale& __loc);
#pragma empty_line
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
#pragma empty_line
explicit
__numpunct_cache(const __numpunct_cache&);
};
#pragma empty_line
template<typename _CharT>
__numpunct_cache<_CharT>::~__numpunct_cache()
{
if (_M_allocated)
{
delete [] _M_grouping;
delete [] _M_truename;
delete [] _M_falsename;
}
}
#pragma empty_line
/**
* @brief Primary class template numpunct.
* @ingroup locales
*
* This facet stores several pieces of information related to printing and
* scanning numbers, such as the decimal point character. It takes a
* template parameter specifying the char type. The numpunct facet is
* used by streams for many I/O operations involving numbers.
*
* The numpunct template uses protected virtual functions to provide the
* actual results. The public accessors forward the call to the virtual
* functions. These virtual functions are hooks for developers to
* implement the behavior they require from a numpunct facet.
*/
template<typename _CharT>
class numpunct : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
//@}
typedef __numpunct_cache<_CharT> __cache_type;
#pragma empty_line
protected:
__cache_type* _M_data;
#pragma empty_line
public:
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Numpunct constructor.
*
* @param refs Refcount to pass to the base class.
*/
explicit
numpunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
{ _M_initialize_numpunct(); }
#pragma empty_line
/**
* @brief Internal constructor. Not for general use.
*
* This is a constructor for use by the library itself to set up the
* predefined locale facets.
*
* @param cache __numpunct_cache object.
* @param refs Refcount to pass to the base class.
*/
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_numpunct(); }
#pragma empty_line
/**
* @brief Internal constructor. Not for general use.
*
* This is a constructor for use by the library itself to set up new
* locales.
*
* @param cloc The C locale.
* @param refs Refcount to pass to the base class.
*/
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_data(__null)
{ _M_initialize_numpunct(__cloc); }
#pragma empty_line
/**
* @brief Return decimal point character.
*
* This function returns a char_type to use as a decimal point. It
* does so by returning returning
* numpunct<char_type>::do_decimal_point().
*
* @return @a char_type representing a decimal point.
*/
char_type
decimal_point() const
{ return this->do_decimal_point(); }
#pragma empty_line
/**
* @brief Return thousands separator character.
*
* This function returns a char_type to use as a thousands
* separator. It does so by returning returning
* numpunct<char_type>::do_thousands_sep().
*
* @return char_type representing a thousands separator.
*/
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
#pragma empty_line
/**
* @brief Return grouping specification.
*
* This function returns a string representing groupings for the
* integer part of a number. Groupings indicate where thousands
* separators should be inserted in the integer part of a number.
*
* Each char in the return string is interpret as an integer
* rather than a character. These numbers represent the number
* of digits in a group. The first char in the string
* represents the number of digits in the least significant
* group. If a char is negative, it indicates an unlimited
* number of digits for the group. If more chars from the
* string are required to group a number, the last char is used
* repeatedly.
*
* For example, if the grouping() returns "\003\002" and is
* applied to the number 123456789, this corresponds to
* 12,34,56,789. Note that if the string was "32", this would
* put more than 50 digits into the least significant group if
* the character set is ASCII.
*
* The string is returned by calling
* numpunct<char_type>::do_grouping().
*
* @return string representing grouping specification.
*/
string
grouping() const
{ return this->do_grouping(); }
#pragma empty_line
/**
* @brief Return string representation of bool true.
*
* This function returns a string_type containing the text
* representation for true bool variables. It does so by calling
* numpunct<char_type>::do_truename().
*
* @return string_type representing printed form of true.
*/
string_type
truename() const
{ return this->do_truename(); }
#pragma empty_line
/**
* @brief Return string representation of bool false.
*
* This function returns a string_type containing the text
* representation for false bool variables. It does so by calling
* numpunct<char_type>::do_falsename().
*
* @return string_type representing printed form of false.
*/
string_type
falsename() const
{ return this->do_falsename(); }
#pragma empty_line
protected:
/// Destructor.
virtual
~numpunct();
#pragma empty_line
/**
* @brief Return decimal point character.
*
* Returns a char_type to use as a decimal point. This function is a
* hook for derived classes to change the value returned.
*
* @return @a char_type representing a decimal point.
*/
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
#pragma empty_line
/**
* @brief Return thousands separator character.
*
* Returns a char_type to use as a thousands separator. This function
* is a hook for derived classes to change the value returned.
*
* @return @a char_type representing a thousands separator.
*/
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
#pragma empty_line
/**
* @brief Return grouping specification.
*
* Returns a string representing groupings for the integer part of a
* number. This function is a hook for derived classes to change the
* value returned. @see grouping() for details.
*
* @return String representing grouping specification.
*/
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
#pragma empty_line
/**
* @brief Return string representation of bool true.
*
* Returns a string_type containing the text representation for true
* bool variables. This function is a hook for derived classes to
* change the value returned.
*
* @return string_type representing printed form of true.
*/
virtual string_type
do_truename() const
{ return _M_data->_M_truename; }
#pragma empty_line
/**
* @brief Return string representation of bool false.
*
* Returns a string_type containing the text representation for false
* bool variables. This function is a hook for derived classes to
* change the value returned.
*
* @return string_type representing printed form of false.
*/
virtual string_type
do_falsename() const
{ return _M_data->_M_falsename; }
#pragma empty_line
// For use at construction time only.
void
_M_initialize_numpunct(__c_locale __cloc = __null);
};
#pragma empty_line
template<typename _CharT>
locale::id numpunct<_CharT>::id;
#pragma empty_line
template<>
numpunct<char>::~numpunct();
#pragma empty_line
template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
#pragma empty_line
#pragma empty_line
template<>
numpunct<wchar_t>::~numpunct();
#pragma empty_line
template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
#pragma empty_line
#pragma empty_line
/// class numpunct_byname [22.2.3.2].
template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
explicit
numpunct_byname(const char* __s, size_t __refs = 0)
: numpunct<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
__c_locale __tmp;
this->_S_create_c_locale(__tmp, __s);
this->_M_initialize_numpunct(__tmp);
this->_S_destroy_c_locale(__tmp);
}
}
#pragma empty_line
protected:
virtual
~numpunct_byname() { }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/**
* @brief Primary class template num_get.
* @ingroup locales
*
* This facet encapsulates the code to parse and return a number
* from a string. It is used by the istream numeric extraction
* operators.
*
* The num_get template uses protected virtual functions to provide the
* actual results. The public accessors forward the call to the virtual
* functions. These virtual functions are hooks for developers to
* implement the behavior they require from the num_get facet.
*/
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef _InIter iter_type;
//@}
#pragma empty_line
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
num_get(size_t __refs = 0) : facet(__refs) { }
#pragma empty_line
/**
* @brief Numeric parsing.
*
* Parses the input stream into the bool @a v. It does so by calling
* num_get::do_get().
*
* If ios_base::boolalpha is set, attempts to read
* ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets
* @a v to true or false if successful. Sets err to
* ios_base::failbit if reading the string fails. Sets err to
* ios_base::eofbit if the stream is emptied.
*
* If ios_base::boolalpha is not set, proceeds as with reading a long,
* except if the value is 1, sets @a v to true, if the value is 0, sets
* @a v to false, and otherwise set err to ios_base::failbit.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
//@{
/**
* @brief Numeric parsing.
*
* Parses the input stream into the integral variable @a v. It does so
* by calling num_get::do_get().
*
* Parsing is affected by the flag settings in @a io.
*
* The basic parse is affected by the value of io.flags() &
* ios_base::basefield. If equal to ios_base::oct, parses like the
* scanf %o specifier. Else if equal to ios_base::hex, parses like %X
* specifier. Else if basefield equal to 0, parses like the %i
* specifier. Otherwise, parses like %d for signed and %u for unsigned
* types. The matching type length modifier is also used.
*
* Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
* If parsing the string yields a valid value for @a v, @a v is set.
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
#pragma empty_line
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
//@}
#pragma empty_line
//@{
/**
* @brief Numeric parsing.
*
* Parses the input stream into the integral variable @a v. It does so
* by calling num_get::do_get().
*
* The input characters are parsed like the scanf %g specifier. The
* matching type length modifier is also used.
*
* The decimal point character used is numpunct::decimal_point().
* Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
* If parsing the string yields a valid value for @a v, @a v is set.
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
//@}
#pragma empty_line
/**
* @brief Numeric parsing.
*
* Parses the input stream into the pointer variable @a v. It does so
* by calling num_get::do_get().
*
* The input characters are parsed like the scanf %p specifier.
*
* Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
* Note that the digit grouping effect for pointers is a bit ambiguous
* in the standard and shouldn't be relied on. See DR 344.
*
* If parsing the string yields a valid value for @a v, @a v is set.
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#pragma empty_line
protected:
/// Destructor.
virtual ~num_get() { }
#pragma empty_line
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
#pragma empty_line
template<typename _ValueT>
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;
#pragma empty_line
template<typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
{
int __ret = -1;
if (__len <= 10)
{
if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
__ret = __c - _CharT2('0');
}
else
{
if (__c >= _CharT2('0') && __c <= _CharT2('9'))
__ret = __c - _CharT2('0');
else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
__ret = 10 + (__c - _CharT2('a'));
else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
__ret = 10 + (__c - _CharT2('A'));
}
return __ret;
}
#pragma empty_line
template<typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
int>::__type
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
{
int __ret = -1;
const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
if (__q)
{
__ret = __q - __zero;
if (__ret > 15)
__ret -= 6;
}
return __ret;
}
#pragma empty_line
//@{
/**
* @brief Numeric parsing.
*
* Parses the input stream into the variable @a v. This function is a
* hook for derived classes to change the value returned. @see get()
* for more details.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
#pragma empty_line
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
#pragma empty_line
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
#pragma empty_line
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
#pragma empty_line
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
#pragma empty_line
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
float&) const;
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
double&) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
long double&) const;
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
void*&) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
//@}
};
#pragma empty_line
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
#pragma empty_line
#pragma empty_line
/**
* @brief Primary class template num_put.
* @ingroup locales
*
* This facet encapsulates the code to convert a number to a string. It is
* used by the ostream numeric insertion operators.
*
* The num_put template uses protected virtual functions to provide the
* actual results. The public accessors forward the call to the virtual
* functions. These virtual functions are hooks for developers to
* implement the behavior they require from the num_put facet.
*/
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef _OutIter iter_type;
//@}
#pragma empty_line
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
num_put(size_t __refs = 0) : facet(__refs) { }
#pragma empty_line
/**
* @brief Numeric formatting.
*
* Formats the boolean @a v and inserts it into a stream. It does so
* by calling num_put::do_put().
*
* If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
* ctype<CharT>::falsename(). Otherwise formats @a v as an int.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
//@{
/**
* @brief Numeric formatting.
*
* Formats the integral value @a v and inserts it into a
* stream. It does so by calling num_put::do_put().
*
* Formatting is affected by the flag settings in @a io.
*
* The basic format is affected by the value of io.flags() &
* ios_base::basefield. If equal to ios_base::oct, formats like the
* printf %o specifier. Else if equal to ios_base::hex, formats like
* %x or %X with ios_base::uppercase unset or set respectively.
* Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
* for unsigned values. Note that if both oct and hex are set, neither
* will take effect.
*
* If ios_base::showpos is set, '+' is output before positive values.
* If ios_base::showbase is set, '0' precedes octal values (except 0)
* and '0[xX]' precedes hex values.
*
* Thousands separators are inserted according to numpunct::grouping()
* and numpunct::thousands_sep(). The decimal point character used is
* numpunct::decimal_point().
*
* If io.width() is non-zero, enough @a fill characters are inserted to
* make the result at least that wide. If
* (io.flags() & ios_base::adjustfield) == ios_base::left, result is
* padded at the end. If ios_base::internal, then padding occurs
* immediately after either a '+' or '-' or after '0x' or '0X'.
* Otherwise, padding occurs at the beginning.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
unsigned long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
unsigned long long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
//@}
#pragma empty_line
//@{
/**
* @brief Numeric formatting.
*
* Formats the floating point value @a v and inserts it into a stream.
* It does so by calling num_put::do_put().
*
* Formatting is affected by the flag settings in @a io.
*
* The basic format is affected by the value of io.flags() &
* ios_base::floatfield. If equal to ios_base::fixed, formats like the
* printf %f specifier. Else if equal to ios_base::scientific, formats
* like %e or %E with ios_base::uppercase unset or set respectively.
* Otherwise, formats like %g or %G depending on uppercase. Note that
* if both fixed and scientific are set, the effect will also be like
* %g or %G.
*
* The output precision is given by io.precision(). This precision is
* capped at numeric_limits::digits10 + 2 (different for double and
* long double). The default precision is 6.
*
* If ios_base::showpos is set, '+' is output before positive values.
* If ios_base::showpoint is set, a decimal point will always be
* output.
*
* Thousands separators are inserted according to numpunct::grouping()
* and numpunct::thousands_sep(). The decimal point character used is
* numpunct::decimal_point().
*
* If io.width() is non-zero, enough @a fill characters are inserted to
* make the result at least that wide. If
* (io.flags() & ios_base::adjustfield) == ios_base::left, result is
* padded at the end. If ios_base::internal, then padding occurs
* immediately after either a '+' or '-' or after '0x' or '0X'.
* Otherwise, padding occurs at the beginning.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
long double __v) const
{ return this->do_put(__s, __f, __fill, __v); }
//@}
#pragma empty_line
/**
* @brief Numeric formatting.
*
* Formats the pointer value @a v and inserts it into a stream. It
* does so by calling num_put::do_put().
*
* This function formats @a v as an unsigned long with ios_base::hex
* and ios_base::showbase set.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
const void* __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;
#pragma empty_line
void
_M_group_float(const char* __grouping, size_t __grouping_size,
char_type __sep, const char_type* __p, char_type* __new,
char_type* __cs, int& __len) const;
#pragma empty_line
template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;
#pragma empty_line
void
_M_group_int(const char* __grouping, size_t __grouping_size,
char_type __sep, ios_base& __io, char_type* __new,
char_type* __cs, int& __len) const;
#pragma empty_line
void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;
#pragma empty_line
/// Destructor.
virtual
~num_put() { };
#pragma empty_line
//@{
/**
* @brief Numeric formatting.
*
* These functions do the work of formatting numeric values and
* inserting them into a stream. This function is a hook for derived
* classes to change the value returned.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
#pragma empty_line
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
#pragma empty_line
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
#pragma empty_line
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, double __v) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
//@}
};
#pragma empty_line
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Subclause convenience interfaces, inlines.
// NB: These are inline because, when used in a loop, some compilers
// can hoist the body out of the loop; then it's just as fast as the
// C is*() function.
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::space, __c).
template<typename _CharT>
inline bool
isspace(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::print, __c).
template<typename _CharT>
inline bool
isprint(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::cntrl, __c).
template<typename _CharT>
inline bool
iscntrl(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::upper, __c).
template<typename _CharT>
inline bool
isupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::lower, __c).
template<typename _CharT>
inline bool
islower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::alpha, __c).
template<typename _CharT>
inline bool
isalpha(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::digit, __c).
template<typename _CharT>
inline bool
isdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::punct, __c).
template<typename _CharT>
inline bool
ispunct(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::xdigit, __c).
template<typename _CharT>
inline bool
isxdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::alnum, __c).
template<typename _CharT>
inline bool
isalnum(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::graph, __c).
template<typename _CharT>
inline bool
isgraph(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
#pragma empty_line
/// Convenience interface to ctype.toupper(__c).
template<typename _CharT>
inline _CharT
toupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
#pragma empty_line
/// Convenience interface to ctype.tolower(__c).
template<typename _CharT>
inline _CharT
tolower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.tcc" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file locale_facets.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.tcc" 3
#pragma empty_line
namespace std {
#pragma empty_line
// Routine to access a cache for the facet. If the cache didn't
// exist before, it gets constructed on the fly.
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
#pragma empty_line
// Specializations.
template<typename _CharT>
struct __use_cache<__numpunct_cache<_CharT> >
{
const __numpunct_cache<_CharT>*
operator() (const locale& __loc) const
{
const size_t __i = numpunct<_CharT>::id._M_id();
const locale::facet** __caches = __loc._M_impl->_M_caches;
if (!__caches[__i])
{
__numpunct_cache<_CharT>* __tmp = __null;
if (true)
{
__tmp = new __numpunct_cache<_CharT>;
__tmp->_M_cache(__loc);
}
if (false)
{
delete __tmp;
;
}
__loc._M_impl->_M_install_cache(__tmp, __i);
}
return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
}
};
#pragma empty_line
template<typename _CharT>
void
__numpunct_cache<_CharT>::_M_cache(const locale& __loc)
{
_M_allocated = true;
#pragma empty_line
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
#pragma empty_line
char* __grouping = 0;
_CharT* __truename = 0;
_CharT* __falsename = 0;
if (true)
{
_M_grouping_size = __np.grouping().size();
__grouping = new char[_M_grouping_size];
__np.grouping().copy(__grouping, _M_grouping_size);
_M_grouping = __grouping;
_M_use_grouping = (_M_grouping_size
&& static_cast<signed char>(_M_grouping[0]) > 0
&& (_M_grouping[0]
!= __gnu_cxx::__numeric_traits<char>::__max));
#pragma empty_line
_M_truename_size = __np.truename().size();
__truename = new _CharT[_M_truename_size];
__np.truename().copy(__truename, _M_truename_size);
_M_truename = __truename;
#pragma empty_line
_M_falsename_size = __np.falsename().size();
__falsename = new _CharT[_M_falsename_size];
__np.falsename().copy(__falsename, _M_falsename_size);
_M_falsename = __falsename;
#pragma empty_line
_M_decimal_point = __np.decimal_point();
_M_thousands_sep = __np.thousands_sep();
#pragma empty_line
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
__ct.widen(__num_base::_S_atoms_out,
__num_base::_S_atoms_out
+ __num_base::_S_oend, _M_atoms_out);
__ct.widen(__num_base::_S_atoms_in,
__num_base::_S_atoms_in
+ __num_base::_S_iend, _M_atoms_in);
}
if (false)
{
delete [] __grouping;
delete [] __truename;
delete [] __falsename;
;
}
}
#pragma empty_line
// Used by both numeric and monetary facets.
// Check to make sure that the __grouping_tmp string constructed in
// money_get or num_get matches the canonical grouping for a given
// locale.
// __grouping_tmp is parsed L to R
// 1,222,444 == __grouping_tmp of "\1\3\3"
// __grouping is parsed R to L
// 1,222,444 == __grouping of "\3" == "\3\3\3"
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
_M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, string& __xtrc) const
{
typedef char_traits<_CharT> __traits_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();
#pragma empty_line
// True if __beg becomes equal to __end.
bool __testeof = __beg == __end;
#pragma empty_line
// First check for sign.
if (!__testeof)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
__xtrc += __plus ? '+' : '-';
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
#pragma empty_line
// Next, look for leading zeros.
bool __found_mantissa = false;
int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero])
{
if (!__found_mantissa)
{
__xtrc += '0';
__found_mantissa = true;
}
++__sep_pos;
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
break;
}
#pragma empty_line
// Only need acceptable digits for floating point numbers.
bool __found_dec = false;
bool __found_sci = false;
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
const char_type* __lit_zero = __lit + __num_base::_S_izero;
#pragma empty_line
if (!__lc->_M_allocated)
// "C" locale
while (!__testeof)
{
const int __digit = _M_find(__lit_zero, 10, __c);
if (__digit != -1)
{
__xtrc += '0' + __digit;
__found_mantissa = true;
}
else if (__c == __lc->_M_decimal_point
&& !__found_dec && !__found_sci)
{
__xtrc += '.';
__found_dec = true;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{
// Scientific notation.
__xtrc += 'e';
__found_sci = true;
#pragma empty_line
// Remove optional plus or minus sign, if they exist.
if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if (__plus || __c == __lit[__num_base::_S_iminus])
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
// According to 22.2.2.1.2, p8-9, first look for thousands_sep
// and decimal_point.
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
if (!__found_dec && !__found_sci)
{
// NB: Thousands separator at the beginning of a string
// is a no-no, as is two consecutive thousands separators.
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
// NB: __convert_to_v will not assign __v and will
// set the failbit.
__xtrc.clear();
break;
}
}
else
break;
}
else if (__c == __lc->_M_decimal_point)
{
if (!__found_dec && !__found_sci)
{
// If no grouping chars are seen, no grouping check
// is applied. Therefore __found_grouping is adjusted
// only if decimal_point comes after some thousands_sep.
if (__found_grouping.size())
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += '.';
__found_dec = true;
}
else
break;
}
else
{
const char_type* __q =
__traits_type::find(__lit_zero, 10, __c);
if (__q)
{
__xtrc += '0' + (__q - __lit_zero);
__found_mantissa = true;
++__sep_pos;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{
// Scientific notation.
if (__found_grouping.size() && !__found_dec)
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += 'e';
__found_sci = true;
#pragma empty_line
// Remove optional plus or minus sign, if they exist.
if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping
&& __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
}
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
#pragma empty_line
// Digit grouping is checked. If grouping and found_grouping don't
// match, then get very very upset, and set failbit.
if (__found_grouping.size())
{
// Add the ending grouping if a decimal or 'e'/'E' wasn't found.
if (!__found_dec && !__found_sci)
__found_grouping += static_cast<char>(__sep_pos);
#pragma empty_line
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
#pragma empty_line
return __beg;
}
#pragma empty_line
template<typename _CharT, typename _InIter>
template<typename _ValueT>
_InIter
num_get<_CharT, _InIter>::
_M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, _ValueT& __v) const
{
typedef char_traits<_CharT> __traits_type;
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();
#pragma empty_line
// NB: Iff __basefield == 0, __base can change based on contents.
const ios_base::fmtflags __basefield = __io.flags()
& ios_base::basefield;
const bool __oct = __basefield == ios_base::oct;
int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
#pragma empty_line
// True if __beg becomes equal to __end.
bool __testeof = __beg == __end;
#pragma empty_line
// First check for sign.
bool __negative = false;
if (!__testeof)
{
__c = *__beg;
__negative = __c == __lit[__num_base::_S_iminus];
if ((__negative || __c == __lit[__num_base::_S_iplus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
#pragma empty_line
// Next, look for leading zeros and check required digits
// for base formats.
bool __found_zero = false;
int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero]
&& (!__found_zero || __base == 10))
{
__found_zero = true;
++__sep_pos;
if (__basefield == 0)
__base = 8;
if (__base == 8)
__sep_pos = 0;
}
else if (__found_zero
&& (__c == __lit[__num_base::_S_ix]
|| __c == __lit[__num_base::_S_iX]))
{
if (__basefield == 0)
__base = 16;
if (__base == 16)
{
__found_zero = false;
__sep_pos = 0;
}
else
break;
}
else
break;
#pragma empty_line
if (++__beg != __end)
{
__c = *__beg;
if (!__found_zero)
break;
}
else
__testeof = true;
}
#pragma empty_line
// At this point, base is determined. If not hex, only allow
// base digits as valid input.
const size_t __len = (__base == 16 ? __num_base::_S_iend
- __num_base::_S_izero : __base);
#pragma empty_line
// Extract.
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
bool __testfail = false;
bool __testoverflow = false;
const __unsigned_type __max =
(__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
? -__gnu_cxx::__numeric_traits<_ValueT>::__min
: __gnu_cxx::__numeric_traits<_ValueT>::__max;
const __unsigned_type __smax = __max / __base;
__unsigned_type __result = 0;
int __digit = 0;
const char_type* __lit_zero = __lit + __num_base::_S_izero;
#pragma empty_line
if (!__lc->_M_allocated)
// "C" locale
while (!__testeof)
{
__digit = _M_find(__lit_zero, __len, __c);
if (__digit == -1)
break;
#pragma empty_line
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
// According to 22.2.2.1.2, p8-9, first look for thousands_sep
// and decimal_point.
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
// NB: Thousands separator at the beginning of a string
// is a no-no, as is two consecutive thousands separators.
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
__testfail = true;
break;
}
}
else if (__c == __lc->_M_decimal_point)
break;
else
{
const char_type* __q =
__traits_type::find(__lit_zero, __len, __c);
if (!__q)
break;
#pragma empty_line
__digit = __q - __lit_zero;
if (__digit > 15)
__digit -= 6;
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
}
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
#pragma empty_line
// Digit grouping is checked. If grouping and found_grouping don't
// match, then get very very upset, and set failbit.
if (__found_grouping.size())
{
// Add the ending grouping.
__found_grouping += static_cast<char>(__sep_pos);
#pragma empty_line
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 23. Num_get overflow result.
if ((!__sep_pos && !__found_zero && !__found_grouping.size())
|| __testfail)
{
__v = 0;
__err = ios_base::failbit;
}
else if (__testoverflow)
{
if (__negative
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
__v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
else
__v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
__err = ios_base::failbit;
}
else
__v = __negative ? -__result : __result;
#pragma empty_line
if (__testeof)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 17. Bad bool parsing
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{
if (!(__io.flags() & ios_base::boolalpha))
{
// Parse bool values as long.
// NB: We can't just call do_get(long) here, as it might
// refer to a derived class.
long __l = -1;
__beg = _M_extract_int(__beg, __end, __io, __err, __l);
if (__l == 0 || __l == 1)
__v = bool(__l);
else
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 23. Num_get overflow result.
__v = true;
__err = ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
}
}
else
{
// Parse bool values as alphanumeric.
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
#pragma empty_line
bool __testf = true;
bool __testt = true;
bool __donef = __lc->_M_falsename_size == 0;
bool __donet = __lc->_M_truename_size == 0;
bool __testeof = false;
size_t __n = 0;
while (!__donef || !__donet)
{
if (__beg == __end)
{
__testeof = true;
break;
}
#pragma empty_line
const char_type __c = *__beg;
#pragma empty_line
if (!__donef)
__testf = __c == __lc->_M_falsename[__n];
#pragma empty_line
if (!__testf && __donet)
break;
#pragma empty_line
if (!__donet)
__testt = __c == __lc->_M_truename[__n];
#pragma empty_line
if (!__testt && __donef)
break;
#pragma empty_line
if (!__testt && !__testf)
break;
#pragma empty_line
++__n;
++__beg;
#pragma empty_line
__donef = !__testf || __n >= __lc->_M_falsename_size;
__donet = !__testt || __n >= __lc->_M_truename_size;
}
if (__testf && __n == __lc->_M_falsename_size && __n)
{
__v = false;
if (__testt && __n == __lc->_M_truename_size)
__err = ios_base::failbit;
else
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
}
else if (__testt && __n == __lc->_M_truename_size && __n)
{
__v = true;
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
}
else
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 23. Num_get overflow result.
__v = false;
__err = ios_base::failbit;
if (__testeof)
__err |= ios_base::eofbit;
}
}
return __beg;
}
#pragma empty_line
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma line 729 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.tcc" 3
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{
// Prepare for hex formatted input.
typedef ios_base::fmtflags fmtflags;
const fmtflags __fmt = __io.flags();
__io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
#pragma empty_line
typedef __gnu_cxx::__conditional_type<(sizeof(void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
#pragma empty_line
_UIntPtrType __ul;
__beg = _M_extract_int(__beg, __end, __io, __err, __ul);
#pragma empty_line
// Reset from hex formatted input.
__io.flags(__fmt);
#pragma empty_line
__v = reinterpret_cast<void*>(__ul);
return __beg;
}
#pragma empty_line
// For use by integer and floating-point types after they have been
// converted into a char_type string.
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_pad(_CharT __fill, streamsize __w, ios_base& __io,
_CharT* __new, const _CharT* __cs, int& __len) const
{
// [22.2.2.2.2] Stage 3.
// If necessary, pad.
__pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
__cs, __w, __len);
__len = static_cast<int>(__w);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _ValueT>
int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
{
_CharT* __buf = __bufend;
if (__builtin_expect(__dec, true))
{
// Decimal.
do
{
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
__v /= 10;
}
while (__v != 0);
}
else if ((__flags & ios_base::basefield) == ios_base::oct)
{
// Octal.
do
{
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
__v >>= 3;
}
while (__v != 0);
}
else
{
// Hex.
const bool __uppercase = __flags & ios_base::uppercase;
const int __case_offset = __uppercase ? __num_base::_S_oudigits
: __num_base::_S_odigits;
do
{
*--__buf = __lit[(__v & 0xf) + __case_offset];
__v >>= 4;
}
while (__v != 0);
}
return __bufend - __buf;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
{
_CharT* __p = std::__add_grouping(__new, __sep, __grouping,
__grouping_size, __cs, __cs + __len);
__len = __p - __new;
}
#pragma empty_line
template<typename _CharT, typename _OutIter>
template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
_ValueT __v) const
{
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_out;
const ios_base::fmtflags __flags = __io.flags();
#pragma empty_line
// Long enough to hold hex, dec, and octal representations.
const int __ilen = 5 * sizeof(_ValueT);
_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __ilen));
#pragma empty_line
// [22.2.2.2.2] Stage 1, numeric conversion to character.
// Result is returned right-justified in the buffer.
const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
const bool __dec = (__basefield != ios_base::oct
&& __basefield != ios_base::hex);
const __unsigned_type __u = ((__v > 0 || !__dec)
? __unsigned_type(__v)
: -__unsigned_type(__v));
int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
__cs += __ilen - __len;
#pragma empty_line
// Add grouping, if necessary.
if (__lc->_M_use_grouping)
{
// Grouping can add (almost) as many separators as the number
// of digits + space is reserved for numeric base or sign.
_CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* (__len + 1)
* 2));
_M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
__cs = __cs2 + 2;
}
#pragma empty_line
// Complete Stage 1, prepend numeric base or sign.
if (__builtin_expect(__dec, true))
{
// Decimal.
if (__v >= 0)
{
if (bool(__flags & ios_base::showpos)
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
*--__cs = __lit[__num_base::_S_oplus], ++__len;
}
else
*--__cs = __lit[__num_base::_S_ominus], ++__len;
}
else if (bool(__flags & ios_base::showbase) && __v)
{
if (__basefield == ios_base::oct)
*--__cs = __lit[__num_base::_S_odigits], ++__len;
else
{
// 'x' or 'X'
const bool __uppercase = __flags & ios_base::uppercase;
*--__cs = __lit[__num_base::_S_ox + __uppercase];
// '0'
*--__cs = __lit[__num_base::_S_odigits];
__len += 2;
}
}
#pragma empty_line
// Pad.
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
_CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __cs3, __cs, __len);
__cs = __cs3;
}
__io.width(0);
#pragma empty_line
// [22.2.2.2.2] Stage 4.
// Write resulting, fully-formatted string to output iterator.
return std::__write(__s, __cs, __len);
}
#pragma empty_line
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_group_float(const char* __grouping, size_t __grouping_size,
_CharT __sep, const _CharT* __p, _CharT* __new,
_CharT* __cs, int& __len) const
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 282. What types does numpunct grouping refer to?
// Add grouping, if necessary.
const int __declen = __p ? __p - __cs : __len;
_CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
__grouping_size,
__cs, __cs + __declen);
#pragma empty_line
// Tack on decimal part.
int __newlen = __p2 - __new;
if (__p)
{
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
__len = __newlen;
}
#pragma empty_line
// The following code uses vsnprintf (or vsprintf(), when
// _GLIBCXX_USE_C99 is not defined) to convert floating point values
// for insertion into a stream. An optimization would be to replace
// them with code that works directly on a wide buffer and then use
// __pad to do the padding. It would be good to replace them anyway
// to gain back the efficiency that C++ provides by knowing up front
// the type of the values to insert. Also, sprintf is dangerous
// since may lead to accidental buffer overruns. This
// implementation follows the C++ standard fairly directly as
// outlined in 22.2.2.2 [lib.locale.num.put]
template<typename _CharT, typename _OutIter>
template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
_ValueT __v) const
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
#pragma empty_line
// Use default precision if out of range.
const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
#pragma empty_line
const int __max_digits =
__gnu_cxx::__numeric_traits<_ValueT>::__digits10;
#pragma empty_line
// [22.2.2.2.2] Stage 1, numeric conversion to character.
int __len;
// Long enough for the max format spec.
char __fbuf[16];
__num_base::_S_format_float(__io, __fbuf, __mod);
#pragma empty_line
#pragma empty_line
// First try a buffer perhaps big enough (most probably sufficient
// for non-ios_base::fixed outputs)
int __cs_size = __max_digits * 3;
char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __prec, __v);
#pragma empty_line
// If the buffer was not large enough, try again with the correct size.
if (__len >= __cs_size)
{
__cs_size = __len + 1;
__cs = static_cast<char*>(__builtin_alloca(__cs_size));
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __prec, __v);
}
#pragma line 1024 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.tcc" 3
// [22.2.2.2.2] Stage 2, convert to char_type, using correct
// numpunct.decimal_point() values for '.' and adding grouping.
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
#pragma empty_line
_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len));
__ctype.widen(__cs, __cs + __len, __ws);
#pragma empty_line
// Replace decimal point.
_CharT* __wp = 0;
const char* __p = char_traits<char>::find(__cs, __len, '.');
if (__p)
{
__wp = __ws + (__p - __cs);
*__wp = __lc->_M_decimal_point;
}
#pragma empty_line
// Add grouping, if necessary.
// N.B. Make sure to not group things like 2e20, i.e., no decimal
// point, scientific notation.
if (__lc->_M_use_grouping
&& (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
&& __cs[1] >= '0' && __cs[2] >= '0')))
{
// Grouping can add (almost) as many separators as the
// number of digits, but no more.
_CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len * 2));
#pragma empty_line
streamsize __off = 0;
if (__cs[0] == '-' || __cs[0] == '+')
{
__off = 1;
__ws2[0] = __ws[0];
__len -= 1;
}
#pragma empty_line
_M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __wp, __ws2 + __off,
__ws + __off, __len);
__len += __off;
#pragma empty_line
__ws = __ws2;
}
#pragma empty_line
// Pad.
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
_CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __ws3, __ws, __len);
__ws = __ws3;
}
__io.width(0);
#pragma empty_line
// [22.2.2.2.2] Stage 4.
// Write resulting, fully-formatted string to output iterator.
return std::__write(__s, __ws, __len);
}
#pragma empty_line
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
{
const ios_base::fmtflags __flags = __io.flags();
if ((__flags & ios_base::boolalpha) == 0)
{
const long __l = __v;
__s = _M_insert_int(__s, __io, __fill, __l);
}
else
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
#pragma empty_line
const _CharT* __name = __v ? __lc->_M_truename
: __lc->_M_falsename;
int __len = __v ? __lc->_M_truename_size
: __lc->_M_falsename_size;
#pragma empty_line
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
const streamsize __plen = __w - __len;
_CharT* __ps
= static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __plen));
#pragma empty_line
char_traits<_CharT>::assign(__ps, __plen, __fill);
__io.width(0);
#pragma empty_line
if ((__flags & ios_base::adjustfield) == ios_base::left)
{
__s = std::__write(__s, __name, __len);
__s = std::__write(__s, __ps, __plen);
}
else
{
__s = std::__write(__s, __ps, __plen);
__s = std::__write(__s, __name, __len);
}
return __s;
}
__io.width(0);
__s = std::__write(__s, __name, __len);
}
return __s;
}
#pragma empty_line
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
{ return _M_insert_float(__s, __io, __fill, char(), __v); }
#pragma line 1151 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.tcc" 3
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
{ return _M_insert_float(__s, __io, __fill, 'L', __v); }
#pragma empty_line
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
{
const ios_base::fmtflags __flags = __io.flags();
const ios_base::fmtflags __fmt = ~(ios_base::basefield
| ios_base::uppercase);
__io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
#pragma empty_line
typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
#pragma empty_line
__s = _M_insert_int(__s, __io, __fill,
reinterpret_cast<_UIntPtrType>(__v));
__io.flags(__flags);
return __s;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Construct correctly padded string, as per 22.2.2.2.2
// Assumes
// __newlen > __oldlen
// __news is allocated for __newlen size
#pragma empty_line
// NB: Of the two parameters, _CharT can be deduced from the
// function arguments. The other (_Traits) has to be explicitly specified.
template<typename _CharT, typename _Traits>
void
__pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
_CharT* __news, const _CharT* __olds,
streamsize __newlen, streamsize __oldlen)
{
const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
#pragma empty_line
// Padding last.
if (__adjust == ios_base::left)
{
_Traits::copy(__news, __olds, __oldlen);
_Traits::assign(__news + __oldlen, __plen, __fill);
return;
}
#pragma empty_line
size_t __mod = 0;
if (__adjust == ios_base::internal)
{
// Pad after the sign, if there is one.
// Pad after 0[xX], if there is one.
// Who came up with these rules, anyway? Jeeze.
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
#pragma empty_line
if (__ctype.widen('-') == __olds[0]
|| __ctype.widen('+') == __olds[0])
{
__news[0] = __olds[0];
__mod = 1;
++__news;
}
else if (__ctype.widen('0') == __olds[0]
&& __oldlen > 1
&& (__ctype.widen('x') == __olds[1]
|| __ctype.widen('X') == __olds[1]))
{
__news[0] = __olds[0];
__news[1] = __olds[1];
__mod = 2;
__news += 2;
}
// else Padding first.
}
_Traits::assign(__news, __plen, __fill);
_Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
}
#pragma empty_line
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
{
size_t __idx = 0;
size_t __ctr = 0;
#pragma empty_line
while (__last - __first > __gbeg[__idx]
&& static_cast<signed char>(__gbeg[__idx]) > 0
&& __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
{
__last -= __gbeg[__idx];
__idx < __gsize - 1 ? ++__idx : ++__ctr;
}
#pragma empty_line
while (__first != __last)
*__s++ = *__first++;
#pragma empty_line
while (__ctr--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
#pragma empty_line
while (__idx--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
#pragma empty_line
return __s;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class numpunct<char>;
extern template class numpunct_byname<char>;
extern template class num_get<char>;
extern template class num_put<char>;
extern template class ctype_byname<char>;
#pragma empty_line
extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);
#pragma empty_line
extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);
#pragma empty_line
extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);
#pragma empty_line
extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<ctype<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<numpunct<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_put<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_get<char> >(const locale&);
#pragma empty_line
#pragma empty_line
extern template class numpunct<wchar_t>;
extern template class numpunct_byname<wchar_t>;
extern template class num_get<wchar_t>;
extern template class num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;
#pragma empty_line
extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);
#pragma empty_line
extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);
#pragma empty_line
extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<ctype<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_get<wchar_t> >(const locale&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 2601 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/locale_facets.h" 2 3
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_ios.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _Facet>
inline const _Facet&
__check_facet(const _Facet* __f)
{
if (!__f)
__throw_bad_cast();
return *__f;
}
#pragma empty_line
// 27.4.5 Template class basic_ios
/**
* @brief Virtual base class for all stream classes.
* @ingroup io
*
* Most of the member functions called dispatched on stream objects
* (e.g., @c std::cout.foo(bar);) are consolidated in this class.
*/
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
//@{
/**
* These are standard types. They permit a standardized way of
* referring to names of (or names dependant on) the template
* parameters, which are specific to the implementation.
*/
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
//@}
#pragma empty_line
//@{
/**
* These are non-standard types.
*/
typedef ctype<_CharT> __ctype_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
//@}
#pragma empty_line
// Data members:
protected:
basic_ostream<_CharT, _Traits>* _M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits>* _M_streambuf;
#pragma empty_line
// Cached use_facet<ctype>, which is based on the current locale info.
const __ctype_type* _M_ctype;
// For ostream.
const __num_put_type* _M_num_put;
// For istream.
const __num_get_type* _M_num_get;
#pragma empty_line
public:
//@{
/**
* @brief The quick-and-easy status check.
*
* This allows you to write constructs such as
* <code>if (!a_stream) ...</code> and <code>while (a_stream) ...</code>
*/
operator void*() const
{ return this->fail() ? 0 : const_cast<basic_ios*>(this); }
#pragma empty_line
bool
operator!() const
{ return this->fail(); }
//@}
#pragma empty_line
/**
* @brief Returns the error state of the stream buffer.
* @return A bit pattern (well, isn't everything?)
*
* See std::ios_base::iostate for the possible bit values. Most
* users will call one of the interpreting wrappers, e.g., good().
*/
iostate
rdstate() const
{ return _M_streambuf_state; }
#pragma empty_line
/**
* @brief [Re]sets the error state.
* @param state The new state flag(s) to set.
*
* See std::ios_base::iostate for the possible bit values. Most
* users will not need to pass an argument.
*/
void
clear(iostate __state = goodbit);
#pragma empty_line
/**
* @brief Sets additional flags in the error state.
* @param state The additional state flag(s) to set.
*
* See std::ios_base::iostate for the possible bit values.
*/
void
setstate(iostate __state)
{ this->clear(this->rdstate() | __state); }
#pragma empty_line
// Flip the internal state on for the proper state bits, then re
// throws the propagated exception if bit also set in
// exceptions().
void
_M_setstate(iostate __state)
{
// 27.6.1.2.1 Common requirements.
// Turn this on without causing an ios::failure to be thrown.
_M_streambuf_state |= __state;
if (this->exceptions() & __state)
;
}
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if no error flags are set.
*
* A wrapper around rdstate.
*/
bool
good() const
{ return this->rdstate() == 0; }
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if the eofbit is set.
*
* Note that other iostate flags may also be set.
*/
bool
eof() const
{ return (this->rdstate() & eofbit) != 0; }
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if either the badbit or the failbit is set.
*
* Checking the badbit in fail() is historical practice.
* Note that other iostate flags may also be set.
*/
bool
fail() const
{ return (this->rdstate() & (badbit | failbit)) != 0; }
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if the badbit is set.
*
* Note that other iostate flags may also be set.
*/
bool
bad() const
{ return (this->rdstate() & badbit) != 0; }
#pragma empty_line
/**
* @brief Throwing exceptions on errors.
* @return The current exceptions mask.
*
* This changes nothing in the stream. See the one-argument version
* of exceptions(iostate) for the meaning of the return value.
*/
iostate
exceptions() const
{ return _M_exception; }
#pragma empty_line
/**
* @brief Throwing exceptions on errors.
* @param except The new exceptions mask.
*
* By default, error flags are set silently. You can set an
* exceptions mask for each stream; if a bit in the mask becomes set
* in the error flags, then an exception of type
* std::ios_base::failure is thrown.
*
* If the error flag is already set when the exceptions mask is
* added, the exception is immediately thrown. Try running the
* following under GCC 3.1 or later:
* @code
* #include <iostream>
* #include <fstream>
* #include <exception>
*
* int main()
* {
* std::set_terminate (__gnu_cxx::__verbose_terminate_handler);
*
* std::ifstream f ("/etc/motd");
*
* std::cerr << "Setting badbit\n";
* f.setstate (std::ios_base::badbit);
*
* std::cerr << "Setting exception mask\n";
* f.exceptions (std::ios_base::badbit);
* }
* @endcode
*/
void
exceptions(iostate __except)
{
_M_exception = __except;
this->clear(_M_streambuf_state);
}
#pragma empty_line
// Constructor/destructor:
/**
* @brief Constructor performs initialization.
*
* The parameter is passed by derived streams.
*/
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
: ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
_M_ctype(0), _M_num_put(0), _M_num_get(0)
{ this->init(__sb); }
#pragma empty_line
/**
* @brief Empty.
*
* The destructor does nothing. More specifically, it does not
* destroy the streambuf held by rdbuf().
*/
virtual
~basic_ios() { }
#pragma empty_line
// Members:
/**
* @brief Fetches the current @e tied stream.
* @return A pointer to the tied stream, or NULL if the stream is
* not tied.
*
* A stream may be @e tied (or synchronized) to a second output
* stream. When this stream performs any I/O, the tied stream is
* first flushed. For example, @c std::cin is tied to @c std::cout.
*/
basic_ostream<_CharT, _Traits>*
tie() const
{ return _M_tie; }
#pragma empty_line
/**
* @brief Ties this stream to an output stream.
* @param tiestr The output stream.
* @return The previously tied output stream, or NULL if the stream
* was not tied.
*
* This sets up a new tie; see tie() for more.
*/
basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
{
basic_ostream<_CharT, _Traits>* __old = _M_tie;
_M_tie = __tiestr;
return __old;
}
#pragma empty_line
/**
* @brief Accessing the underlying buffer.
* @return The current stream buffer.
*
* This does not change the state of the stream.
*/
basic_streambuf<_CharT, _Traits>*
rdbuf() const
{ return _M_streambuf; }
#pragma empty_line
/**
* @brief Changing the underlying buffer.
* @param sb The new stream buffer.
* @return The previous stream buffer.
*
* Associates a new buffer with the current stream, and clears the
* error state.
*
* Due to historical accidents which the LWG refuses to correct, the
* I/O library suffers from a design error: this function is hidden
* in derived classes by overrides of the zero-argument @c rdbuf(),
* which is non-virtual for hysterical raisins. As a result, you
* must use explicit qualifications to access this function via any
* derived class. For example:
*
* @code
* std::fstream foo; // or some other derived type
* std::streambuf* p = .....;
*
* foo.ios::rdbuf(p); // ios == basic_ios<char>
* @endcode
*/
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
#pragma empty_line
/**
* @brief Copies fields of __rhs into this.
* @param __rhs The source values for the copies.
* @return Reference to this object.
*
* All fields of __rhs are copied into this object except that rdbuf()
* and rdstate() remain unchanged. All values in the pword and iword
* arrays are copied. Before copying, each callback is invoked with
* erase_event. After copying, each (new) callback is invoked with
* copyfmt_event. The final step is to copy exceptions().
*/
basic_ios&
copyfmt(const basic_ios& __rhs);
#pragma empty_line
/**
* @brief Retrieves the @a empty character.
* @return The current fill character.
*
* It defaults to a space (' ') in the current locale.
*/
char_type
fill() const
{
if (!_M_fill_init)
{
_M_fill = this->widen(' ');
_M_fill_init = true;
}
return _M_fill;
}
#pragma empty_line
/**
* @brief Sets a new @a empty character.
* @param ch The new character.
* @return The previous fill character.
*
* The fill character is used to fill out space when P+ characters
* have been requested (e.g., via setw), Q characters are actually
* used, and Q<P. It defaults to a space (' ') in the current locale.
*/
char_type
fill(char_type __ch)
{
char_type __old = this->fill();
_M_fill = __ch;
return __old;
}
#pragma empty_line
// Locales:
/**
* @brief Moves to a new locale.
* @param loc The new locale.
* @return The previous locale.
*
* Calls @c ios_base::imbue(loc), and if a stream buffer is associated
* with this stream, calls that buffer's @c pubimbue(loc).
*
* Additional l10n notes are at
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
*/
locale
imbue(const locale& __loc);
#pragma empty_line
/**
* @brief Squeezes characters.
* @param c The character to narrow.
* @param dfault The character to narrow.
* @return The narrowed character.
*
* Maps a character of @c char_type to a character of @c char,
* if possible.
*
* Returns the result of
* @code
* std::use_facet<ctype<char_type> >(getloc()).narrow(c,dfault)
* @endcode
*
* Additional l10n notes are at
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
*/
char
narrow(char_type __c, char __dfault) const
{ return __check_facet(_M_ctype).narrow(__c, __dfault); }
#pragma empty_line
/**
* @brief Widens characters.
* @param c The character to widen.
* @return The widened character.
*
* Maps a character of @c char to a character of @c char_type.
*
* Returns the result of
* @code
* std::use_facet<ctype<char_type> >(getloc()).widen(c)
* @endcode
*
* Additional l10n notes are at
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
*/
char_type
widen(char __c) const
{ return __check_facet(_M_ctype).widen(__c); }
#pragma empty_line
protected:
// 27.4.5.1 basic_ios constructors
/**
* @brief Empty.
*
* The default constructor does nothing and is not normally
* accessible to users.
*/
basic_ios()
: ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
{ }
#pragma empty_line
/**
* @brief All setup is performed here.
*
* This is called from the public constructor. It is not virtual and
* cannot be redefined.
*/
void
init(basic_streambuf<_CharT, _Traits>* __sb);
#pragma empty_line
void
_M_cache_locale(const locale& __loc);
};
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_ios.tcc" 1 3
// basic_ios member functions -*- C++ -*-
#pragma empty_line
// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
// 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file basic_ios.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 34 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_ios.tcc" 3
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::clear(iostate __state)
{
if (this->rdbuf())
_M_streambuf_state = __state;
else
_M_streambuf_state = __state | badbit;
if (this->exceptions() & this->rdstate())
__throw_ios_failure(("basic_ios::clear"));
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_streambuf<_CharT, _Traits>*
basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{
basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
_M_streambuf = __sb;
this->clear();
return __old;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ios<_CharT, _Traits>&
basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 292. effects of a.copyfmt (a)
if (this != &__rhs)
{
// Per 27.1.1, do not call imbue, yet must trash all caches
// associated with imbue()
#pragma empty_line
// Alloc any new word array first, so if it fails we have "rollback".
_Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
_M_local_word : new _Words[__rhs._M_word_size];
#pragma empty_line
// Bump refs before doing callbacks, for safety.
_Callback_list* __cb = __rhs._M_callbacks;
if (__cb)
__cb->_M_add_reference();
_M_call_callbacks(erase_event);
if (_M_word != _M_local_word)
{
delete [] _M_word;
_M_word = 0;
}
_M_dispose_callbacks();
#pragma empty_line
// NB: Don't want any added during above.
_M_callbacks = __cb;
for (int __i = 0; __i < __rhs._M_word_size; ++__i)
__words[__i] = __rhs._M_word[__i];
_M_word = __words;
_M_word_size = __rhs._M_word_size;
#pragma empty_line
this->flags(__rhs.flags());
this->width(__rhs.width());
this->precision(__rhs.precision());
this->tie(__rhs.tie());
this->fill(__rhs.fill());
_M_ios_locale = __rhs.getloc();
_M_cache_locale(_M_ios_locale);
#pragma empty_line
_M_call_callbacks(copyfmt_event);
#pragma empty_line
// The next is required to be the last assignment.
this->exceptions(__rhs.exceptions());
}
return *this;
}
#pragma empty_line
// Locales:
template<typename _CharT, typename _Traits>
locale
basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
{
locale __old(this->getloc());
ios_base::imbue(__loc);
_M_cache_locale(__loc);
if (this->rdbuf() != 0)
this->rdbuf()->pubimbue(__loc);
return __old;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
{
// NB: This may be called more than once on the same object.
ios_base::_M_init();
#pragma empty_line
// Cache locale data and specific facets used by iostreams.
_M_cache_locale(_M_ios_locale);
#pragma empty_line
// NB: The 27.4.4.1 Postconditions Table specifies requirements
// after basic_ios::init() has been called. As part of this,
// fill() must return widen(' ') any time after init() has been
// called, which needs an imbued ctype facet of char_type to
// return without throwing an exception. Unfortunately,
// ctype<char_type> is not necessarily a required facet, so
// streams with char_type != [char, wchar_t] will not have it by
// default. Because of this, the correct value for _M_fill is
// constructed on the first call of fill(). That way,
// unformatted input and output with non-required basic_ios
// instantiations is possible even without imbuing the expected
// ctype<char_type> facet.
_M_fill = _CharT();
_M_fill_init = false;
#pragma empty_line
_M_tie = 0;
_M_exception = goodbit;
_M_streambuf = __sb;
_M_streambuf_state = __sb ? goodbit : badbit;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
{
if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
_M_ctype = &use_facet<__ctype_type>(__loc);
else
_M_ctype = 0;
#pragma empty_line
if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
_M_num_put = &use_facet<__num_put_type>(__loc);
else
_M_num_put = 0;
#pragma empty_line
if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
_M_num_get = &use_facet<__num_get_type>(__loc);
else
_M_num_get = 0;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class basic_ios<char>;
#pragma empty_line
#pragma empty_line
extern template class basic_ios<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 471 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/basic_ios.h" 2 3
#pragma line 45 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ios" 2 3
#pragma line 40 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ostream" 2 3
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
// [27.6.2.1] Template class basic_ostream
/**
* @brief Controlling output.
* @ingroup io
*
* This is the base class for all output streams. It provides text
* formatting of all builtin types, and communicates with any class
* derived from basic_streambuf to do the actual output.
*/
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
// Types (inherited from basic_ios (27.4.4)):
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
#pragma empty_line
// Non-standard Types:
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
#pragma empty_line
// [27.6.2.2] constructor/destructor
/**
* @brief Base constructor.
*
* This ctor is almost never called by the user directly, rather from
* derived classes' initialization lists, which pass a pointer to
* their own stream buffer.
*/
explicit
basic_ostream(__streambuf_type* __sb)
{ this->init(__sb); }
#pragma empty_line
/**
* @brief Base destructor.
*
* This does very little apart from providing a virtual base dtor.
*/
virtual
~basic_ostream() { }
#pragma empty_line
// [27.6.2.3] prefix/suffix
class sentry;
friend class sentry;
#pragma empty_line
// [27.6.2.5] formatted output
// [27.6.2.5.3] basic_ostream::operator<<
//@{
/**
* @brief Interface for manipulators.
*
* Manipulators such as @c std::endl and @c std::hex use these
* functions in constructs like "std::cout << std::endl". For more
* information, see the iomanip header.
*/
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// The inserters for manipulators are *not* formatted output functions.
return __pf(*this);
}
#pragma empty_line
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// The inserters for manipulators are *not* formatted output functions.
__pf(*this);
return *this;
}
#pragma empty_line
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// The inserters for manipulators are *not* formatted output functions.
__pf(*this);
return *this;
}
//@}
#pragma empty_line
// [27.6.2.5.2] arithmetic inserters
/**
* @name Arithmetic Inserters
*
* All the @c operator<< functions (aka <em>formatted output
* functions</em>) have some common behavior. Each starts by
* constructing a temporary object of type std::basic_ostream::sentry.
* This can have several effects, concluding with the setting of a
* status flag; see the sentry documentation for more.
*
* If the sentry status is good, the function tries to generate
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during insertion, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Basic arithmetic inserters
* @param A variable of builtin type.
* @return @c *this if successful
*
* These functions use the stream's current locale (specifically, the
* @c num_get facet) to perform numeric formatting.
*/
__ostream_type&
operator<<(long __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(unsigned long __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(bool __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(short __n);
#pragma empty_line
__ostream_type&
operator<<(unsigned short __n)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
return _M_insert(static_cast<unsigned long>(__n));
}
#pragma empty_line
__ostream_type&
operator<<(int __n);
#pragma empty_line
__ostream_type&
operator<<(unsigned int __n)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
return _M_insert(static_cast<unsigned long>(__n));
}
#pragma empty_line
#pragma empty_line
__ostream_type&
operator<<(long long __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(unsigned long long __n)
{ return _M_insert(__n); }
#pragma empty_line
#pragma empty_line
__ostream_type&
operator<<(double __f)
{ return _M_insert(__f); }
#pragma empty_line
__ostream_type&
operator<<(float __f)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
return _M_insert(static_cast<double>(__f));
}
#pragma empty_line
__ostream_type&
operator<<(long double __f)
{ return _M_insert(__f); }
#pragma empty_line
__ostream_type&
operator<<(const void* __p)
{ return _M_insert(__p); }
#pragma empty_line
/**
* @brief Extracting from another streambuf.
* @param sb A pointer to a streambuf
*
* This function behaves like one of the basic arithmetic extractors,
* in that it also constructs a sentry object and has the same error
* handling behavior.
*
* If @a sb is NULL, the stream will set failbit in its error state.
*
* Characters are extracted from @a sb and inserted into @c *this
* until one of the following occurs:
*
* - the input stream reaches end-of-file,
* - insertion into the output sequence fails (in this case, the
* character that would have been inserted is not extracted), or
* - an exception occurs while getting a character from @a sb, which
* sets failbit in the error state
*
* If the function inserts no characters, failbit is set.
*/
__ostream_type&
operator<<(__streambuf_type* __sb);
//@}
#pragma empty_line
// [27.6.2.6] unformatted output functions
/**
* @name Unformatted Output Functions
*
* All the unformatted output functions have some common behavior.
* Each starts by constructing a temporary object of type
* std::basic_ostream::sentry. This has several effects, concluding
* with the setting of a status flag; see the sentry documentation
* for more.
*
* If the sentry status is good, the function tries to generate
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during insertion, ios_base::badbit
* will be turned on in the stream's error state. If badbit is on in
* the stream's exceptions mask, the exception will be rethrown
* without completing its actions.
*/
//@{
/**
* @brief Simple insertion.
* @param c The character to insert.
* @return *this
*
* Tries to insert @a c.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__ostream_type&
put(char_type __c);
#pragma empty_line
// Core write functionality, without sentry.
void
_M_write(const char_type* __s, streamsize __n)
{
const streamsize __put = this->rdbuf()->sputn(__s, __n);
if (__put != __n)
this->setstate(ios_base::badbit);
}
#pragma empty_line
/**
* @brief Character string insertion.
* @param s The array to insert.
* @param n Maximum number of characters to insert.
* @return *this
*
* Characters are copied from @a s and inserted into the stream until
* one of the following happens:
*
* - @a n characters are inserted
* - inserting into the output sequence fails (in this case, badbit
* will be set in the stream's error state)
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__ostream_type&
write(const char_type* __s, streamsize __n);
//@}
#pragma empty_line
/**
* @brief Synchronizing the stream buffer.
* @return *this
*
* If @c rdbuf() is a null pointer, changes nothing.
*
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
* sets badbit.
*/
__ostream_type&
flush();
#pragma empty_line
// [27.6.2.4] seek members
/**
* @brief Getting the current write position.
* @return A file position object.
*
* If @c fail() is not false, returns @c pos_type(-1) to indicate
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
*/
pos_type
tellp();
#pragma empty_line
/**
* @brief Changing the current write position.
* @param pos A file position object.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
* that function fails, sets failbit.
*/
__ostream_type&
seekp(pos_type);
#pragma empty_line
/**
* @brief Changing the current write position.
* @param off A file offset object.
* @param dir The direction in which to seek.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
* If that function fails, sets failbit.
*/
__ostream_type&
seekp(off_type, ios_base::seekdir);
#pragma empty_line
protected:
basic_ostream()
{ this->init(0); }
#pragma empty_line
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
#pragma empty_line
/**
* @brief Performs setup work for output streams.
*
* Objects of this class are created before all of the standard
* inserters are run. It is responsible for <em>exception-safe prefix and
* suffix operations</em>.
*/
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
// Data Members.
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
#pragma empty_line
public:
/**
* @brief The constructor performs preparatory work.
* @param os The output stream to guard.
*
* If the stream state is good (@a os.good() is true), then if the
* stream is tied to another output stream, @c is.tie()->flush()
* is called to synchronize the output sequences.
*
* If the stream state is still good, then the sentry state becomes
* true (@a okay).
*/
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
#pragma empty_line
/**
* @brief Possibly flushes the stream.
*
* If @c ios_base::unitbuf is set in @c os.flags(), and
* @c std::uncaught_exception() is true, the sentry destructor calls
* @c flush() on the output stream.
*/
~sentry()
{
// XXX MT
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
{
// Can't call flush directly or else will get into recursive lock.
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
_M_os.setstate(ios_base::badbit);
}
}
#pragma empty_line
/**
* @brief Quick status checking.
* @return The sentry state.
*
* For ease of use, sentries may be converted to booleans. The
* return value is that of the sentry state (true == okay).
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
operator bool() const
{ return _M_ok; }
};
#pragma empty_line
// [27.6.2.5.4] character insertion templates
//@{
/**
* @brief Character inserters
* @param out An output stream.
* @param c A character.
* @return out
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts a single character and any required
* padding (as determined by [22.2.2.2.2]). @c out.width(0) is then
* called.
*
* If @a c is of type @c char and the character type of the stream is not
* @c char, the character is widened before insertion.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
{ return __ostream_insert(__out, &__c, 1); }
#pragma empty_line
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
{ return (__out << __out.widen(__c)); }
#pragma empty_line
// Specialization
template <class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
{ return __ostream_insert(__out, &__c, 1); }
#pragma empty_line
// Signed and unsigned
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
{ return (__out << static_cast<char>(__c)); }
#pragma empty_line
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
{ return (__out << static_cast<char>(__c)); }
//@}
#pragma empty_line
//@{
/**
* @brief String inserters
* @param out An output stream.
* @param s A character string.
* @return out
* @pre @a s must be a non-NULL pointer
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts @c traits::length(s) characters starting
* at @a s, widened if necessary, followed by any required padding (as
* determined by [22.2.2.2.2]). @c out.width(0) is then called.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
#pragma empty_line
// Partial specializations
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
#pragma empty_line
// Signed and unsigned
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }
#pragma empty_line
template<class _Traits>
inline basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }
//@}
#pragma empty_line
// [27.6.2.7] standard basic_ostream manipulators
/**
* @brief Write a newline and flush the stream.
*
* This manipulator is often mistakenly used when a simple newline is
* desired, leading to poor buffering performance. See
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
* for more on this subject.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{ return flush(__os.put(__os.widen('\n'))); }
#pragma empty_line
/**
* @brief Write a null character into the output sequence.
*
* <em>Null character</em> is @c CharT() by definition. For CharT of @c char,
* this correctly writes the ASCII @c NUL character string terminator.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
{ return __os.put(_CharT()); }
#pragma empty_line
/**
* @brief Flushes the output stream.
*
* This manipulator simply calls the stream's @c flush() member function.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
{ return __os.flush(); }
#pragma line 582 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ostream" 3
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ostream.tcc" 1 3
// ostream classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ostream.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.6.2 Output streams
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/ostream.tcc" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>::sentry::
sentry(basic_ostream<_CharT, _Traits>& __os)
: _M_ok(false), _M_os(__os)
{
// XXX MT
if (__os.tie() && __os.good())
__os.tie()->flush();
#pragma empty_line
if (__os.good())
_M_ok = true;
else
__os.setstate(ios_base::failbit);
}
#pragma empty_line
template<typename _CharT, typename _Traits>
template<typename _ValueT>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
_M_insert(_ValueT __v)
{
sentry __cerb(*this);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const __num_put_type& __np = __check_facet(this->_M_num_put);
if (__np.put(*this, *this, this->fill(), __v).failed())
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(short __n)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(int __n)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(__streambuf_type* __sbin)
{
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this);
if (__cerb && __sbin)
{
if (true)
{
if (!__copy_streambufs(__sbin, this->rdbuf()))
__err |= ios_base::failbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::failbit); }
}
else if (!__sbin)
__err |= ios_base::badbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
put(char_type __c)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// basic_ostream::put(char_type) is an unformatted output function.
// DR 63. Exception-handling policy for unformatted output.
// Unformatted output functions should catch exceptions thrown
// from streambuf members.
sentry __cerb(*this);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __put = this->rdbuf()->sputc(__c);
if (traits_type::eq_int_type(__put, traits_type::eof()))
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
write(const _CharT* __s, streamsize __n)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// basic_ostream::write(const char_type*, streamsize) is an
// unformatted output function.
// DR 63. Exception-handling policy for unformatted output.
// Unformatted output functions should catch exceptions thrown
// from streambuf members.
sentry __cerb(*this);
if (__cerb)
{
if (true)
{ _M_write(__s, __n); }
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
flush()
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// basic_ostream::flush() is *not* an unformatted output function.
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
typename basic_ostream<_CharT, _Traits>::pos_type
basic_ostream<_CharT, _Traits>::
tellp()
{
pos_type __ret = pos_type(-1);
if (true)
{
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
return __ret;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
seekp(pos_type __pos)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::out);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
seekp(off_type __off, ios_base::seekdir __dir)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::out);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 167. Improper use of traits_type::length()
const size_t __clen = char_traits<char>::length(__s);
if (true)
{
struct __ptr_guard
{
_CharT *__p;
__ptr_guard (_CharT *__ip): __p(__ip) { }
~__ptr_guard() { delete[] __p; }
_CharT* __get() { return __p; }
} __pg (new _CharT[__clen]);
#pragma empty_line
_CharT *__ws = __pg.__get();
for (size_t __i = 0; __i < __clen; ++__i)
__ws[__i] = __out.widen(__s[__i]);
__ostream_insert(__out, __ws, __clen);
}
if (false)
{
__out._M_setstate(ios_base::badbit);
;
}
if (false)
{ __out._M_setstate(ios_base::badbit); }
}
return __out;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class basic_ostream<char>;
extern template ostream& endl(ostream&);
extern template ostream& ends(ostream&);
extern template ostream& flush(ostream&);
extern template ostream& operator<<(ostream&, char);
extern template ostream& operator<<(ostream&, unsigned char);
extern template ostream& operator<<(ostream&, signed char);
extern template ostream& operator<<(ostream&, const char*);
extern template ostream& operator<<(ostream&, const unsigned char*);
extern template ostream& operator<<(ostream&, const signed char*);
#pragma empty_line
extern template ostream& ostream::_M_insert(long);
extern template ostream& ostream::_M_insert(unsigned long);
extern template ostream& ostream::_M_insert(bool);
#pragma empty_line
extern template ostream& ostream::_M_insert(long long);
extern template ostream& ostream::_M_insert(unsigned long long);
#pragma empty_line
extern template ostream& ostream::_M_insert(double);
extern template ostream& ostream::_M_insert(long double);
extern template ostream& ostream::_M_insert(const void*);
#pragma empty_line
#pragma empty_line
extern template class basic_ostream<wchar_t>;
extern template wostream& endl(wostream&);
extern template wostream& ends(wostream&);
extern template wostream& flush(wostream&);
extern template wostream& operator<<(wostream&, wchar_t);
extern template wostream& operator<<(wostream&, char);
extern template wostream& operator<<(wostream&, const wchar_t*);
extern template wostream& operator<<(wostream&, const char*);
#pragma empty_line
extern template wostream& wostream::_M_insert(long);
extern template wostream& wostream::_M_insert(unsigned long);
extern template wostream& wostream::_M_insert(bool);
#pragma empty_line
extern template wostream& wostream::_M_insert(long long);
extern template wostream& wostream::_M_insert(unsigned long long);
#pragma empty_line
extern template wostream& wostream::_M_insert(double);
extern template wostream& wostream::_M_insert(long double);
extern template wostream& wostream::_M_insert(const void*);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 586 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\ostream" 2 3
#pragma line 40 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iostream" 2 3
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\istream" 1 3
// Input streams -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
//
// ISO C++ 14882: 27.6.1 Input streams
//
#pragma empty_line
/** @file istream
* This is a Standard C++ Library header.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\istream" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
// [27.6.1.1] Template class basic_istream
/**
* @brief Controlling input.
* @ingroup io
*
* This is the base class for all input streams. It provides text
* formatting of all builtin types, and communicates with any class
* derived from basic_streambuf to do the actual input.
*/
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
// Types (inherited from basic_ios (27.4.4)):
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
#pragma empty_line
// Non-standard Types:
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
typedef ctype<_CharT> __ctype_type;
#pragma empty_line
protected:
// Data Members:
/**
* The number of characters extracted in the previous unformatted
* function; see gcount().
*/
streamsize _M_gcount;
#pragma empty_line
public:
// [27.6.1.1.1] constructor/destructor
/**
* @brief Base constructor.
*
* This ctor is almost never called by the user directly, rather from
* derived classes' initialization lists, which pass a pointer to
* their own stream buffer.
*/
explicit
basic_istream(__streambuf_type* __sb)
: _M_gcount(streamsize(0))
{ this->init(__sb); }
#pragma empty_line
/**
* @brief Base destructor.
*
* This does very little apart from providing a virtual base dtor.
*/
virtual
~basic_istream()
{ _M_gcount = streamsize(0); }
#pragma empty_line
// [27.6.1.1.2] prefix/suffix
class sentry;
friend class sentry;
#pragma empty_line
// [27.6.1.2] formatted input
// [27.6.1.2.3] basic_istream::operator>>
//@{
/**
* @brief Interface for manipulators.
*
* Manipulators such as @c std::ws and @c std::dec use these
* functions in constructs like
* <code>std::cin >> std::ws</code>.
* For more information, see the iomanip header.
*/
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
{ return __pf(*this); }
#pragma empty_line
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
{
__pf(*this);
return *this;
}
#pragma empty_line
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
{
__pf(*this);
return *this;
}
//@}
#pragma empty_line
// [27.6.1.2.2] arithmetic extractors
/**
* @name Arithmetic Extractors
*
* All the @c operator>> functions (aka <em>formatted input
* functions</em>) have some common behavior. Each starts by
* constructing a temporary object of type std::basic_istream::sentry
* with the second argument (noskipws) set to false. This has several
* effects, concluding with the setting of a status flag; see the
* sentry documentation for more.
*
* If the sentry status is good, the function tries to extract
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during extraction, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Basic arithmetic extractors
* @param A variable of builtin type.
* @return @c *this if successful
*
* These functions use the stream's current locale (specifically, the
* @c num_get facet) to parse the input data.
*/
__istream_type&
operator>>(bool& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(short& __n);
#pragma empty_line
__istream_type&
operator>>(unsigned short& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(int& __n);
#pragma empty_line
__istream_type&
operator>>(unsigned int& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(long& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(unsigned long& __n)
{ return _M_extract(__n); }
#pragma empty_line
#pragma empty_line
__istream_type&
operator>>(long long& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(unsigned long long& __n)
{ return _M_extract(__n); }
#pragma empty_line
#pragma empty_line
__istream_type&
operator>>(float& __f)
{ return _M_extract(__f); }
#pragma empty_line
__istream_type&
operator>>(double& __f)
{ return _M_extract(__f); }
#pragma empty_line
__istream_type&
operator>>(long double& __f)
{ return _M_extract(__f); }
#pragma empty_line
__istream_type&
operator>>(void*& __p)
{ return _M_extract(__p); }
#pragma empty_line
/**
* @brief Extracting into another streambuf.
* @param sb A pointer to a streambuf
*
* This function behaves like one of the basic arithmetic extractors,
* in that it also constructs a sentry object and has the same error
* handling behavior.
*
* If @a sb is NULL, the stream will set failbit in its error state.
*
* Characters are extracted from this stream and inserted into the
* @a sb streambuf until one of the following occurs:
*
* - the input stream reaches end-of-file,
* - insertion into the output buffer fails (in this case, the
* character that would have been inserted is not extracted), or
* - an exception occurs (and in this case is caught)
*
* If the function inserts no characters, failbit is set.
*/
__istream_type&
operator>>(__streambuf_type* __sb);
//@}
#pragma empty_line
// [27.6.1.3] unformatted input
/**
* @brief Character counting
* @return The number of characters extracted by the previous
* unformatted input function dispatched for this stream.
*/
streamsize
gcount() const
{ return _M_gcount; }
#pragma empty_line
/**
* @name Unformatted Input Functions
*
* All the unformatted input functions have some common behavior.
* Each starts by constructing a temporary object of type
* std::basic_istream::sentry with the second argument (noskipws)
* set to true. This has several effects, concluding with the
* setting of a status flag; see the sentry documentation for more.
*
* If the sentry status is good, the function tries to extract
* whatever data is appropriate for the type of the argument.
*
* The number of characters extracted is stored for later retrieval
* by gcount().
*
* If an exception is thrown during extraction, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Simple extraction.
* @return A character, or eof().
*
* Tries to extract a character. If none are available, sets failbit
* and returns traits::eof().
*/
int_type
get();
#pragma empty_line
/**
* @brief Simple extraction.
* @param c The character in which to store data.
* @return *this
*
* Tries to extract a character and store it in @a c. If none are
* available, sets failbit and returns traits::eof().
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
get(char_type& __c);
#pragma empty_line
/**
* @brief Simple multiple-character extraction.
* @param s Pointer to an array.
* @param n Maximum number of characters to store in @a s.
* @param delim A "stop" character.
* @return *this
*
* Characters are extracted and stored into @a s until one of the
* following happens:
*
* - @c n-1 characters are stored
* - the input sequence reaches EOF
* - the next character equals @a delim, in which case the character
* is not extracted
*
* If no characters are stored, failbit is set in the stream's error
* state.
*
* In any case, a null character is stored into the next location in
* the array.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
/**
* @brief Simple multiple-character extraction.
* @param s Pointer to an array.
* @param n Maximum number of characters to store in @a s.
* @return *this
*
* Returns @c get(s,n,widen('\\n')).
*/
__istream_type&
get(char_type* __s, streamsize __n)
{ return this->get(__s, __n, this->widen('\n')); }
#pragma empty_line
/**
* @brief Extraction into another streambuf.
* @param sb A streambuf in which to store data.
* @param delim A "stop" character.
* @return *this
*
* Characters are extracted and inserted into @a sb until one of the
* following happens:
*
* - the input sequence reaches EOF
* - insertion into the output buffer fails (in this case, the
* character that would have been inserted is not extracted)
* - the next character equals @a delim (in this case, the character
* is not extracted)
* - an exception occurs (and in this case is caught)
*
* If no characters are stored, failbit is set in the stream's error
* state.
*/
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
#pragma empty_line
/**
* @brief Extraction into another streambuf.
* @param sb A streambuf in which to store data.
* @return *this
*
* Returns @c get(sb,widen('\\n')).
*/
__istream_type&
get(__streambuf_type& __sb)
{ return this->get(__sb, this->widen('\n')); }
#pragma empty_line
/**
* @brief String extraction.
* @param s A character array in which to store the data.
* @param n Maximum number of characters to extract.
* @param delim A "stop" character.
* @return *this
*
* Extracts and stores characters into @a s until one of the
* following happens. Note that these criteria are required to be
* tested in the order listed here, to allow an input line to exactly
* fill the @a s array without setting failbit.
*
* -# the input sequence reaches end-of-file, in which case eofbit
* is set in the stream error state
* -# the next character equals @c delim, in which case the character
* is extracted (and therefore counted in @c gcount()) but not stored
* -# @c n-1 characters are stored, in which case failbit is set
* in the stream error state
*
* If no characters are extracted, failbit is set. (An empty line of
* input should therefore not cause failbit to be set.)
*
* In any case, a null character is stored in the next location in
* the array.
*/
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
/**
* @brief String extraction.
* @param s A character array in which to store the data.
* @param n Maximum number of characters to extract.
* @return *this
*
* Returns @c getline(s,n,widen('\\n')).
*/
__istream_type&
getline(char_type* __s, streamsize __n)
{ return this->getline(__s, __n, this->widen('\n')); }
#pragma empty_line
/**
* @brief Discarding characters
* @param n Number of characters to discard.
* @param delim A "stop" character.
* @return *this
*
* Extracts characters and throws them away until one of the
* following happens:
* - if @a n @c != @c std::numeric_limits<int>::max(), @a n
* characters are extracted
* - the input sequence reaches end-of-file
* - the next character equals @a delim (in this case, the character
* is extracted); note that this condition will never occur if
* @a delim equals @c traits::eof().
*
* NB: Provide three overloads, instead of the single function
* (with defaults) mandated by the Standard: this leads to a
* better performing implementation, while still conforming to
* the Standard.
*/
__istream_type&
ignore();
#pragma empty_line
__istream_type&
ignore(streamsize __n);
#pragma empty_line
__istream_type&
ignore(streamsize __n, int_type __delim);
#pragma empty_line
/**
* @brief Looking ahead in the stream
* @return The next character, or eof().
*
* If, after constructing the sentry object, @c good() is false,
* returns @c traits::eof(). Otherwise reads but does not extract
* the next input character.
*/
int_type
peek();
#pragma empty_line
/**
* @brief Extraction without delimiters.
* @param s A character array.
* @param n Maximum number of characters to store.
* @return *this
*
* If the stream state is @c good(), extracts characters and stores
* them into @a s until one of the following happens:
* - @a n characters are stored
* - the input sequence reaches end-of-file, in which case the error
* state is set to @c failbit|eofbit.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
read(char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Extraction until the buffer is exhausted, but no more.
* @param s A character array.
* @param n Maximum number of characters to store.
* @return The number of characters extracted.
*
* Extracts characters and stores them into @a s depending on the
* number of characters remaining in the streambuf's buffer,
* @c rdbuf()->in_avail(), called @c A here:
* - if @c A @c == @c -1, sets eofbit and extracts no characters
* - if @c A @c == @c 0, extracts no characters
* - if @c A @c > @c 0, extracts @c min(A,n)
*
* The goal is to empty the current buffer, and to not request any
* more from the external input sequence controlled by the streambuf.
*/
streamsize
readsome(char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Unextracting a single character.
* @param c The character to push back into the input stream.
* @return *this
*
* If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c).
*
* If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in
* the error state.
*
* @note Since no characters are extracted, the next call to
* @c gcount() will return 0, as required by DR 60.
*/
__istream_type&
putback(char_type __c);
#pragma empty_line
/**
* @brief Unextracting the previous character.
* @return *this
*
* If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c).
*
* If @c rdbuf() is null or if @c sungetc() fails, sets badbit in
* the error state.
*
* @note Since no characters are extracted, the next call to
* @c gcount() will return 0, as required by DR 60.
*/
__istream_type&
unget();
#pragma empty_line
/**
* @brief Synchronizing the stream buffer.
* @return 0 on success, -1 on failure
*
* If @c rdbuf() is a null pointer, returns -1.
*
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
* sets badbit and returns -1.
*
* Otherwise, returns 0.
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
int
sync();
#pragma empty_line
/**
* @brief Getting the current read position.
* @return A file position object.
*
* If @c fail() is not false, returns @c pos_type(-1) to indicate
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in).
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
pos_type
tellg();
#pragma empty_line
/**
* @brief Changing the current read position.
* @param pos A file position object.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
* that function fails, sets failbit.
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
__istream_type&
seekg(pos_type);
#pragma empty_line
/**
* @brief Changing the current read position.
* @param off A file offset object.
* @param dir The direction in which to seek.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
* If that function fails, sets failbit.
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
__istream_type&
seekg(off_type, ios_base::seekdir);
//@}
#pragma empty_line
protected:
basic_istream()
: _M_gcount(streamsize(0))
{ this->init(0); }
#pragma empty_line
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
#pragma empty_line
// Explicit specialization declarations, defined in src/istream.cc.
template<>
basic_istream<char>&
basic_istream<char>::
getline(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n);
#pragma empty_line
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n, int_type __delim);
#pragma empty_line
#pragma empty_line
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
getline(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n);
#pragma empty_line
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n, int_type __delim);
#pragma empty_line
#pragma empty_line
/**
* @brief Performs setup work for input streams.
*
* Objects of this class are created before all of the standard
* extractors are run. It is responsible for <em>exception-safe
* prefix and suffix operations,</em> although only prefix actions
* are currently required by the standard.
*/
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
// Data Members.
bool _M_ok;
#pragma empty_line
public:
/// Easy access to dependant types.
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;
#pragma empty_line
/**
* @brief The constructor performs all the work.
* @param is The input stream to guard.
* @param noskipws Whether to consume whitespace or not.
*
* If the stream state is good (@a is.good() is true), then the
* following actions are performed, otherwise the sentry state
* is false (<em>not okay</em>) and failbit is set in the
* stream state.
*
* The sentry's preparatory actions are:
*
* -# if the stream is tied to an output stream, @c is.tie()->flush()
* is called to synchronize the output sequence
* -# if @a noskipws is false, and @c ios_base::skipws is set in
* @c is.flags(), the sentry extracts and discards whitespace
* characters from the stream. The currently imbued locale is
* used to determine whether each character is whitespace.
*
* If the stream state is still good, then the sentry state becomes
* true (@a okay).
*/
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
#pragma empty_line
/**
* @brief Quick status checking.
* @return The sentry state.
*
* For ease of use, sentries may be converted to booleans. The
* return value is that of the sentry state (true == okay).
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
operator bool() const
{ return _M_ok; }
};
#pragma empty_line
// [27.6.1.2.3] character extraction templates
//@{
/**
* @brief Character extractors
* @param in An input stream.
* @param c A character reference.
* @return in
*
* Behaves like one of the formatted arithmetic extractors described in
* std::basic_istream. After constructing a sentry object with good
* status, this function extracts a character (if one is available) and
* stores it in @a c. Otherwise, sets failbit in the input stream.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
//@}
#pragma empty_line
//@{
/**
* @brief Character string extractors
* @param in An input stream.
* @param s A pointer to a character array.
* @return in
*
* Behaves like one of the formatted arithmetic extractors described in
* std::basic_istream. After constructing a sentry object with good
* status, this function extracts up to @c n characters and stores them
* into the array starting at @a s. @c n is defined as:
*
* - if @c width() is greater than zero, @c n is width() otherwise
* - @c n is <em>the number of elements of the largest array of *
* - @c char_type that can store a terminating @c eos.</em>
* - [27.6.1.2.3]/6
*
* Characters are extracted and stored until one of the following happens:
* - @c n-1 characters are stored
* - EOF is reached
* - the next character is whitespace according to the current locale
* - the next character is a null byte (i.e., @c charT() )
*
* @c width(0) is then called for the input stream.
*
* If no characters are extracted, sets failbit.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
#pragma empty_line
// Explicit specialization declaration, defined in src/istream.cc.
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __in, char* __s);
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
//@}
#pragma empty_line
// 27.6.1.5 Template class basic_iostream
/**
* @brief Merging istream and ostream capabilities.
* @ingroup io
*
* This class multiply inherits from the input and output stream classes
* simply to provide a single interface.
*/
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 271. basic_iostream missing typedefs
// Types (inherited):
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
#pragma empty_line
// Non-standard Types:
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
#pragma empty_line
/**
* @brief Constructor does nothing.
*
* Both of the parent classes are initialized with the same
* streambuf pointer passed to this constructor.
*/
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
: __istream_type(__sb), __ostream_type(__sb) { }
#pragma empty_line
/**
* @brief Destructor does nothing.
*/
virtual
~basic_iostream() { }
#pragma empty_line
protected:
basic_iostream()
: __istream_type(), __ostream_type() { }
};
#pragma empty_line
// [27.6.1.4] standard basic_istream manipulators
/**
* @brief Quick and easy way to eat whitespace
*
* This manipulator extracts whitespace characters, stopping when the
* next character is non-whitespace, or when the input sequence is empty.
* If the sequence is empty, @c eofbit is set in the stream, but not
* @c failbit.
*
* The current locale is used to distinguish whitespace characters.
*
* Example:
* @code
* MyClass mc;
*
* std::cin >> std::ws >> mc;
* @endcode
* will skip leading whitespace before calling operator>> on cin and your
* object. Note that the same effect can be achieved by creating a
* std::basic_istream::sentry inside your definition of operator>>.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
#pragma line 850 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\istream" 3
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/istream.tcc" 1 3
// istream classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file istream.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.6.1 Input streams
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\bits/istream.tcc" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>::sentry::
sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
{
ios_base::iostate __err = ios_base::goodbit;
if (__in.good())
{
if (__in.tie())
__in.tie()->flush();
if (!__noskip && bool(__in.flags() & ios_base::skipws))
{
const __int_type __eof = traits_type::eof();
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
#pragma empty_line
const __ctype_type& __ct = __check_facet(__in._M_ctype);
while (!traits_type::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space,
traits_type::to_char_type(__c)))
__c = __sb->snextc();
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 195. Should basic_istream::sentry's constructor ever
// set eofbit?
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
}
#pragma empty_line
if (__in.good() && __err == ios_base::goodbit)
_M_ok = true;
else
{
__err |= ios_base::failbit;
__in.setstate(__err);
}
}
#pragma empty_line
template<typename _CharT, typename _Traits>
template<typename _ValueT>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
_M_extract(_ValueT& __v)
{
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __v);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(short& __n)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 118. basic_istream uses nonexistent num_get member functions.
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 696. istream::operator>>(int&) broken.
if (__l < __gnu_cxx::__numeric_traits<short>::__min)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__min;
}
else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__max;
}
else
__n = short(__l);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(int& __n)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 118. basic_istream uses nonexistent num_get member functions.
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 696. istream::operator>>(int&) broken.
if (__l < __gnu_cxx::__numeric_traits<int>::__min)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__min;
}
else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__max;
}
else
__n = int(__l);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(__streambuf_type* __sbout)
{
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, false);
if (__cerb && __sbout)
{
if (true)
{
bool __ineof;
if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
__err |= ios_base::failbit;
if (__ineof)
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::failbit);
;
}
if (false)
{ this->_M_setstate(ios_base::failbit); }
}
else if (!__sbout)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::
get(void)
{
const int_type __eof = traits_type::eof();
int_type __c = __eof;
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
if (true)
{
__c = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
if (!traits_type::eq_int_type(__c, __eof))
_M_gcount = 1;
else
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return __c;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
get(char_type& __c)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
if (true)
{
const int_type __cb = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
if (!traits_type::eq_int_type(__cb, traits_type::eof()))
{
_M_gcount = 1;
__c = traits_type::to_char_type(__cb);
}
else
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
get(char_type* __s, streamsize __n, char_type __delim)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
if (true)
{
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
while (_M_gcount + 1 < __n
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim))
{
*__s++ = traits_type::to_char_type(__c);
++_M_gcount;
__c = __sb->snextc();
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 243. get and getline when sentry reports failure.
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
get(__streambuf_type& __sb, char_type __delim)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
if (true)
{
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type* __this_sb = this->rdbuf();
int_type __c = __this_sb->sgetc();
char_type __c2 = traits_type::to_char_type(__c);
#pragma empty_line
while (!traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim)
&& !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
{
++_M_gcount;
__c = __this_sb->snextc();
__c2 = traits_type::to_char_type(__c);
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
getline(char_type* __s, streamsize __n, char_type __delim)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
if (true)
{
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
while (_M_gcount + 1 < __n
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim))
{
*__s++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
++_M_gcount;
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
else
{
if (traits_type::eq_int_type(__c, __idelim))
{
__sb->sbumpc();
++_M_gcount;
}
else
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 243. get and getline when sentry reports failure.
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
// We provide three overloads, since the first two are much simpler
// than the general case. Also, the latter two can thus adopt the
// same "batchy" strategy used by getline above.
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(void)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
#pragma empty_line
if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
__err |= ios_base::eofbit;
else
_M_gcount = 1;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(streamsize __n)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
// N.B. On LFS-enabled platforms streamsize is still 32 bits
// wide: if we want to implement the standard mandated behavior
// for n == max() (see 27.6.1.3/24) we are at risk of signed
// integer overflow: thus these contortions. Also note that,
// by definition, when more than 2G chars are actually ignored,
// _M_gcount (the return value of gcount, that is) cannot be
// really correct, being unavoidably too small.
bool __large_ignore = false;
while (true)
{
while (_M_gcount < __n
&& !traits_type::eq_int_type(__c, __eof))
{
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
&& !traits_type::eq_int_type(__c, __eof))
{
_M_gcount =
__gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
}
else
break;
}
#pragma empty_line
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
#pragma empty_line
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(streamsize __n, int_type __delim)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
// See comment above.
bool __large_ignore = false;
while (true)
{
while (_M_gcount < __n
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __delim))
{
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __delim))
{
_M_gcount =
__gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
}
else
break;
}
#pragma empty_line
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
#pragma empty_line
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
else if (traits_type::eq_int_type(__c, __delim))
{
if (_M_gcount
< __gnu_cxx::__numeric_traits<streamsize>::__max)
++_M_gcount;
__sb->sbumpc();
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::
peek(void)
{
int_type __c = traits_type::eof();
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
__c = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__c, traits_type::eof()))
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return __c;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
read(char_type* __s, streamsize __n)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
_M_gcount = this->rdbuf()->sgetn(__s, __n);
if (_M_gcount != __n)
__err |= (ios_base::eofbit | ios_base::failbit);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
streamsize
basic_istream<_CharT, _Traits>::
readsome(char_type* __s, streamsize __n)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
// Cannot compare int_type with streamsize generically.
const streamsize __num = this->rdbuf()->in_avail();
if (__num > 0)
_M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
else if (__num == -1)
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return _M_gcount;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
putback(char_type __c)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 60. What is a formatted input function?
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
if (!__sb
|| traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
unget(void)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 60. What is a formatted input function?
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
if (!__sb
|| traits_type::eq_int_type(__sb->sungetc(), __eof))
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
int
basic_istream<_CharT, _Traits>::
sync(void)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
int __ret = -1;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
__streambuf_type* __sb = this->rdbuf();
if (__sb)
{
if (__sb->pubsync() == -1)
__err |= ios_base::badbit;
else
__ret = 0;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return __ret;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::pos_type
basic_istream<_CharT, _Traits>::
tellg(void)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
pos_type __ret = pos_type(-1);
if (true)
{
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
ios_base::in);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
return __ret;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(pos_type __pos)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::in);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(off_type __off, ios_base::seekdir __dir)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::in);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
// 27.6.1.2.3 Character extraction templates
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::int_type __int_type;
#pragma empty_line
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const __int_type __cb = __in.rdbuf()->sbumpc();
if (!_Traits::eq_int_type(__cb, _Traits::eof()))
__c = _Traits::to_char_type(__cb);
else
__err |= (ios_base::eofbit | ios_base::failbit);
}
if (false)
{
__in._M_setstate(ios_base::badbit);
;
}
if (false)
{ __in._M_setstate(ios_base::badbit); }
if (__err)
__in.setstate(__err);
}
return __in;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename _Traits::int_type int_type;
typedef _CharT char_type;
typedef ctype<_CharT> __ctype_type;
#pragma empty_line
streamsize __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
if (true)
{
// Figure out how many characters to extract.
streamsize __num = __in.width();
if (__num <= 0)
__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
#pragma empty_line
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
#pragma empty_line
const int_type __eof = _Traits::eof();
__streambuf_type* __sb = __in.rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
while (__extracted < __num - 1
&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(ctype_base::space,
_Traits::to_char_type(__c)))
{
*__s++ = _Traits::to_char_type(__c);
++__extracted;
__c = __sb->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 68. Extractors for char* should store null at end
*__s = char_type();
__in.width(0);
}
if (false)
{
__in._M_setstate(ios_base::badbit);
;
}
if (false)
{ __in._M_setstate(ios_base::badbit); }
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
#pragma empty_line
// 27.6.1.4 Standard basic_istream manipulators
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __in)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename __istream_type::int_type __int_type;
typedef ctype<_CharT> __ctype_type;
#pragma empty_line
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
#pragma empty_line
while (!_Traits::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
__c = __sb->snextc();
#pragma empty_line
if (_Traits::eq_int_type(__c, __eof))
__in.setstate(ios_base::eofbit);
return __in;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#pragma empty_line
extern template class basic_istream<char>;
extern template istream& ws(istream&);
extern template istream& operator>>(istream&, char&);
extern template istream& operator>>(istream&, char*);
extern template istream& operator>>(istream&, unsigned char&);
extern template istream& operator>>(istream&, signed char&);
extern template istream& operator>>(istream&, unsigned char*);
extern template istream& operator>>(istream&, signed char*);
#pragma empty_line
extern template istream& istream::_M_extract(unsigned short&);
extern template istream& istream::_M_extract(unsigned int&);
extern template istream& istream::_M_extract(long&);
extern template istream& istream::_M_extract(unsigned long&);
extern template istream& istream::_M_extract(bool&);
#pragma empty_line
extern template istream& istream::_M_extract(long long&);
extern template istream& istream::_M_extract(unsigned long long&);
#pragma empty_line
extern template istream& istream::_M_extract(float&);
extern template istream& istream::_M_extract(double&);
extern template istream& istream::_M_extract(long double&);
extern template istream& istream::_M_extract(void*&);
#pragma empty_line
extern template class basic_iostream<char>;
#pragma empty_line
#pragma empty_line
extern template class basic_istream<wchar_t>;
extern template wistream& ws(wistream&);
extern template wistream& operator>>(wistream&, wchar_t&);
extern template wistream& operator>>(wistream&, wchar_t*);
#pragma empty_line
extern template wistream& wistream::_M_extract(unsigned short&);
extern template wistream& wistream::_M_extract(unsigned int&);
extern template wistream& wistream::_M_extract(long&);
extern template wistream& wistream::_M_extract(unsigned long&);
extern template wistream& wistream::_M_extract(bool&);
#pragma empty_line
extern template wistream& wistream::_M_extract(long long&);
extern template wistream& wistream::_M_extract(unsigned long long&);
#pragma empty_line
extern template wistream& wistream::_M_extract(float&);
extern template wistream& wistream::_M_extract(double&);
extern template wistream& wistream::_M_extract(long double&);
extern template wistream& wistream::_M_extract(void*&);
#pragma empty_line
extern template class basic_iostream<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 854 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\istream" 2 3
#pragma line 41 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin\\..\\lib\\clang\\3.1/../../../include/c++/4.5.2\\iostream" 2 3
#pragma empty_line
namespace std {
#pragma empty_line
/**
* @name Standard Stream Objects
*
* The <iostream> header declares the eight <em>standard stream
* objects</em>. For other declarations, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html
* and the @link iosfwd I/O forward declarations @endlink
*
* They are required by default to cooperate with the global C
* library's @c FILE streams, and to be available during program
* startup and termination. For more information, see the HOWTO
* linked to above.
*/
//@{
extern istream cin; ///< Linked to standard input
extern ostream cout; ///< Linked to standard output
extern ostream cerr; ///< Linked to standard error (unbuffered)
extern ostream clog; ///< Linked to standard error (buffered)
#pragma empty_line
#pragma empty_line
extern wistream wcin; ///< Linked to standard input
extern wostream wcout; ///< Linked to standard output
extern wostream wcerr; ///< Linked to standard error (unbuffered)
extern wostream wclog; ///< Linked to standard error (buffered)
#pragma empty_line
//@}
#pragma empty_line
// For construction of filebuffers for cout, cin, cerr, clog et. al.
static ios_base::Init __ioinit;
#pragma empty_line
}
#pragma line 23 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h" 2
extern "C" {
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 10 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 12 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 2 3
#pragma empty_line
#pragma empty_line
struct _exception;
#pragma empty_line
#pragma pack(push,_CRT_PACKING)
#pragma line 55 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* See also float.h */
#pragma empty_line
#pragma empty_line
/* IEEE 754 classication */
#pragma line 75 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double * _imp___HUGE;
#pragma line 91 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
struct _exception {
int type;
const char *name;
double arg1;
double arg2;
double retval;
};
#pragma empty_line
void __mingw_raise_matherr (int typ, const char *name, double a1, double a2,
double rslt);
void __mingw_setusermatherr (int ( *)(struct _exception *));
__attribute__ ((__dllimport__)) void __setusermatherr(int ( *)(struct _exception *));
#pragma empty_line
#pragma empty_line
#pragma empty_line
double sin(double _X);
double cos(double _X);
double tan(double _X);
double sinh(double _X);
double cosh(double _X);
double tanh(double _X);
double asin(double _X);
double acos(double _X);
double atan(double _X);
double atan2(double _Y,double _X);
double exp(double _X);
double log(double _X);
double log10(double _X);
double pow(double _X,double _Y);
double sqrt(double _X);
double ceil(double _X);
double floor(double _X);
double fabs(double _X);
#pragma line 135 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
double ldexp(double _X,int _Y);
double frexp(double _X,int *_Y);
double modf(double _X,double *_Y);
double fmod(double _X,double _Y);
#pragma empty_line
void sincos (double __x, double *p_sin, double *p_cos);
void sincosl (long double __x, long double *p_sin, long double *p_cos);
void sincosf (float __x, float *p_sin, float *p_cos);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int abs(int _X);
long labs(long _X);
#pragma empty_line
#pragma empty_line
#pragma empty_line
double atof(const char *_String);
double _atof_l(const char *_String,_locale_t _Locale);
#pragma line 162 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
struct _complex {
double x;
double y;
};
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) double _cabs(struct _complex _ComplexA);
double _hypot(double _X,double _Y);
__attribute__ ((__dllimport__)) double _j0(double _X);
__attribute__ ((__dllimport__)) double _j1(double _X);
__attribute__ ((__dllimport__)) double _jn(int _X,double _Y);
__attribute__ ((__dllimport__)) double _y0(double _X);
__attribute__ ((__dllimport__)) double _y1(double _X);
__attribute__ ((__dllimport__)) double _yn(int _X,double _Y);
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) int _matherr (struct _exception *);
#pragma empty_line
#pragma empty_line
/* These are also declared in Mingw float.h; needed here as well to work
around GCC build issues. */
/* BEGIN FLOAT.H COPY */
/*
* IEEE recommended functions
*/
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) double _chgsign (double _X);
__attribute__ ((__dllimport__)) double _copysign (double _Number,double _Sign);
__attribute__ ((__dllimport__)) double _logb (double);
__attribute__ ((__dllimport__)) double _nextafter (double, double);
__attribute__ ((__dllimport__)) double _scalb (double, long);
__attribute__ ((__dllimport__)) int _finite (double);
__attribute__ ((__dllimport__)) int _fpclass (double);
__attribute__ ((__dllimport__)) int _isnan (double);
#pragma empty_line
#pragma empty_line
/* END FLOAT.H COPY */
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) double j0 (double) ;
__attribute__ ((__dllimport__)) double j1 (double) ;
__attribute__ ((__dllimport__)) double jn (int, double) ;
__attribute__ ((__dllimport__)) double y0 (double) ;
__attribute__ ((__dllimport__)) double y1 (double) ;
__attribute__ ((__dllimport__)) double yn (int, double) ;
#pragma empty_line
__attribute__ ((__dllimport__)) double chgsign (double);
/*
* scalb() is a GCC built-in.
* Exclude this _scalb() stub; the semantics are incompatible
* with the built-in implementation.
*
_CRTIMP double __cdecl scalb (double, long);
*
*/
__attribute__ ((__dllimport__)) int finite (double);
__attribute__ ((__dllimport__)) int fpclass (double);
#pragma line 236 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
__attribute__ ((__dllimport__)) int _set_SSE2_enable(int _Flag);
#pragma line 260 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* Use the compiler's builtin define for FLT_EVAL_METHOD to
set float_t and double_t. */
#pragma empty_line
#pragma empty_line
typedef float float_t;
typedef double double_t;
#pragma line 278 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* 7.12.3.1 */
/*
Return values for fpclassify.
These are based on Intel x87 fpu condition codes
in the high byte of status word and differ from
the return values for MS IEEE 754 extension _fpclass()
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* 0x0200 is signbit mask */
#pragma empty_line
/*
We can't inline float or double, because we want to ensure truncation
to semantic type before classification.
(A normal long double value might become subnormal when
converted to double, and zero when converted to float.)
*/
#pragma empty_line
extern int __fpclassifyl (long double);
extern int __fpclassifyf (float);
extern int __fpclassify (double);
#pragma line 325 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* 7.12.3.2 */
#pragma empty_line
#pragma empty_line
/* 7.12.3.3 */
#pragma empty_line
#pragma empty_line
/* 7.12.3.4 */
/* We don't need to worry about truncation here:
A NaN stays a NaN. */
#pragma empty_line
extern int __isnan (double);
extern int __isnanf (float);
extern int __isnanl (long double);
#pragma line 372 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* 7.12.3.5 */
#pragma empty_line
#pragma empty_line
/* 7.12.3.6 The signbit macro */
extern int __signbit (double);
extern int __signbitf (float);
extern int __signbitl (long double);
#pragma line 403 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* 7.12.4 Trigonometric functions: Double in C89 */
extern float sinf(float _X);
extern long double sinl(long double);
#pragma empty_line
extern float cosf(float _X);
extern long double cosl(long double);
#pragma empty_line
extern float tanf(float _X);
extern long double tanl(long double);
extern float asinf(float _X);
extern long double asinl(long double);
#pragma empty_line
extern float acosf (float);
extern long double acosl (long double);
#pragma empty_line
extern float atanf (float);
extern long double atanl (long double);
#pragma empty_line
extern float atan2f (float, float);
extern long double atan2l (long double, long double);
#pragma empty_line
/* 7.12.5 Hyperbolic functions: Double in C89 */
extern float sinhf(float _X);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double sinhl(long double);
#pragma empty_line
extern float coshf(float _X);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double coshl(long double);
#pragma empty_line
extern float tanhf(float _X);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double tanhl(long double);
#pragma empty_line
/* Inverse hyperbolic trig functions */
/* 7.12.5.1 */
extern double acosh (double);
extern float acoshf (float);
extern long double acoshl (long double);
#pragma empty_line
/* 7.12.5.2 */
extern double asinh (double);
extern float asinhf (float);
extern long double asinhl (long double);
#pragma empty_line
/* 7.12.5.3 */
extern double atanh (double);
extern float atanhf (float);
extern long double atanhl (long double);
#pragma empty_line
/* Exponentials and logarithms */
/* 7.12.6.1 Double in C89 */
extern float expf(float _X);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double expl(long double);
#pragma empty_line
/* 7.12.6.2 */
extern double exp2(double);
extern float exp2f(float);
extern long double exp2l(long double);
#pragma empty_line
/* 7.12.6.3 The expm1 functions */
/* TODO: These could be inlined */
extern double expm1(double);
extern float expm1f(float);
extern long double expm1l(long double);
#pragma empty_line
/* 7.12.6.4 Double in C89 */
extern float frexpf(float _X,int *_Y);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double frexpl(long double,int *);
#pragma empty_line
/* 7.12.6.5 */
#pragma empty_line
#pragma empty_line
extern int ilogb (double);
extern int ilogbf (float);
extern int ilogbl (long double);
#pragma empty_line
/* 7.12.6.6 Double in C89 */
extern float ldexpf(float _X,int _Y);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double ldexpl (long double, int);
#pragma empty_line
/* 7.12.6.7 Double in C89 */
extern float logf (float);
extern long double logl(long double);
#pragma empty_line
/* 7.12.6.8 Double in C89 */
extern float log10f (float);
extern long double log10l(long double);
#pragma empty_line
/* 7.12.6.9 */
extern double log1p(double);
extern float log1pf(float);
extern long double log1pl(long double);
#pragma empty_line
/* 7.12.6.10 */
extern double log2 (double);
extern float log2f (float);
extern long double log2l (long double);
#pragma empty_line
/* 7.12.6.11 */
extern double logb (double);
extern float logbf (float);
extern long double logbl (long double);
#pragma empty_line
/* Inline versions. GCC-4.0+ can do a better fast-math optimization
with __builtins. */
#pragma line 552 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* 7.12.6.12 Double in C89 */
extern float modff (float, float*);
extern long double modfl (long double, long double*);
#pragma empty_line
/* 7.12.6.13 */
extern double scalbn (double, int);
extern float scalbnf (float, int);
extern long double scalbnl (long double, int);
#pragma empty_line
extern double scalbln (double, long);
extern float scalblnf (float, long);
extern long double scalblnl (long double, long);
#pragma empty_line
/* 7.12.7.1 */
/* Implementations adapted from Cephes versions */
extern double cbrt (double);
extern float cbrtf (float);
extern long double cbrtl (long double);
#pragma empty_line
/* 7.12.7.2 The fabs functions: Double in C89 */
extern float fabsf (float x);
#pragma line 583 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
extern long double fabsl (long double);
#pragma line 594 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* 7.12.7.3 */
extern double hypot (double, double) ; /* in libmoldname.a */
extern float hypotf (float x, float y);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double hypotl (long double, long double);
#pragma empty_line
/* 7.12.7.4 The pow functions. Double in C89 */
extern float powf(float _X,float _Y);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double powl (long double, long double);
#pragma empty_line
/* 7.12.7.5 The sqrt functions. Double in C89. */
extern float sqrtf (float);
extern long double sqrtl(long double);
#pragma empty_line
/* 7.12.8.1 The erf functions */
extern double erf (double);
extern float erff (float);
extern long double erfl (long double);
#pragma empty_line
/* 7.12.8.2 The erfc functions */
extern double erfc (double);
extern float erfcf (float);
extern long double erfcl (long double);
#pragma empty_line
/* 7.12.8.3 The lgamma functions */
extern double lgamma (double);
extern float lgammaf (float);
extern long double lgammal (long double);
#pragma empty_line
/* 7.12.8.4 The tgamma functions */
extern double tgamma (double);
extern float tgammaf (float);
extern long double tgammal (long double);
#pragma empty_line
/* 7.12.9.1 Double in C89 */
extern float ceilf (float);
extern long double ceill (long double);
#pragma empty_line
/* 7.12.9.2 Double in C89 */
extern float floorf (float);
extern long double floorl (long double);
#pragma empty_line
/* 7.12.9.3 */
extern double nearbyint ( double);
extern float nearbyintf (float);
extern long double nearbyintl (long double);
#pragma empty_line
/* 7.12.9.4 */
/* round, using fpu control word settings */
extern double rint (double);
extern float rintf (float);
extern long double rintl (long double);
#pragma empty_line
/* 7.12.9.5 */
extern long lrint (double);
extern long lrintf (float);
extern long lrintl (long double);
#pragma empty_line
__extension__ long long llrint (double);
__extension__ long long llrintf (float);
__extension__ long long llrintl (long double);
#pragma empty_line
/* Inline versions of above.
GCC 4.0+ can do a better fast-math job with __builtins. */
#pragma line 737 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
/* 7.12.9.6 */
/* round away from zero, regardless of fpu control word settings */
extern double round (double);
extern float roundf (float);
extern long double roundl (long double);
#pragma empty_line
/* 7.12.9.7 */
extern long lround (double);
extern long lroundf (float);
extern long lroundl (long double);
__extension__ long long llround (double);
__extension__ long long llroundf (float);
__extension__ long long llroundl (long double);
#pragma empty_line
/* 7.12.9.8 */
/* round towards zero, regardless of fpu control word settings */
extern double trunc (double);
extern float truncf (float);
extern long double truncl (long double);
#pragma empty_line
/* 7.12.10.1 Double in C89 */
extern float fmodf (float, float);
extern long double fmodl (long double, long double);
#pragma empty_line
/* 7.12.10.2 */
extern double remainder (double, double);
extern float remainderf (float, float);
extern long double remainderl (long double, long double);
#pragma empty_line
/* 7.12.10.3 */
extern double remquo(double, double, int *);
extern float remquof(float, float, int *);
extern long double remquol(long double, long double, int *);
#pragma empty_line
/* 7.12.11.1 */
extern double copysign (double, double); /* in libmoldname.a */
extern float copysignf (float, float);
extern long double copysignl (long double, long double);
#pragma empty_line
/* 7.12.11.2 Return a NaN */
extern double nan(const char *tagp);
extern float nanf(const char *tagp);
extern long double nanl(const char *tagp);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* 7.12.11.3 */
extern double nextafter (double, double); /* in libmoldname.a */
extern float nextafterf (float, float);
extern long double nextafterl (long double, long double);
#pragma empty_line
/* 7.12.11.4 The nexttoward functions */
extern double nexttoward (double, long double);
extern float nexttowardf (float, long double);
extern long double nexttowardl (long double, long double);
#pragma empty_line
/* 7.12.12.1 */
/* x > y ? (x - y) : 0.0 */
extern double fdim (double x, double y);
extern float fdimf (float x, float y);
extern long double fdiml (long double x, long double y);
#pragma empty_line
/* fmax and fmin.
NaN arguments are treated as missing data: if one argument is a NaN
and the other numeric, then these functions choose the numeric
value. */
#pragma empty_line
/* 7.12.12.2 */
extern double fmax (double, double);
extern float fmaxf (float, float);
extern long double fmaxl (long double, long double);
#pragma empty_line
/* 7.12.12.3 */
extern double fmin (double, double);
extern float fminf (float, float);
extern long double fminl (long double, long double);
#pragma empty_line
/* 7.12.13.1 */
/* return x * y + z as a ternary op */
extern double fma (double, double, double);
extern float fmaf (float, float, float);
extern long double fmal (long double, long double, long double);
#pragma empty_line
/* 7.12.14 */
/*
* With these functions, comparisons involving quiet NaNs set the FP
* condition code to "unordered". The IEEE floating-point spec
* dictates that the result of floating-point comparisons should be
* false whenever a NaN is involved, with the exception of the != op,
* which always returns true: yes, (NaN != NaN) is true).
*/
#pragma line 867 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
__attribute__ ((__dllimport__)) float _hypotf(float _X,float _Y);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__dllimport__)) float _copysignf (float _Number,float _Sign);
__attribute__ ((__dllimport__)) float _chgsignf (float _X);
__attribute__ ((__dllimport__)) float _logbf(float _X);
__attribute__ ((__dllimport__)) float _nextafterf(float _X,float _Y);
__attribute__ ((__dllimport__)) int _finitef(float _X);
__attribute__ ((__dllimport__)) int _isnanf(float _X);
__attribute__ ((__dllimport__)) int _fpclassf(float _X);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double _chgsignl (long double);
#pragma line 893 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\math.h" 3
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma pack(pop)
#pragma line 24 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h" 2
}
#pragma line 24 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 1 3 4
/*===---- limits.h - Standard header for integer sizes --------------------===*\
*
* Copyright (c) 2009 Chris Lattner
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
\*===----------------------------------------------------------------------===*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The system's limits.h may, in turn, try to #include_next GCC's limits.h.
Avert this #include_next madness. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* System headers include a number of constants from POSIX in <limits.h>.
Include it if we're hosted. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\limits.h" 1 3 4
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma empty_line
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3 4
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the w64 mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#pragma line 6 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*
* File system limits
*
* NOTE: Apparently the actual size of PATH_MAX is 260, but a space is
* required for the NUL. TODO: Test?
* NOTE: PATH_MAX is the POSIX equivalent for Microsoft's MAX_PATH; the two
* are semantically identical, with a limit of 259 characters for the
* path name, plus one for a terminating NUL, for a total of 260.
*/
#pragma line 38 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Many system headers try to "help us out" by defining these. No really, we
know how big each datatype is. */
#pragma line 60 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* C90/99 5.2.4.2.1 */
#pragma line 90 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* C99 5.2.4.2.1: Added long long. */
#pragma line 102 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/win64/tools/clang/bin/../lib/clang/3.1/include\\limits.h" 3 4
/* LONG_LONG_MIN/LONG_LONG_MAX/ULONG_LONG_MAX are a GNU extension. It's too bad
that we don't have something like #pragma poison that could be used to
deprecate a macro - the code should just use LLONG_MAX and friends.
*/
#pragma line 28 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* for safety*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* for safety*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*for safety*/
#pragma line 65 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
typedef unsigned long long ap_ulong;
typedef signed long long ap_slong;
#pragma line 83 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
/*support SC mode*/
#pragma line 101 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
extern "C" void _ssdm_string2bits(...);
//#ifdef C99STRING
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Basic AP data types.
----------------------------------------------------------------
*/
template<int _AP_N, bool _AP_S> struct ssdm_int;
#pragma line 138 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_dt.def" 1
#pragma empty_line
#pragma empty_line
template<> struct ssdm_int<1 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<2 + 1024 * 0,true> { int V __attribute__ ((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<2 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<3 + 1024 * 0,true> { int V __attribute__ ((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<3 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<4 + 1024 * 0,true> { int V __attribute__ ((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<4 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<5 + 1024 * 0,true> { int V __attribute__ ((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<5 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<6 + 1024 * 0,true> { int V __attribute__ ((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<6 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<7 + 1024 * 0,true> { int V __attribute__ ((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<7 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<8 + 1024 * 0,true> { int V __attribute__ ((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<8 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<9 + 1024 * 0,true> { int V __attribute__ ((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<9 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<10 + 1024 * 0,true> { int V __attribute__ ((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<10 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<11 + 1024 * 0,true> { int V __attribute__ ((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<11 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<12 + 1024 * 0,true> { int V __attribute__ ((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<12 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<13 + 1024 * 0,true> { int V __attribute__ ((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<13 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<14 + 1024 * 0,true> { int V __attribute__ ((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<14 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<15 + 1024 * 0,true> { int V __attribute__ ((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<15 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<16 + 1024 * 0,true> { int V __attribute__ ((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<16 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<17 + 1024 * 0,true> { int V __attribute__ ((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<17 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<18 + 1024 * 0,true> { int V __attribute__ ((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<18 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<19 + 1024 * 0,true> { int V __attribute__ ((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<19 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<20 + 1024 * 0,true> { int V __attribute__ ((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<20 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<21 + 1024 * 0,true> { int V __attribute__ ((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<21 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<22 + 1024 * 0,true> { int V __attribute__ ((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<22 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<23 + 1024 * 0,true> { int V __attribute__ ((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<23 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<24 + 1024 * 0,true> { int V __attribute__ ((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<24 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<25 + 1024 * 0,true> { int V __attribute__ ((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<25 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<26 + 1024 * 0,true> { int V __attribute__ ((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<26 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<27 + 1024 * 0,true> { int V __attribute__ ((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<27 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<28 + 1024 * 0,true> { int V __attribute__ ((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<28 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<29 + 1024 * 0,true> { int V __attribute__ ((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<29 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<30 + 1024 * 0,true> { int V __attribute__ ((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<30 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<31 + 1024 * 0,true> { int V __attribute__ ((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<31 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<32 + 1024 * 0,true> { int V __attribute__ ((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<32 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<33 + 1024 * 0,true> { int V __attribute__ ((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<33 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<34 + 1024 * 0,true> { int V __attribute__ ((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<34 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<35 + 1024 * 0,true> { int V __attribute__ ((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<35 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<36 + 1024 * 0,true> { int V __attribute__ ((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<36 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<37 + 1024 * 0,true> { int V __attribute__ ((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<37 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<38 + 1024 * 0,true> { int V __attribute__ ((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<38 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<39 + 1024 * 0,true> { int V __attribute__ ((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<39 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<40 + 1024 * 0,true> { int V __attribute__ ((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<40 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<41 + 1024 * 0,true> { int V __attribute__ ((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<41 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<42 + 1024 * 0,true> { int V __attribute__ ((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<42 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<43 + 1024 * 0,true> { int V __attribute__ ((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<43 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<44 + 1024 * 0,true> { int V __attribute__ ((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<44 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<45 + 1024 * 0,true> { int V __attribute__ ((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<45 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<46 + 1024 * 0,true> { int V __attribute__ ((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<46 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<47 + 1024 * 0,true> { int V __attribute__ ((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<47 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<48 + 1024 * 0,true> { int V __attribute__ ((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<48 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<49 + 1024 * 0,true> { int V __attribute__ ((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<49 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<50 + 1024 * 0,true> { int V __attribute__ ((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<50 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<51 + 1024 * 0,true> { int V __attribute__ ((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<51 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<52 + 1024 * 0,true> { int V __attribute__ ((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<52 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<53 + 1024 * 0,true> { int V __attribute__ ((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<53 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<54 + 1024 * 0,true> { int V __attribute__ ((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<54 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<55 + 1024 * 0,true> { int V __attribute__ ((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<55 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<56 + 1024 * 0,true> { int V __attribute__ ((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<56 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<57 + 1024 * 0,true> { int V __attribute__ ((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<57 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<58 + 1024 * 0,true> { int V __attribute__ ((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<58 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<59 + 1024 * 0,true> { int V __attribute__ ((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<59 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<60 + 1024 * 0,true> { int V __attribute__ ((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<60 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<61 + 1024 * 0,true> { int V __attribute__ ((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<61 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<62 + 1024 * 0,true> { int V __attribute__ ((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<62 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<63 + 1024 * 0,true> { int V __attribute__ ((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<63 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0 , false>() { }; };
#pragma empty_line
#pragma empty_line
template<> struct ssdm_int<64 + 1024 * 0,true> { int V __attribute__ ((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<64 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0 , false>() { }; };
#pragma empty_line
#pragma empty_line
/*#if AUTOPILOT_VERSION >= 1 */
#pragma empty_line
template<> struct ssdm_int<65 + 1024 * 0,true> { int V __attribute__ ((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<65 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<66 + 1024 * 0,true> { int V __attribute__ ((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<66 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<67 + 1024 * 0,true> { int V __attribute__ ((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<67 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<68 + 1024 * 0,true> { int V __attribute__ ((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<68 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<69 + 1024 * 0,true> { int V __attribute__ ((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<69 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<70 + 1024 * 0,true> { int V __attribute__ ((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<70 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<71 + 1024 * 0,true> { int V __attribute__ ((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<71 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<72 + 1024 * 0,true> { int V __attribute__ ((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<72 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<73 + 1024 * 0,true> { int V __attribute__ ((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<73 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<74 + 1024 * 0,true> { int V __attribute__ ((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<74 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<75 + 1024 * 0,true> { int V __attribute__ ((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<75 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<76 + 1024 * 0,true> { int V __attribute__ ((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<76 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<77 + 1024 * 0,true> { int V __attribute__ ((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<77 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<78 + 1024 * 0,true> { int V __attribute__ ((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<78 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<79 + 1024 * 0,true> { int V __attribute__ ((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<79 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<80 + 1024 * 0,true> { int V __attribute__ ((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<80 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<81 + 1024 * 0,true> { int V __attribute__ ((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<81 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<82 + 1024 * 0,true> { int V __attribute__ ((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<82 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<83 + 1024 * 0,true> { int V __attribute__ ((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<83 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<84 + 1024 * 0,true> { int V __attribute__ ((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<84 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<85 + 1024 * 0,true> { int V __attribute__ ((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<85 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<86 + 1024 * 0,true> { int V __attribute__ ((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<86 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<87 + 1024 * 0,true> { int V __attribute__ ((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<87 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<88 + 1024 * 0,true> { int V __attribute__ ((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<88 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<89 + 1024 * 0,true> { int V __attribute__ ((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<89 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<90 + 1024 * 0,true> { int V __attribute__ ((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<90 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<91 + 1024 * 0,true> { int V __attribute__ ((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<91 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<92 + 1024 * 0,true> { int V __attribute__ ((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<92 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<93 + 1024 * 0,true> { int V __attribute__ ((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<93 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<94 + 1024 * 0,true> { int V __attribute__ ((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<94 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<95 + 1024 * 0,true> { int V __attribute__ ((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<95 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<96 + 1024 * 0,true> { int V __attribute__ ((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<96 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<97 + 1024 * 0,true> { int V __attribute__ ((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<97 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<98 + 1024 * 0,true> { int V __attribute__ ((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<98 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<99 + 1024 * 0,true> { int V __attribute__ ((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<99 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<100 + 1024 * 0,true> { int V __attribute__ ((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<100 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<101 + 1024 * 0,true> { int V __attribute__ ((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<101 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<102 + 1024 * 0,true> { int V __attribute__ ((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<102 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<103 + 1024 * 0,true> { int V __attribute__ ((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<103 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<104 + 1024 * 0,true> { int V __attribute__ ((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<104 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<105 + 1024 * 0,true> { int V __attribute__ ((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<105 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<106 + 1024 * 0,true> { int V __attribute__ ((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<106 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<107 + 1024 * 0,true> { int V __attribute__ ((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<107 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<108 + 1024 * 0,true> { int V __attribute__ ((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<108 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<109 + 1024 * 0,true> { int V __attribute__ ((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<109 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<110 + 1024 * 0,true> { int V __attribute__ ((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<110 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<111 + 1024 * 0,true> { int V __attribute__ ((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<111 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<112 + 1024 * 0,true> { int V __attribute__ ((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<112 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<113 + 1024 * 0,true> { int V __attribute__ ((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<113 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<114 + 1024 * 0,true> { int V __attribute__ ((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<114 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<115 + 1024 * 0,true> { int V __attribute__ ((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<115 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<116 + 1024 * 0,true> { int V __attribute__ ((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<116 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<117 + 1024 * 0,true> { int V __attribute__ ((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<117 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<118 + 1024 * 0,true> { int V __attribute__ ((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<118 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<119 + 1024 * 0,true> { int V __attribute__ ((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<119 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<120 + 1024 * 0,true> { int V __attribute__ ((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<120 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<121 + 1024 * 0,true> { int V __attribute__ ((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<121 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<122 + 1024 * 0,true> { int V __attribute__ ((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<122 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<123 + 1024 * 0,true> { int V __attribute__ ((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<123 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<124 + 1024 * 0,true> { int V __attribute__ ((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<124 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<125 + 1024 * 0,true> { int V __attribute__ ((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<125 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<126 + 1024 * 0,true> { int V __attribute__ ((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<126 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<127 + 1024 * 0,true> { int V __attribute__ ((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<127 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<128 + 1024 * 0,true> { int V __attribute__ ((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<128 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0 , false>() { }; };
#pragma empty_line
/*#endif*/
#pragma empty_line
#pragma empty_line
/*#ifdef EXTENDED_GCC*/
#pragma empty_line
template<> struct ssdm_int<129 + 1024 * 0,true> { int V __attribute__ ((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<129 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<130 + 1024 * 0,true> { int V __attribute__ ((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<130 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<131 + 1024 * 0,true> { int V __attribute__ ((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<131 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<132 + 1024 * 0,true> { int V __attribute__ ((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<132 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<133 + 1024 * 0,true> { int V __attribute__ ((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<133 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<134 + 1024 * 0,true> { int V __attribute__ ((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<134 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<135 + 1024 * 0,true> { int V __attribute__ ((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<135 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<136 + 1024 * 0,true> { int V __attribute__ ((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<136 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<137 + 1024 * 0,true> { int V __attribute__ ((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<137 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<138 + 1024 * 0,true> { int V __attribute__ ((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<138 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<139 + 1024 * 0,true> { int V __attribute__ ((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<139 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<140 + 1024 * 0,true> { int V __attribute__ ((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<140 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<141 + 1024 * 0,true> { int V __attribute__ ((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<141 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<142 + 1024 * 0,true> { int V __attribute__ ((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<142 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<143 + 1024 * 0,true> { int V __attribute__ ((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<143 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<144 + 1024 * 0,true> { int V __attribute__ ((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<144 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<145 + 1024 * 0,true> { int V __attribute__ ((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<145 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<146 + 1024 * 0,true> { int V __attribute__ ((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<146 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<147 + 1024 * 0,true> { int V __attribute__ ((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<147 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<148 + 1024 * 0,true> { int V __attribute__ ((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<148 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<149 + 1024 * 0,true> { int V __attribute__ ((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<149 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<150 + 1024 * 0,true> { int V __attribute__ ((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<150 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<151 + 1024 * 0,true> { int V __attribute__ ((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<151 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<152 + 1024 * 0,true> { int V __attribute__ ((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<152 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<153 + 1024 * 0,true> { int V __attribute__ ((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<153 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<154 + 1024 * 0,true> { int V __attribute__ ((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<154 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<155 + 1024 * 0,true> { int V __attribute__ ((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<155 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<156 + 1024 * 0,true> { int V __attribute__ ((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<156 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<157 + 1024 * 0,true> { int V __attribute__ ((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<157 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<158 + 1024 * 0,true> { int V __attribute__ ((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<158 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<159 + 1024 * 0,true> { int V __attribute__ ((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<159 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<160 + 1024 * 0,true> { int V __attribute__ ((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<160 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<161 + 1024 * 0,true> { int V __attribute__ ((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<161 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<162 + 1024 * 0,true> { int V __attribute__ ((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<162 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<163 + 1024 * 0,true> { int V __attribute__ ((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<163 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<164 + 1024 * 0,true> { int V __attribute__ ((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<164 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<165 + 1024 * 0,true> { int V __attribute__ ((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<165 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<166 + 1024 * 0,true> { int V __attribute__ ((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<166 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<167 + 1024 * 0,true> { int V __attribute__ ((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<167 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<168 + 1024 * 0,true> { int V __attribute__ ((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<168 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<169 + 1024 * 0,true> { int V __attribute__ ((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<169 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<170 + 1024 * 0,true> { int V __attribute__ ((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<170 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<171 + 1024 * 0,true> { int V __attribute__ ((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<171 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<172 + 1024 * 0,true> { int V __attribute__ ((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<172 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<173 + 1024 * 0,true> { int V __attribute__ ((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<173 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<174 + 1024 * 0,true> { int V __attribute__ ((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<174 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<175 + 1024 * 0,true> { int V __attribute__ ((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<175 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<176 + 1024 * 0,true> { int V __attribute__ ((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<176 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<177 + 1024 * 0,true> { int V __attribute__ ((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<177 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<178 + 1024 * 0,true> { int V __attribute__ ((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<178 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<179 + 1024 * 0,true> { int V __attribute__ ((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<179 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<180 + 1024 * 0,true> { int V __attribute__ ((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<180 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<181 + 1024 * 0,true> { int V __attribute__ ((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<181 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<182 + 1024 * 0,true> { int V __attribute__ ((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<182 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<183 + 1024 * 0,true> { int V __attribute__ ((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<183 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<184 + 1024 * 0,true> { int V __attribute__ ((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<184 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<185 + 1024 * 0,true> { int V __attribute__ ((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<185 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<186 + 1024 * 0,true> { int V __attribute__ ((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<186 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<187 + 1024 * 0,true> { int V __attribute__ ((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<187 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<188 + 1024 * 0,true> { int V __attribute__ ((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<188 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<189 + 1024 * 0,true> { int V __attribute__ ((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<189 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<190 + 1024 * 0,true> { int V __attribute__ ((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<190 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<191 + 1024 * 0,true> { int V __attribute__ ((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<191 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<192 + 1024 * 0,true> { int V __attribute__ ((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<192 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<193 + 1024 * 0,true> { int V __attribute__ ((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<193 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<194 + 1024 * 0,true> { int V __attribute__ ((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<194 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<195 + 1024 * 0,true> { int V __attribute__ ((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<195 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<196 + 1024 * 0,true> { int V __attribute__ ((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<196 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<197 + 1024 * 0,true> { int V __attribute__ ((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<197 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<198 + 1024 * 0,true> { int V __attribute__ ((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<198 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<199 + 1024 * 0,true> { int V __attribute__ ((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<199 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<200 + 1024 * 0,true> { int V __attribute__ ((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<200 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<201 + 1024 * 0,true> { int V __attribute__ ((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<201 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<202 + 1024 * 0,true> { int V __attribute__ ((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<202 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<203 + 1024 * 0,true> { int V __attribute__ ((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<203 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<204 + 1024 * 0,true> { int V __attribute__ ((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<204 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<205 + 1024 * 0,true> { int V __attribute__ ((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<205 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<206 + 1024 * 0,true> { int V __attribute__ ((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<206 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<207 + 1024 * 0,true> { int V __attribute__ ((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<207 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<208 + 1024 * 0,true> { int V __attribute__ ((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<208 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<209 + 1024 * 0,true> { int V __attribute__ ((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<209 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<210 + 1024 * 0,true> { int V __attribute__ ((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<210 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<211 + 1024 * 0,true> { int V __attribute__ ((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<211 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<212 + 1024 * 0,true> { int V __attribute__ ((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<212 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<213 + 1024 * 0,true> { int V __attribute__ ((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<213 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<214 + 1024 * 0,true> { int V __attribute__ ((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<214 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<215 + 1024 * 0,true> { int V __attribute__ ((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<215 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<216 + 1024 * 0,true> { int V __attribute__ ((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<216 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<217 + 1024 * 0,true> { int V __attribute__ ((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<217 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<218 + 1024 * 0,true> { int V __attribute__ ((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<218 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<219 + 1024 * 0,true> { int V __attribute__ ((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<219 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<220 + 1024 * 0,true> { int V __attribute__ ((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<220 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<221 + 1024 * 0,true> { int V __attribute__ ((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<221 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<222 + 1024 * 0,true> { int V __attribute__ ((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<222 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<223 + 1024 * 0,true> { int V __attribute__ ((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<223 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<224 + 1024 * 0,true> { int V __attribute__ ((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<224 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<225 + 1024 * 0,true> { int V __attribute__ ((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<225 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<226 + 1024 * 0,true> { int V __attribute__ ((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<226 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<227 + 1024 * 0,true> { int V __attribute__ ((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<227 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<228 + 1024 * 0,true> { int V __attribute__ ((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<228 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<229 + 1024 * 0,true> { int V __attribute__ ((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<229 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<230 + 1024 * 0,true> { int V __attribute__ ((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<230 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<231 + 1024 * 0,true> { int V __attribute__ ((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<231 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<232 + 1024 * 0,true> { int V __attribute__ ((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<232 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<233 + 1024 * 0,true> { int V __attribute__ ((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<233 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<234 + 1024 * 0,true> { int V __attribute__ ((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<234 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<235 + 1024 * 0,true> { int V __attribute__ ((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<235 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<236 + 1024 * 0,true> { int V __attribute__ ((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<236 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<237 + 1024 * 0,true> { int V __attribute__ ((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<237 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<238 + 1024 * 0,true> { int V __attribute__ ((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<238 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<239 + 1024 * 0,true> { int V __attribute__ ((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<239 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<240 + 1024 * 0,true> { int V __attribute__ ((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<240 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<241 + 1024 * 0,true> { int V __attribute__ ((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<241 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<242 + 1024 * 0,true> { int V __attribute__ ((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<242 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<243 + 1024 * 0,true> { int V __attribute__ ((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<243 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<244 + 1024 * 0,true> { int V __attribute__ ((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<244 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<245 + 1024 * 0,true> { int V __attribute__ ((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<245 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<246 + 1024 * 0,true> { int V __attribute__ ((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<246 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<247 + 1024 * 0,true> { int V __attribute__ ((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<247 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<248 + 1024 * 0,true> { int V __attribute__ ((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<248 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<249 + 1024 * 0,true> { int V __attribute__ ((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<249 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<250 + 1024 * 0,true> { int V __attribute__ ((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<250 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<251 + 1024 * 0,true> { int V __attribute__ ((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<251 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<252 + 1024 * 0,true> { int V __attribute__ ((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<252 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<253 + 1024 * 0,true> { int V __attribute__ ((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<253 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<254 + 1024 * 0,true> { int V __attribute__ ((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<254 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<255 + 1024 * 0,true> { int V __attribute__ ((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<255 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<256 + 1024 * 0,true> { int V __attribute__ ((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<256 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<257 + 1024 * 0,true> { int V __attribute__ ((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<257 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<258 + 1024 * 0,true> { int V __attribute__ ((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<258 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<259 + 1024 * 0,true> { int V __attribute__ ((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<259 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<260 + 1024 * 0,true> { int V __attribute__ ((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<260 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<261 + 1024 * 0,true> { int V __attribute__ ((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<261 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<262 + 1024 * 0,true> { int V __attribute__ ((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<262 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<263 + 1024 * 0,true> { int V __attribute__ ((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<263 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<264 + 1024 * 0,true> { int V __attribute__ ((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<264 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<265 + 1024 * 0,true> { int V __attribute__ ((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<265 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<266 + 1024 * 0,true> { int V __attribute__ ((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<266 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<267 + 1024 * 0,true> { int V __attribute__ ((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<267 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<268 + 1024 * 0,true> { int V __attribute__ ((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<268 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<269 + 1024 * 0,true> { int V __attribute__ ((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<269 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<270 + 1024 * 0,true> { int V __attribute__ ((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<270 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<271 + 1024 * 0,true> { int V __attribute__ ((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<271 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<272 + 1024 * 0,true> { int V __attribute__ ((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<272 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<273 + 1024 * 0,true> { int V __attribute__ ((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<273 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<274 + 1024 * 0,true> { int V __attribute__ ((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<274 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<275 + 1024 * 0,true> { int V __attribute__ ((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<275 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<276 + 1024 * 0,true> { int V __attribute__ ((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<276 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<277 + 1024 * 0,true> { int V __attribute__ ((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<277 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<278 + 1024 * 0,true> { int V __attribute__ ((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<278 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<279 + 1024 * 0,true> { int V __attribute__ ((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<279 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<280 + 1024 * 0,true> { int V __attribute__ ((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<280 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<281 + 1024 * 0,true> { int V __attribute__ ((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<281 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<282 + 1024 * 0,true> { int V __attribute__ ((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<282 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<283 + 1024 * 0,true> { int V __attribute__ ((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<283 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<284 + 1024 * 0,true> { int V __attribute__ ((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<284 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<285 + 1024 * 0,true> { int V __attribute__ ((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<285 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<286 + 1024 * 0,true> { int V __attribute__ ((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<286 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<287 + 1024 * 0,true> { int V __attribute__ ((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<287 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<288 + 1024 * 0,true> { int V __attribute__ ((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<288 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<289 + 1024 * 0,true> { int V __attribute__ ((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<289 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<290 + 1024 * 0,true> { int V __attribute__ ((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<290 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<291 + 1024 * 0,true> { int V __attribute__ ((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<291 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<292 + 1024 * 0,true> { int V __attribute__ ((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<292 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<293 + 1024 * 0,true> { int V __attribute__ ((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<293 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<294 + 1024 * 0,true> { int V __attribute__ ((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<294 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<295 + 1024 * 0,true> { int V __attribute__ ((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<295 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<296 + 1024 * 0,true> { int V __attribute__ ((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<296 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<297 + 1024 * 0,true> { int V __attribute__ ((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<297 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<298 + 1024 * 0,true> { int V __attribute__ ((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<298 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<299 + 1024 * 0,true> { int V __attribute__ ((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<299 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<300 + 1024 * 0,true> { int V __attribute__ ((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<300 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<301 + 1024 * 0,true> { int V __attribute__ ((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<301 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<302 + 1024 * 0,true> { int V __attribute__ ((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<302 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<303 + 1024 * 0,true> { int V __attribute__ ((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<303 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<304 + 1024 * 0,true> { int V __attribute__ ((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<304 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<305 + 1024 * 0,true> { int V __attribute__ ((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<305 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<306 + 1024 * 0,true> { int V __attribute__ ((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<306 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<307 + 1024 * 0,true> { int V __attribute__ ((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<307 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<308 + 1024 * 0,true> { int V __attribute__ ((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<308 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<309 + 1024 * 0,true> { int V __attribute__ ((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<309 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<310 + 1024 * 0,true> { int V __attribute__ ((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<310 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<311 + 1024 * 0,true> { int V __attribute__ ((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<311 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<312 + 1024 * 0,true> { int V __attribute__ ((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<312 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<313 + 1024 * 0,true> { int V __attribute__ ((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<313 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<314 + 1024 * 0,true> { int V __attribute__ ((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<314 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<315 + 1024 * 0,true> { int V __attribute__ ((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<315 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<316 + 1024 * 0,true> { int V __attribute__ ((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<316 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<317 + 1024 * 0,true> { int V __attribute__ ((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<317 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<318 + 1024 * 0,true> { int V __attribute__ ((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<318 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<319 + 1024 * 0,true> { int V __attribute__ ((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<319 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<320 + 1024 * 0,true> { int V __attribute__ ((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<320 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<321 + 1024 * 0,true> { int V __attribute__ ((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<321 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<322 + 1024 * 0,true> { int V __attribute__ ((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<322 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<323 + 1024 * 0,true> { int V __attribute__ ((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<323 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<324 + 1024 * 0,true> { int V __attribute__ ((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<324 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<325 + 1024 * 0,true> { int V __attribute__ ((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<325 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<326 + 1024 * 0,true> { int V __attribute__ ((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<326 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<327 + 1024 * 0,true> { int V __attribute__ ((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<327 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<328 + 1024 * 0,true> { int V __attribute__ ((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<328 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<329 + 1024 * 0,true> { int V __attribute__ ((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<329 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<330 + 1024 * 0,true> { int V __attribute__ ((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<330 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<331 + 1024 * 0,true> { int V __attribute__ ((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<331 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<332 + 1024 * 0,true> { int V __attribute__ ((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<332 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<333 + 1024 * 0,true> { int V __attribute__ ((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<333 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<334 + 1024 * 0,true> { int V __attribute__ ((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<334 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<335 + 1024 * 0,true> { int V __attribute__ ((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<335 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<336 + 1024 * 0,true> { int V __attribute__ ((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<336 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<337 + 1024 * 0,true> { int V __attribute__ ((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<337 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<338 + 1024 * 0,true> { int V __attribute__ ((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<338 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<339 + 1024 * 0,true> { int V __attribute__ ((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<339 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<340 + 1024 * 0,true> { int V __attribute__ ((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<340 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<341 + 1024 * 0,true> { int V __attribute__ ((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<341 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<342 + 1024 * 0,true> { int V __attribute__ ((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<342 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<343 + 1024 * 0,true> { int V __attribute__ ((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<343 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<344 + 1024 * 0,true> { int V __attribute__ ((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<344 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<345 + 1024 * 0,true> { int V __attribute__ ((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<345 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<346 + 1024 * 0,true> { int V __attribute__ ((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<346 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<347 + 1024 * 0,true> { int V __attribute__ ((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<347 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<348 + 1024 * 0,true> { int V __attribute__ ((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<348 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<349 + 1024 * 0,true> { int V __attribute__ ((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<349 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<350 + 1024 * 0,true> { int V __attribute__ ((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<350 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<351 + 1024 * 0,true> { int V __attribute__ ((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<351 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<352 + 1024 * 0,true> { int V __attribute__ ((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<352 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<353 + 1024 * 0,true> { int V __attribute__ ((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<353 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<354 + 1024 * 0,true> { int V __attribute__ ((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<354 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<355 + 1024 * 0,true> { int V __attribute__ ((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<355 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<356 + 1024 * 0,true> { int V __attribute__ ((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<356 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<357 + 1024 * 0,true> { int V __attribute__ ((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<357 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<358 + 1024 * 0,true> { int V __attribute__ ((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<358 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<359 + 1024 * 0,true> { int V __attribute__ ((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<359 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<360 + 1024 * 0,true> { int V __attribute__ ((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<360 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<361 + 1024 * 0,true> { int V __attribute__ ((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<361 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<362 + 1024 * 0,true> { int V __attribute__ ((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<362 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<363 + 1024 * 0,true> { int V __attribute__ ((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<363 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<364 + 1024 * 0,true> { int V __attribute__ ((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<364 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<365 + 1024 * 0,true> { int V __attribute__ ((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<365 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<366 + 1024 * 0,true> { int V __attribute__ ((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<366 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<367 + 1024 * 0,true> { int V __attribute__ ((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<367 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<368 + 1024 * 0,true> { int V __attribute__ ((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<368 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<369 + 1024 * 0,true> { int V __attribute__ ((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<369 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<370 + 1024 * 0,true> { int V __attribute__ ((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<370 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<371 + 1024 * 0,true> { int V __attribute__ ((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<371 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<372 + 1024 * 0,true> { int V __attribute__ ((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<372 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<373 + 1024 * 0,true> { int V __attribute__ ((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<373 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<374 + 1024 * 0,true> { int V __attribute__ ((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<374 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<375 + 1024 * 0,true> { int V __attribute__ ((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<375 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<376 + 1024 * 0,true> { int V __attribute__ ((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<376 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<377 + 1024 * 0,true> { int V __attribute__ ((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<377 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<378 + 1024 * 0,true> { int V __attribute__ ((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<378 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<379 + 1024 * 0,true> { int V __attribute__ ((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<379 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<380 + 1024 * 0,true> { int V __attribute__ ((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<380 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<381 + 1024 * 0,true> { int V __attribute__ ((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<381 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<382 + 1024 * 0,true> { int V __attribute__ ((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<382 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<383 + 1024 * 0,true> { int V __attribute__ ((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<383 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<384 + 1024 * 0,true> { int V __attribute__ ((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<384 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<385 + 1024 * 0,true> { int V __attribute__ ((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<385 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<386 + 1024 * 0,true> { int V __attribute__ ((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<386 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<387 + 1024 * 0,true> { int V __attribute__ ((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<387 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<388 + 1024 * 0,true> { int V __attribute__ ((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<388 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<389 + 1024 * 0,true> { int V __attribute__ ((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<389 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<390 + 1024 * 0,true> { int V __attribute__ ((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<390 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<391 + 1024 * 0,true> { int V __attribute__ ((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<391 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<392 + 1024 * 0,true> { int V __attribute__ ((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<392 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<393 + 1024 * 0,true> { int V __attribute__ ((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<393 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<394 + 1024 * 0,true> { int V __attribute__ ((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<394 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<395 + 1024 * 0,true> { int V __attribute__ ((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<395 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<396 + 1024 * 0,true> { int V __attribute__ ((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<396 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<397 + 1024 * 0,true> { int V __attribute__ ((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<397 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<398 + 1024 * 0,true> { int V __attribute__ ((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<398 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<399 + 1024 * 0,true> { int V __attribute__ ((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<399 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<400 + 1024 * 0,true> { int V __attribute__ ((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<400 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<401 + 1024 * 0,true> { int V __attribute__ ((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<401 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<402 + 1024 * 0,true> { int V __attribute__ ((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<402 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<403 + 1024 * 0,true> { int V __attribute__ ((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<403 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<404 + 1024 * 0,true> { int V __attribute__ ((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<404 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<405 + 1024 * 0,true> { int V __attribute__ ((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<405 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<406 + 1024 * 0,true> { int V __attribute__ ((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<406 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<407 + 1024 * 0,true> { int V __attribute__ ((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<407 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<408 + 1024 * 0,true> { int V __attribute__ ((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<408 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<409 + 1024 * 0,true> { int V __attribute__ ((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<409 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<410 + 1024 * 0,true> { int V __attribute__ ((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<410 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<411 + 1024 * 0,true> { int V __attribute__ ((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<411 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<412 + 1024 * 0,true> { int V __attribute__ ((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<412 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<413 + 1024 * 0,true> { int V __attribute__ ((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<413 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<414 + 1024 * 0,true> { int V __attribute__ ((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<414 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<415 + 1024 * 0,true> { int V __attribute__ ((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<415 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<416 + 1024 * 0,true> { int V __attribute__ ((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<416 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<417 + 1024 * 0,true> { int V __attribute__ ((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<417 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<418 + 1024 * 0,true> { int V __attribute__ ((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<418 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<419 + 1024 * 0,true> { int V __attribute__ ((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<419 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<420 + 1024 * 0,true> { int V __attribute__ ((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<420 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<421 + 1024 * 0,true> { int V __attribute__ ((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<421 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<422 + 1024 * 0,true> { int V __attribute__ ((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<422 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<423 + 1024 * 0,true> { int V __attribute__ ((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<423 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<424 + 1024 * 0,true> { int V __attribute__ ((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<424 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<425 + 1024 * 0,true> { int V __attribute__ ((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<425 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<426 + 1024 * 0,true> { int V __attribute__ ((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<426 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<427 + 1024 * 0,true> { int V __attribute__ ((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<427 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<428 + 1024 * 0,true> { int V __attribute__ ((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<428 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<429 + 1024 * 0,true> { int V __attribute__ ((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<429 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<430 + 1024 * 0,true> { int V __attribute__ ((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<430 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<431 + 1024 * 0,true> { int V __attribute__ ((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<431 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<432 + 1024 * 0,true> { int V __attribute__ ((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<432 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<433 + 1024 * 0,true> { int V __attribute__ ((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<433 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<434 + 1024 * 0,true> { int V __attribute__ ((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<434 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<435 + 1024 * 0,true> { int V __attribute__ ((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<435 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<436 + 1024 * 0,true> { int V __attribute__ ((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<436 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<437 + 1024 * 0,true> { int V __attribute__ ((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<437 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<438 + 1024 * 0,true> { int V __attribute__ ((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<438 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<439 + 1024 * 0,true> { int V __attribute__ ((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<439 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<440 + 1024 * 0,true> { int V __attribute__ ((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<440 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<441 + 1024 * 0,true> { int V __attribute__ ((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<441 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<442 + 1024 * 0,true> { int V __attribute__ ((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<442 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<443 + 1024 * 0,true> { int V __attribute__ ((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<443 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<444 + 1024 * 0,true> { int V __attribute__ ((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<444 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<445 + 1024 * 0,true> { int V __attribute__ ((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<445 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<446 + 1024 * 0,true> { int V __attribute__ ((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<446 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<447 + 1024 * 0,true> { int V __attribute__ ((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<447 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<448 + 1024 * 0,true> { int V __attribute__ ((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<448 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<449 + 1024 * 0,true> { int V __attribute__ ((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<449 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<450 + 1024 * 0,true> { int V __attribute__ ((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<450 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<451 + 1024 * 0,true> { int V __attribute__ ((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<451 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<452 + 1024 * 0,true> { int V __attribute__ ((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<452 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<453 + 1024 * 0,true> { int V __attribute__ ((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<453 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<454 + 1024 * 0,true> { int V __attribute__ ((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<454 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<455 + 1024 * 0,true> { int V __attribute__ ((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<455 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<456 + 1024 * 0,true> { int V __attribute__ ((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<456 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<457 + 1024 * 0,true> { int V __attribute__ ((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<457 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<458 + 1024 * 0,true> { int V __attribute__ ((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<458 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<459 + 1024 * 0,true> { int V __attribute__ ((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<459 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<460 + 1024 * 0,true> { int V __attribute__ ((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<460 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<461 + 1024 * 0,true> { int V __attribute__ ((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<461 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<462 + 1024 * 0,true> { int V __attribute__ ((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<462 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<463 + 1024 * 0,true> { int V __attribute__ ((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<463 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<464 + 1024 * 0,true> { int V __attribute__ ((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<464 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<465 + 1024 * 0,true> { int V __attribute__ ((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<465 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<466 + 1024 * 0,true> { int V __attribute__ ((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<466 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<467 + 1024 * 0,true> { int V __attribute__ ((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<467 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<468 + 1024 * 0,true> { int V __attribute__ ((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<468 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<469 + 1024 * 0,true> { int V __attribute__ ((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<469 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<470 + 1024 * 0,true> { int V __attribute__ ((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<470 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<471 + 1024 * 0,true> { int V __attribute__ ((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<471 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<472 + 1024 * 0,true> { int V __attribute__ ((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<472 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<473 + 1024 * 0,true> { int V __attribute__ ((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<473 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<474 + 1024 * 0,true> { int V __attribute__ ((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<474 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<475 + 1024 * 0,true> { int V __attribute__ ((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<475 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<476 + 1024 * 0,true> { int V __attribute__ ((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<476 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<477 + 1024 * 0,true> { int V __attribute__ ((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<477 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<478 + 1024 * 0,true> { int V __attribute__ ((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<478 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<479 + 1024 * 0,true> { int V __attribute__ ((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<479 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<480 + 1024 * 0,true> { int V __attribute__ ((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<480 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<481 + 1024 * 0,true> { int V __attribute__ ((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<481 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<482 + 1024 * 0,true> { int V __attribute__ ((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<482 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<483 + 1024 * 0,true> { int V __attribute__ ((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<483 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<484 + 1024 * 0,true> { int V __attribute__ ((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<484 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<485 + 1024 * 0,true> { int V __attribute__ ((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<485 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<486 + 1024 * 0,true> { int V __attribute__ ((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<486 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<487 + 1024 * 0,true> { int V __attribute__ ((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<487 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<488 + 1024 * 0,true> { int V __attribute__ ((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<488 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<489 + 1024 * 0,true> { int V __attribute__ ((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<489 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<490 + 1024 * 0,true> { int V __attribute__ ((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<490 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<491 + 1024 * 0,true> { int V __attribute__ ((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<491 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<492 + 1024 * 0,true> { int V __attribute__ ((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<492 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<493 + 1024 * 0,true> { int V __attribute__ ((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<493 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<494 + 1024 * 0,true> { int V __attribute__ ((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<494 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<495 + 1024 * 0,true> { int V __attribute__ ((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<495 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<496 + 1024 * 0,true> { int V __attribute__ ((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<496 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<497 + 1024 * 0,true> { int V __attribute__ ((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<497 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<498 + 1024 * 0,true> { int V __attribute__ ((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<498 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<499 + 1024 * 0,true> { int V __attribute__ ((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<499 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<500 + 1024 * 0,true> { int V __attribute__ ((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<500 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<501 + 1024 * 0,true> { int V __attribute__ ((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<501 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<502 + 1024 * 0,true> { int V __attribute__ ((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<502 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<503 + 1024 * 0,true> { int V __attribute__ ((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<503 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<504 + 1024 * 0,true> { int V __attribute__ ((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<504 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<505 + 1024 * 0,true> { int V __attribute__ ((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<505 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<506 + 1024 * 0,true> { int V __attribute__ ((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<506 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<507 + 1024 * 0,true> { int V __attribute__ ((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<507 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<508 + 1024 * 0,true> { int V __attribute__ ((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<508 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<509 + 1024 * 0,true> { int V __attribute__ ((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<509 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<510 + 1024 * 0,true> { int V __attribute__ ((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<510 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<511 + 1024 * 0,true> { int V __attribute__ ((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<511 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<512 + 1024 * 0,true> { int V __attribute__ ((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<512 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<513 + 1024 * 0,true> { int V __attribute__ ((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<513 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<514 + 1024 * 0,true> { int V __attribute__ ((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<514 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<515 + 1024 * 0,true> { int V __attribute__ ((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<515 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<516 + 1024 * 0,true> { int V __attribute__ ((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<516 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<517 + 1024 * 0,true> { int V __attribute__ ((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<517 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<518 + 1024 * 0,true> { int V __attribute__ ((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<518 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<519 + 1024 * 0,true> { int V __attribute__ ((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<519 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<520 + 1024 * 0,true> { int V __attribute__ ((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<520 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<521 + 1024 * 0,true> { int V __attribute__ ((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<521 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<522 + 1024 * 0,true> { int V __attribute__ ((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<522 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<523 + 1024 * 0,true> { int V __attribute__ ((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<523 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<524 + 1024 * 0,true> { int V __attribute__ ((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<524 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<525 + 1024 * 0,true> { int V __attribute__ ((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<525 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<526 + 1024 * 0,true> { int V __attribute__ ((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<526 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<527 + 1024 * 0,true> { int V __attribute__ ((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<527 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<528 + 1024 * 0,true> { int V __attribute__ ((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<528 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<529 + 1024 * 0,true> { int V __attribute__ ((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<529 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<530 + 1024 * 0,true> { int V __attribute__ ((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<530 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<531 + 1024 * 0,true> { int V __attribute__ ((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<531 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<532 + 1024 * 0,true> { int V __attribute__ ((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<532 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<533 + 1024 * 0,true> { int V __attribute__ ((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<533 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<534 + 1024 * 0,true> { int V __attribute__ ((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<534 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<535 + 1024 * 0,true> { int V __attribute__ ((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<535 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<536 + 1024 * 0,true> { int V __attribute__ ((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<536 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<537 + 1024 * 0,true> { int V __attribute__ ((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<537 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<538 + 1024 * 0,true> { int V __attribute__ ((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<538 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<539 + 1024 * 0,true> { int V __attribute__ ((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<539 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<540 + 1024 * 0,true> { int V __attribute__ ((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<540 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<541 + 1024 * 0,true> { int V __attribute__ ((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<541 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<542 + 1024 * 0,true> { int V __attribute__ ((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<542 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<543 + 1024 * 0,true> { int V __attribute__ ((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<543 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<544 + 1024 * 0,true> { int V __attribute__ ((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<544 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<545 + 1024 * 0,true> { int V __attribute__ ((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<545 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<546 + 1024 * 0,true> { int V __attribute__ ((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<546 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<547 + 1024 * 0,true> { int V __attribute__ ((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<547 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<548 + 1024 * 0,true> { int V __attribute__ ((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<548 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<549 + 1024 * 0,true> { int V __attribute__ ((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<549 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<550 + 1024 * 0,true> { int V __attribute__ ((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<550 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<551 + 1024 * 0,true> { int V __attribute__ ((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<551 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<552 + 1024 * 0,true> { int V __attribute__ ((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<552 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<553 + 1024 * 0,true> { int V __attribute__ ((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<553 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<554 + 1024 * 0,true> { int V __attribute__ ((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<554 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<555 + 1024 * 0,true> { int V __attribute__ ((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<555 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<556 + 1024 * 0,true> { int V __attribute__ ((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<556 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<557 + 1024 * 0,true> { int V __attribute__ ((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<557 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<558 + 1024 * 0,true> { int V __attribute__ ((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<558 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<559 + 1024 * 0,true> { int V __attribute__ ((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<559 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<560 + 1024 * 0,true> { int V __attribute__ ((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<560 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<561 + 1024 * 0,true> { int V __attribute__ ((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<561 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<562 + 1024 * 0,true> { int V __attribute__ ((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<562 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<563 + 1024 * 0,true> { int V __attribute__ ((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<563 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<564 + 1024 * 0,true> { int V __attribute__ ((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<564 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<565 + 1024 * 0,true> { int V __attribute__ ((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<565 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<566 + 1024 * 0,true> { int V __attribute__ ((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<566 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<567 + 1024 * 0,true> { int V __attribute__ ((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<567 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<568 + 1024 * 0,true> { int V __attribute__ ((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<568 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<569 + 1024 * 0,true> { int V __attribute__ ((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<569 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<570 + 1024 * 0,true> { int V __attribute__ ((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<570 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<571 + 1024 * 0,true> { int V __attribute__ ((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<571 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<572 + 1024 * 0,true> { int V __attribute__ ((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<572 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<573 + 1024 * 0,true> { int V __attribute__ ((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<573 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<574 + 1024 * 0,true> { int V __attribute__ ((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<574 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<575 + 1024 * 0,true> { int V __attribute__ ((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<575 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<576 + 1024 * 0,true> { int V __attribute__ ((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<576 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<577 + 1024 * 0,true> { int V __attribute__ ((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<577 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<578 + 1024 * 0,true> { int V __attribute__ ((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<578 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<579 + 1024 * 0,true> { int V __attribute__ ((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<579 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<580 + 1024 * 0,true> { int V __attribute__ ((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<580 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<581 + 1024 * 0,true> { int V __attribute__ ((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<581 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<582 + 1024 * 0,true> { int V __attribute__ ((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<582 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<583 + 1024 * 0,true> { int V __attribute__ ((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<583 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<584 + 1024 * 0,true> { int V __attribute__ ((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<584 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<585 + 1024 * 0,true> { int V __attribute__ ((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<585 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<586 + 1024 * 0,true> { int V __attribute__ ((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<586 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<587 + 1024 * 0,true> { int V __attribute__ ((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<587 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<588 + 1024 * 0,true> { int V __attribute__ ((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<588 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<589 + 1024 * 0,true> { int V __attribute__ ((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<589 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<590 + 1024 * 0,true> { int V __attribute__ ((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<590 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<591 + 1024 * 0,true> { int V __attribute__ ((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<591 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<592 + 1024 * 0,true> { int V __attribute__ ((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<592 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<593 + 1024 * 0,true> { int V __attribute__ ((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<593 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<594 + 1024 * 0,true> { int V __attribute__ ((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<594 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<595 + 1024 * 0,true> { int V __attribute__ ((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<595 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<596 + 1024 * 0,true> { int V __attribute__ ((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<596 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<597 + 1024 * 0,true> { int V __attribute__ ((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<597 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<598 + 1024 * 0,true> { int V __attribute__ ((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<598 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<599 + 1024 * 0,true> { int V __attribute__ ((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<599 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<600 + 1024 * 0,true> { int V __attribute__ ((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<600 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<601 + 1024 * 0,true> { int V __attribute__ ((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<601 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<602 + 1024 * 0,true> { int V __attribute__ ((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<602 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<603 + 1024 * 0,true> { int V __attribute__ ((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<603 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<604 + 1024 * 0,true> { int V __attribute__ ((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<604 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<605 + 1024 * 0,true> { int V __attribute__ ((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<605 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<606 + 1024 * 0,true> { int V __attribute__ ((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<606 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<607 + 1024 * 0,true> { int V __attribute__ ((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<607 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<608 + 1024 * 0,true> { int V __attribute__ ((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<608 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<609 + 1024 * 0,true> { int V __attribute__ ((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<609 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<610 + 1024 * 0,true> { int V __attribute__ ((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<610 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<611 + 1024 * 0,true> { int V __attribute__ ((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<611 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<612 + 1024 * 0,true> { int V __attribute__ ((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<612 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<613 + 1024 * 0,true> { int V __attribute__ ((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<613 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<614 + 1024 * 0,true> { int V __attribute__ ((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<614 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<615 + 1024 * 0,true> { int V __attribute__ ((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<615 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<616 + 1024 * 0,true> { int V __attribute__ ((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<616 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<617 + 1024 * 0,true> { int V __attribute__ ((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<617 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<618 + 1024 * 0,true> { int V __attribute__ ((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<618 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<619 + 1024 * 0,true> { int V __attribute__ ((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<619 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<620 + 1024 * 0,true> { int V __attribute__ ((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<620 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<621 + 1024 * 0,true> { int V __attribute__ ((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<621 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<622 + 1024 * 0,true> { int V __attribute__ ((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<622 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<623 + 1024 * 0,true> { int V __attribute__ ((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<623 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<624 + 1024 * 0,true> { int V __attribute__ ((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<624 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<625 + 1024 * 0,true> { int V __attribute__ ((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<625 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<626 + 1024 * 0,true> { int V __attribute__ ((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<626 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<627 + 1024 * 0,true> { int V __attribute__ ((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<627 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<628 + 1024 * 0,true> { int V __attribute__ ((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<628 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<629 + 1024 * 0,true> { int V __attribute__ ((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<629 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<630 + 1024 * 0,true> { int V __attribute__ ((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<630 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<631 + 1024 * 0,true> { int V __attribute__ ((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<631 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<632 + 1024 * 0,true> { int V __attribute__ ((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<632 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<633 + 1024 * 0,true> { int V __attribute__ ((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<633 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<634 + 1024 * 0,true> { int V __attribute__ ((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<634 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<635 + 1024 * 0,true> { int V __attribute__ ((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<635 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<636 + 1024 * 0,true> { int V __attribute__ ((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<636 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<637 + 1024 * 0,true> { int V __attribute__ ((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<637 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<638 + 1024 * 0,true> { int V __attribute__ ((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<638 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<639 + 1024 * 0,true> { int V __attribute__ ((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<639 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<640 + 1024 * 0,true> { int V __attribute__ ((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<640 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<641 + 1024 * 0,true> { int V __attribute__ ((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<641 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<642 + 1024 * 0,true> { int V __attribute__ ((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<642 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<643 + 1024 * 0,true> { int V __attribute__ ((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<643 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<644 + 1024 * 0,true> { int V __attribute__ ((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<644 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<645 + 1024 * 0,true> { int V __attribute__ ((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<645 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<646 + 1024 * 0,true> { int V __attribute__ ((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<646 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<647 + 1024 * 0,true> { int V __attribute__ ((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<647 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<648 + 1024 * 0,true> { int V __attribute__ ((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<648 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<649 + 1024 * 0,true> { int V __attribute__ ((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<649 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<650 + 1024 * 0,true> { int V __attribute__ ((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<650 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<651 + 1024 * 0,true> { int V __attribute__ ((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<651 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<652 + 1024 * 0,true> { int V __attribute__ ((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<652 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<653 + 1024 * 0,true> { int V __attribute__ ((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<653 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<654 + 1024 * 0,true> { int V __attribute__ ((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<654 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<655 + 1024 * 0,true> { int V __attribute__ ((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<655 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<656 + 1024 * 0,true> { int V __attribute__ ((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<656 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<657 + 1024 * 0,true> { int V __attribute__ ((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<657 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<658 + 1024 * 0,true> { int V __attribute__ ((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<658 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<659 + 1024 * 0,true> { int V __attribute__ ((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<659 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<660 + 1024 * 0,true> { int V __attribute__ ((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<660 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<661 + 1024 * 0,true> { int V __attribute__ ((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<661 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<662 + 1024 * 0,true> { int V __attribute__ ((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<662 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<663 + 1024 * 0,true> { int V __attribute__ ((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<663 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<664 + 1024 * 0,true> { int V __attribute__ ((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<664 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<665 + 1024 * 0,true> { int V __attribute__ ((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<665 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<666 + 1024 * 0,true> { int V __attribute__ ((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<666 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<667 + 1024 * 0,true> { int V __attribute__ ((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<667 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<668 + 1024 * 0,true> { int V __attribute__ ((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<668 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<669 + 1024 * 0,true> { int V __attribute__ ((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<669 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<670 + 1024 * 0,true> { int V __attribute__ ((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<670 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<671 + 1024 * 0,true> { int V __attribute__ ((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<671 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<672 + 1024 * 0,true> { int V __attribute__ ((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<672 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<673 + 1024 * 0,true> { int V __attribute__ ((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<673 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<674 + 1024 * 0,true> { int V __attribute__ ((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<674 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<675 + 1024 * 0,true> { int V __attribute__ ((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<675 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<676 + 1024 * 0,true> { int V __attribute__ ((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<676 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<677 + 1024 * 0,true> { int V __attribute__ ((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<677 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<678 + 1024 * 0,true> { int V __attribute__ ((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<678 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<679 + 1024 * 0,true> { int V __attribute__ ((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<679 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<680 + 1024 * 0,true> { int V __attribute__ ((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<680 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<681 + 1024 * 0,true> { int V __attribute__ ((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<681 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<682 + 1024 * 0,true> { int V __attribute__ ((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<682 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<683 + 1024 * 0,true> { int V __attribute__ ((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<683 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<684 + 1024 * 0,true> { int V __attribute__ ((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<684 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<685 + 1024 * 0,true> { int V __attribute__ ((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<685 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<686 + 1024 * 0,true> { int V __attribute__ ((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<686 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<687 + 1024 * 0,true> { int V __attribute__ ((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<687 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<688 + 1024 * 0,true> { int V __attribute__ ((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<688 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<689 + 1024 * 0,true> { int V __attribute__ ((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<689 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<690 + 1024 * 0,true> { int V __attribute__ ((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<690 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<691 + 1024 * 0,true> { int V __attribute__ ((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<691 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<692 + 1024 * 0,true> { int V __attribute__ ((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<692 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<693 + 1024 * 0,true> { int V __attribute__ ((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<693 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<694 + 1024 * 0,true> { int V __attribute__ ((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<694 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<695 + 1024 * 0,true> { int V __attribute__ ((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<695 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<696 + 1024 * 0,true> { int V __attribute__ ((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<696 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<697 + 1024 * 0,true> { int V __attribute__ ((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<697 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<698 + 1024 * 0,true> { int V __attribute__ ((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<698 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<699 + 1024 * 0,true> { int V __attribute__ ((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<699 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<700 + 1024 * 0,true> { int V __attribute__ ((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<700 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<701 + 1024 * 0,true> { int V __attribute__ ((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<701 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<702 + 1024 * 0,true> { int V __attribute__ ((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<702 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<703 + 1024 * 0,true> { int V __attribute__ ((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<703 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<704 + 1024 * 0,true> { int V __attribute__ ((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<704 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<705 + 1024 * 0,true> { int V __attribute__ ((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<705 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<706 + 1024 * 0,true> { int V __attribute__ ((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<706 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<707 + 1024 * 0,true> { int V __attribute__ ((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<707 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<708 + 1024 * 0,true> { int V __attribute__ ((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<708 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<709 + 1024 * 0,true> { int V __attribute__ ((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<709 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<710 + 1024 * 0,true> { int V __attribute__ ((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<710 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<711 + 1024 * 0,true> { int V __attribute__ ((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<711 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<712 + 1024 * 0,true> { int V __attribute__ ((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<712 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<713 + 1024 * 0,true> { int V __attribute__ ((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<713 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<714 + 1024 * 0,true> { int V __attribute__ ((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<714 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<715 + 1024 * 0,true> { int V __attribute__ ((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<715 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<716 + 1024 * 0,true> { int V __attribute__ ((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<716 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<717 + 1024 * 0,true> { int V __attribute__ ((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<717 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<718 + 1024 * 0,true> { int V __attribute__ ((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<718 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<719 + 1024 * 0,true> { int V __attribute__ ((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<719 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<720 + 1024 * 0,true> { int V __attribute__ ((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<720 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<721 + 1024 * 0,true> { int V __attribute__ ((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<721 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<722 + 1024 * 0,true> { int V __attribute__ ((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<722 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<723 + 1024 * 0,true> { int V __attribute__ ((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<723 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<724 + 1024 * 0,true> { int V __attribute__ ((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<724 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<725 + 1024 * 0,true> { int V __attribute__ ((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<725 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<726 + 1024 * 0,true> { int V __attribute__ ((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<726 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<727 + 1024 * 0,true> { int V __attribute__ ((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<727 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<728 + 1024 * 0,true> { int V __attribute__ ((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<728 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<729 + 1024 * 0,true> { int V __attribute__ ((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<729 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<730 + 1024 * 0,true> { int V __attribute__ ((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<730 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<731 + 1024 * 0,true> { int V __attribute__ ((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<731 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<732 + 1024 * 0,true> { int V __attribute__ ((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<732 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<733 + 1024 * 0,true> { int V __attribute__ ((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<733 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<734 + 1024 * 0,true> { int V __attribute__ ((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<734 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<735 + 1024 * 0,true> { int V __attribute__ ((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<735 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<736 + 1024 * 0,true> { int V __attribute__ ((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<736 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<737 + 1024 * 0,true> { int V __attribute__ ((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<737 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<738 + 1024 * 0,true> { int V __attribute__ ((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<738 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<739 + 1024 * 0,true> { int V __attribute__ ((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<739 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<740 + 1024 * 0,true> { int V __attribute__ ((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<740 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<741 + 1024 * 0,true> { int V __attribute__ ((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<741 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<742 + 1024 * 0,true> { int V __attribute__ ((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<742 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<743 + 1024 * 0,true> { int V __attribute__ ((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<743 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<744 + 1024 * 0,true> { int V __attribute__ ((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<744 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<745 + 1024 * 0,true> { int V __attribute__ ((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<745 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<746 + 1024 * 0,true> { int V __attribute__ ((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<746 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<747 + 1024 * 0,true> { int V __attribute__ ((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<747 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<748 + 1024 * 0,true> { int V __attribute__ ((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<748 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<749 + 1024 * 0,true> { int V __attribute__ ((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<749 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<750 + 1024 * 0,true> { int V __attribute__ ((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<750 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<751 + 1024 * 0,true> { int V __attribute__ ((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<751 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<752 + 1024 * 0,true> { int V __attribute__ ((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<752 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<753 + 1024 * 0,true> { int V __attribute__ ((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<753 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<754 + 1024 * 0,true> { int V __attribute__ ((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<754 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<755 + 1024 * 0,true> { int V __attribute__ ((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<755 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<756 + 1024 * 0,true> { int V __attribute__ ((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<756 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<757 + 1024 * 0,true> { int V __attribute__ ((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<757 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<758 + 1024 * 0,true> { int V __attribute__ ((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<758 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<759 + 1024 * 0,true> { int V __attribute__ ((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<759 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<760 + 1024 * 0,true> { int V __attribute__ ((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<760 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<761 + 1024 * 0,true> { int V __attribute__ ((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<761 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<762 + 1024 * 0,true> { int V __attribute__ ((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<762 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<763 + 1024 * 0,true> { int V __attribute__ ((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<763 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<764 + 1024 * 0,true> { int V __attribute__ ((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<764 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<765 + 1024 * 0,true> { int V __attribute__ ((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<765 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<766 + 1024 * 0,true> { int V __attribute__ ((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<766 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<767 + 1024 * 0,true> { int V __attribute__ ((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<767 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<768 + 1024 * 0,true> { int V __attribute__ ((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<768 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<769 + 1024 * 0,true> { int V __attribute__ ((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<769 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<770 + 1024 * 0,true> { int V __attribute__ ((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<770 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<771 + 1024 * 0,true> { int V __attribute__ ((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<771 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<772 + 1024 * 0,true> { int V __attribute__ ((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<772 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<773 + 1024 * 0,true> { int V __attribute__ ((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<773 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<774 + 1024 * 0,true> { int V __attribute__ ((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<774 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<775 + 1024 * 0,true> { int V __attribute__ ((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<775 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<776 + 1024 * 0,true> { int V __attribute__ ((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<776 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<777 + 1024 * 0,true> { int V __attribute__ ((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<777 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<778 + 1024 * 0,true> { int V __attribute__ ((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<778 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<779 + 1024 * 0,true> { int V __attribute__ ((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<779 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<780 + 1024 * 0,true> { int V __attribute__ ((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<780 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<781 + 1024 * 0,true> { int V __attribute__ ((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<781 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<782 + 1024 * 0,true> { int V __attribute__ ((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<782 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<783 + 1024 * 0,true> { int V __attribute__ ((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<783 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<784 + 1024 * 0,true> { int V __attribute__ ((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<784 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<785 + 1024 * 0,true> { int V __attribute__ ((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<785 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<786 + 1024 * 0,true> { int V __attribute__ ((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<786 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<787 + 1024 * 0,true> { int V __attribute__ ((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<787 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<788 + 1024 * 0,true> { int V __attribute__ ((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<788 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<789 + 1024 * 0,true> { int V __attribute__ ((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<789 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<790 + 1024 * 0,true> { int V __attribute__ ((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<790 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<791 + 1024 * 0,true> { int V __attribute__ ((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<791 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<792 + 1024 * 0,true> { int V __attribute__ ((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<792 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<793 + 1024 * 0,true> { int V __attribute__ ((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<793 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<794 + 1024 * 0,true> { int V __attribute__ ((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<794 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<795 + 1024 * 0,true> { int V __attribute__ ((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<795 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<796 + 1024 * 0,true> { int V __attribute__ ((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<796 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<797 + 1024 * 0,true> { int V __attribute__ ((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<797 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<798 + 1024 * 0,true> { int V __attribute__ ((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<798 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<799 + 1024 * 0,true> { int V __attribute__ ((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<799 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<800 + 1024 * 0,true> { int V __attribute__ ((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<800 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<801 + 1024 * 0,true> { int V __attribute__ ((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<801 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<802 + 1024 * 0,true> { int V __attribute__ ((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<802 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<803 + 1024 * 0,true> { int V __attribute__ ((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<803 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<804 + 1024 * 0,true> { int V __attribute__ ((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<804 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<805 + 1024 * 0,true> { int V __attribute__ ((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<805 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<806 + 1024 * 0,true> { int V __attribute__ ((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<806 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<807 + 1024 * 0,true> { int V __attribute__ ((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<807 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<808 + 1024 * 0,true> { int V __attribute__ ((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<808 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<809 + 1024 * 0,true> { int V __attribute__ ((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<809 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<810 + 1024 * 0,true> { int V __attribute__ ((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<810 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<811 + 1024 * 0,true> { int V __attribute__ ((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<811 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<812 + 1024 * 0,true> { int V __attribute__ ((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<812 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<813 + 1024 * 0,true> { int V __attribute__ ((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<813 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<814 + 1024 * 0,true> { int V __attribute__ ((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<814 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<815 + 1024 * 0,true> { int V __attribute__ ((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<815 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<816 + 1024 * 0,true> { int V __attribute__ ((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<816 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<817 + 1024 * 0,true> { int V __attribute__ ((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<817 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<818 + 1024 * 0,true> { int V __attribute__ ((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<818 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<819 + 1024 * 0,true> { int V __attribute__ ((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<819 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<820 + 1024 * 0,true> { int V __attribute__ ((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<820 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<821 + 1024 * 0,true> { int V __attribute__ ((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<821 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<822 + 1024 * 0,true> { int V __attribute__ ((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<822 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<823 + 1024 * 0,true> { int V __attribute__ ((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<823 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<824 + 1024 * 0,true> { int V __attribute__ ((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<824 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<825 + 1024 * 0,true> { int V __attribute__ ((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<825 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<826 + 1024 * 0,true> { int V __attribute__ ((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<826 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<827 + 1024 * 0,true> { int V __attribute__ ((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<827 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<828 + 1024 * 0,true> { int V __attribute__ ((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<828 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<829 + 1024 * 0,true> { int V __attribute__ ((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<829 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<830 + 1024 * 0,true> { int V __attribute__ ((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<830 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<831 + 1024 * 0,true> { int V __attribute__ ((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<831 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<832 + 1024 * 0,true> { int V __attribute__ ((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<832 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<833 + 1024 * 0,true> { int V __attribute__ ((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<833 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<834 + 1024 * 0,true> { int V __attribute__ ((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<834 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<835 + 1024 * 0,true> { int V __attribute__ ((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<835 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<836 + 1024 * 0,true> { int V __attribute__ ((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<836 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<837 + 1024 * 0,true> { int V __attribute__ ((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<837 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<838 + 1024 * 0,true> { int V __attribute__ ((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<838 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<839 + 1024 * 0,true> { int V __attribute__ ((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<839 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<840 + 1024 * 0,true> { int V __attribute__ ((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<840 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<841 + 1024 * 0,true> { int V __attribute__ ((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<841 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<842 + 1024 * 0,true> { int V __attribute__ ((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<842 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<843 + 1024 * 0,true> { int V __attribute__ ((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<843 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<844 + 1024 * 0,true> { int V __attribute__ ((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<844 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<845 + 1024 * 0,true> { int V __attribute__ ((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<845 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<846 + 1024 * 0,true> { int V __attribute__ ((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<846 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<847 + 1024 * 0,true> { int V __attribute__ ((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<847 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<848 + 1024 * 0,true> { int V __attribute__ ((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<848 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<849 + 1024 * 0,true> { int V __attribute__ ((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<849 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<850 + 1024 * 0,true> { int V __attribute__ ((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<850 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<851 + 1024 * 0,true> { int V __attribute__ ((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<851 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<852 + 1024 * 0,true> { int V __attribute__ ((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<852 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<853 + 1024 * 0,true> { int V __attribute__ ((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<853 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<854 + 1024 * 0,true> { int V __attribute__ ((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<854 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<855 + 1024 * 0,true> { int V __attribute__ ((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<855 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<856 + 1024 * 0,true> { int V __attribute__ ((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<856 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<857 + 1024 * 0,true> { int V __attribute__ ((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<857 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<858 + 1024 * 0,true> { int V __attribute__ ((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<858 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<859 + 1024 * 0,true> { int V __attribute__ ((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<859 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<860 + 1024 * 0,true> { int V __attribute__ ((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<860 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<861 + 1024 * 0,true> { int V __attribute__ ((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<861 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<862 + 1024 * 0,true> { int V __attribute__ ((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<862 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<863 + 1024 * 0,true> { int V __attribute__ ((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<863 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<864 + 1024 * 0,true> { int V __attribute__ ((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<864 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<865 + 1024 * 0,true> { int V __attribute__ ((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<865 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<866 + 1024 * 0,true> { int V __attribute__ ((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<866 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<867 + 1024 * 0,true> { int V __attribute__ ((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<867 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<868 + 1024 * 0,true> { int V __attribute__ ((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<868 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<869 + 1024 * 0,true> { int V __attribute__ ((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<869 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<870 + 1024 * 0,true> { int V __attribute__ ((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<870 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<871 + 1024 * 0,true> { int V __attribute__ ((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<871 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<872 + 1024 * 0,true> { int V __attribute__ ((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<872 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<873 + 1024 * 0,true> { int V __attribute__ ((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<873 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<874 + 1024 * 0,true> { int V __attribute__ ((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<874 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<875 + 1024 * 0,true> { int V __attribute__ ((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<875 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<876 + 1024 * 0,true> { int V __attribute__ ((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<876 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<877 + 1024 * 0,true> { int V __attribute__ ((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<877 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<878 + 1024 * 0,true> { int V __attribute__ ((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<878 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<879 + 1024 * 0,true> { int V __attribute__ ((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<879 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<880 + 1024 * 0,true> { int V __attribute__ ((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<880 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<881 + 1024 * 0,true> { int V __attribute__ ((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<881 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<882 + 1024 * 0,true> { int V __attribute__ ((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<882 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<883 + 1024 * 0,true> { int V __attribute__ ((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<883 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<884 + 1024 * 0,true> { int V __attribute__ ((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<884 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<885 + 1024 * 0,true> { int V __attribute__ ((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<885 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<886 + 1024 * 0,true> { int V __attribute__ ((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<886 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<887 + 1024 * 0,true> { int V __attribute__ ((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<887 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<888 + 1024 * 0,true> { int V __attribute__ ((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<888 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<889 + 1024 * 0,true> { int V __attribute__ ((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<889 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<890 + 1024 * 0,true> { int V __attribute__ ((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<890 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<891 + 1024 * 0,true> { int V __attribute__ ((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<891 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<892 + 1024 * 0,true> { int V __attribute__ ((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<892 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<893 + 1024 * 0,true> { int V __attribute__ ((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<893 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<894 + 1024 * 0,true> { int V __attribute__ ((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<894 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<895 + 1024 * 0,true> { int V __attribute__ ((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<895 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<896 + 1024 * 0,true> { int V __attribute__ ((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<896 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<897 + 1024 * 0,true> { int V __attribute__ ((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<897 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<898 + 1024 * 0,true> { int V __attribute__ ((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<898 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<899 + 1024 * 0,true> { int V __attribute__ ((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<899 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<900 + 1024 * 0,true> { int V __attribute__ ((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<900 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<901 + 1024 * 0,true> { int V __attribute__ ((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<901 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<902 + 1024 * 0,true> { int V __attribute__ ((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<902 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<903 + 1024 * 0,true> { int V __attribute__ ((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<903 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<904 + 1024 * 0,true> { int V __attribute__ ((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<904 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<905 + 1024 * 0,true> { int V __attribute__ ((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<905 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<906 + 1024 * 0,true> { int V __attribute__ ((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<906 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<907 + 1024 * 0,true> { int V __attribute__ ((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<907 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<908 + 1024 * 0,true> { int V __attribute__ ((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<908 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<909 + 1024 * 0,true> { int V __attribute__ ((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<909 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<910 + 1024 * 0,true> { int V __attribute__ ((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<910 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<911 + 1024 * 0,true> { int V __attribute__ ((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<911 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<912 + 1024 * 0,true> { int V __attribute__ ((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<912 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<913 + 1024 * 0,true> { int V __attribute__ ((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<913 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<914 + 1024 * 0,true> { int V __attribute__ ((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<914 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<915 + 1024 * 0,true> { int V __attribute__ ((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<915 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<916 + 1024 * 0,true> { int V __attribute__ ((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<916 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<917 + 1024 * 0,true> { int V __attribute__ ((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<917 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<918 + 1024 * 0,true> { int V __attribute__ ((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<918 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<919 + 1024 * 0,true> { int V __attribute__ ((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<919 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<920 + 1024 * 0,true> { int V __attribute__ ((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<920 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<921 + 1024 * 0,true> { int V __attribute__ ((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<921 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<922 + 1024 * 0,true> { int V __attribute__ ((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<922 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<923 + 1024 * 0,true> { int V __attribute__ ((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<923 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<924 + 1024 * 0,true> { int V __attribute__ ((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<924 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<925 + 1024 * 0,true> { int V __attribute__ ((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<925 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<926 + 1024 * 0,true> { int V __attribute__ ((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<926 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<927 + 1024 * 0,true> { int V __attribute__ ((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<927 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<928 + 1024 * 0,true> { int V __attribute__ ((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<928 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<929 + 1024 * 0,true> { int V __attribute__ ((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<929 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<930 + 1024 * 0,true> { int V __attribute__ ((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<930 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<931 + 1024 * 0,true> { int V __attribute__ ((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<931 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<932 + 1024 * 0,true> { int V __attribute__ ((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<932 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<933 + 1024 * 0,true> { int V __attribute__ ((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<933 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<934 + 1024 * 0,true> { int V __attribute__ ((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<934 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<935 + 1024 * 0,true> { int V __attribute__ ((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<935 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<936 + 1024 * 0,true> { int V __attribute__ ((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<936 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<937 + 1024 * 0,true> { int V __attribute__ ((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<937 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<938 + 1024 * 0,true> { int V __attribute__ ((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<938 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<939 + 1024 * 0,true> { int V __attribute__ ((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<939 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<940 + 1024 * 0,true> { int V __attribute__ ((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<940 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<941 + 1024 * 0,true> { int V __attribute__ ((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<941 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<942 + 1024 * 0,true> { int V __attribute__ ((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<942 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<943 + 1024 * 0,true> { int V __attribute__ ((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<943 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<944 + 1024 * 0,true> { int V __attribute__ ((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<944 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<945 + 1024 * 0,true> { int V __attribute__ ((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<945 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<946 + 1024 * 0,true> { int V __attribute__ ((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<946 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<947 + 1024 * 0,true> { int V __attribute__ ((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<947 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<948 + 1024 * 0,true> { int V __attribute__ ((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<948 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<949 + 1024 * 0,true> { int V __attribute__ ((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<949 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<950 + 1024 * 0,true> { int V __attribute__ ((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<950 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<951 + 1024 * 0,true> { int V __attribute__ ((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<951 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<952 + 1024 * 0,true> { int V __attribute__ ((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<952 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<953 + 1024 * 0,true> { int V __attribute__ ((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<953 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<954 + 1024 * 0,true> { int V __attribute__ ((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<954 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<955 + 1024 * 0,true> { int V __attribute__ ((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<955 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<956 + 1024 * 0,true> { int V __attribute__ ((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<956 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<957 + 1024 * 0,true> { int V __attribute__ ((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<957 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<958 + 1024 * 0,true> { int V __attribute__ ((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<958 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<959 + 1024 * 0,true> { int V __attribute__ ((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<959 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<960 + 1024 * 0,true> { int V __attribute__ ((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<960 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<961 + 1024 * 0,true> { int V __attribute__ ((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<961 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<962 + 1024 * 0,true> { int V __attribute__ ((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<962 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<963 + 1024 * 0,true> { int V __attribute__ ((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<963 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<964 + 1024 * 0,true> { int V __attribute__ ((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<964 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<965 + 1024 * 0,true> { int V __attribute__ ((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<965 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<966 + 1024 * 0,true> { int V __attribute__ ((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<966 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<967 + 1024 * 0,true> { int V __attribute__ ((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<967 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<968 + 1024 * 0,true> { int V __attribute__ ((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<968 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<969 + 1024 * 0,true> { int V __attribute__ ((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<969 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<970 + 1024 * 0,true> { int V __attribute__ ((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<970 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<971 + 1024 * 0,true> { int V __attribute__ ((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<971 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<972 + 1024 * 0,true> { int V __attribute__ ((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<972 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<973 + 1024 * 0,true> { int V __attribute__ ((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<973 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<974 + 1024 * 0,true> { int V __attribute__ ((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<974 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<975 + 1024 * 0,true> { int V __attribute__ ((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<975 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<976 + 1024 * 0,true> { int V __attribute__ ((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<976 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<977 + 1024 * 0,true> { int V __attribute__ ((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<977 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<978 + 1024 * 0,true> { int V __attribute__ ((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<978 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<979 + 1024 * 0,true> { int V __attribute__ ((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<979 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<980 + 1024 * 0,true> { int V __attribute__ ((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<980 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<981 + 1024 * 0,true> { int V __attribute__ ((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<981 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<982 + 1024 * 0,true> { int V __attribute__ ((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<982 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<983 + 1024 * 0,true> { int V __attribute__ ((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<983 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<984 + 1024 * 0,true> { int V __attribute__ ((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<984 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<985 + 1024 * 0,true> { int V __attribute__ ((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<985 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<986 + 1024 * 0,true> { int V __attribute__ ((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<986 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<987 + 1024 * 0,true> { int V __attribute__ ((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<987 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<988 + 1024 * 0,true> { int V __attribute__ ((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<988 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<989 + 1024 * 0,true> { int V __attribute__ ((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<989 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<990 + 1024 * 0,true> { int V __attribute__ ((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<990 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<991 + 1024 * 0,true> { int V __attribute__ ((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<991 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<992 + 1024 * 0,true> { int V __attribute__ ((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<992 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<993 + 1024 * 0,true> { int V __attribute__ ((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<993 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<994 + 1024 * 0,true> { int V __attribute__ ((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<994 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<995 + 1024 * 0,true> { int V __attribute__ ((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<995 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<996 + 1024 * 0,true> { int V __attribute__ ((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<996 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<997 + 1024 * 0,true> { int V __attribute__ ((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<997 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<998 + 1024 * 0,true> { int V __attribute__ ((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<998 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<999 + 1024 * 0,true> { int V __attribute__ ((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<999 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1000 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1000 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1001 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1001 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1002 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1002 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1003 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1003 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1004 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1004 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1005 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1005 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1006 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1006 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1007 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1007 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1008 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1008 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1009 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1009 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1010 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1010 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1011 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1011 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1012 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1012 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1013 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1013 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1014 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1014 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1015 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1015 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1016 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1016 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1017 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1017 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1018 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1018 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1019 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1019 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1020 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1020 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1021 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1021 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1022 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1022 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1023 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1023 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1024 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1024 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0 , false>() { }; };
#pragma line 139 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h" 2
#pragma line 557 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
enum BaseMode { SC_BIN=2, SC_OCT=8, SC_DEC=10, SC_HEX=16 };
#pragma line 600 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h" 1
/* autopilot_ssdm_bits.h */
/*
* __VIVADO_HLS_COPYRIGHT-INFO__
*
* $Id$
*/
#pragma line 52 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Concatination ----------------*/
#pragma line 62 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Bit get/set ----------------*/
#pragma line 83 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Part get/set ----------------*/
#pragma empty_line
/* GetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 97 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* SetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 110 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Reduce operations ----------------*/
#pragma line 146 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- String-Integer conversions ----------------*/
#pragma line 312 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 601 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h" 2
#pragma empty_line
#pragma empty_line
/* Forward declaration.*/
template<int _AP_W, bool _AP_S, bool _AP_C = (_AP_W <= 64)>
struct ap_int_base;
template<int _AP_W, bool _AP_S> struct ap_range_ref;
template<int _AP_W, bool _AP_S> struct ap_bit_ref;
template<int _AP_W> struct ap_uint;
template<int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2> struct ap_concat_ref;
#pragma empty_line
enum ap_q_mode {
SC_RND, // rounding to plus infinity
SC_RND_ZERO, // rounding to zero
SC_RND_MIN_INF, // rounding to minus infinity
SC_RND_INF, // rounding to infinity
SC_RND_CONV, // convergent rounding
SC_TRN, // truncation
SC_TRN_ZERO // truncation to zero
#pragma empty_line
};
enum ap_o_mode {
SC_SAT, // saturation
SC_SAT_ZERO, // saturation to zero
SC_SAT_SYM, // symmetrical saturation
SC_WRAP, // wrap-around (*)
SC_WRAP_SM // sign magnitude wrap-around (*)
};
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> struct ap_fixed_base;
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> struct af_range_ref;
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> struct af_bit_ref;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Concatination reference.
----------------------------------------------------------------
*/
template<int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2>
struct ap_concat_ref {
enum { _AP_WR = _AP_W1+_AP_W2, };
#pragma empty_line
_AP_T1& mbv1;
_AP_T2& mbv2;
#pragma empty_line
inline __attribute__((always_inline)) ap_concat_ref(const ap_concat_ref<_AP_W1, _AP_T1,
_AP_W2, _AP_T2>& ref):
mbv1(ref.mbv1), mbv2(ref.mbv2) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_concat_ref( _AP_T1& bv1, _AP_T2& bv2) : mbv1(bv1), mbv2(bv2) { }
#pragma empty_line
#pragma empty_line
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_int_base<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1+_AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1,false> Part1;
Part1.V = ({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), W_ref2, W_ref1+W_ref2-1); __Result__; });
mbv1.set(Part1);
ap_int_base<_AP_W2,false> Part2;
Part2.V = ({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, W_ref2-1); __Result__; });
mbv2.set(Part2);
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_concat_ref& operator = (unsigned long long val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
#pragma empty_line
/*template<typename _AP_T3>
INLINE ap_concat_ref& operator = ( const _AP_T3& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator=<_AP_W1+_AP_W2,false>(tmpVal);
}*/
template<int _AP_W3, typename _AP_T3, int _AP_W4, typename _AP_T4>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_concat_ref<_AP_W1,_AP_T1,_AP_W2,_AP_T2>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_bit_ref<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_range_ref<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
#pragma empty_line
template<int _AP_W3, int _AP_I3, bool _AP_S3,
ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator= (const af_range_ref<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator = ((const ap_int_base<_AP_W3, false>)(val));
}
#pragma empty_line
template<int _AP_W3, int _AP_I3, bool _AP_S3,
ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator= (const ap_fixed_base<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator = (val.to_ap_int_base());
}
#pragma empty_line
template<int _AP_W3, int _AP_I3, bool _AP_S3,
ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator= (const af_bit_ref<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator=((unsigned long long)(bool)(val));
}
inline __attribute__((always_inline)) operator ap_int_base<_AP_WR, false> () const {
return get();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long long () const {
return get().to_uint64();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_range_ref<_AP_W3, _AP_S3> >
operator, (const ap_range_ref<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_range_ref<_AP_W3, _AP_S3> >(*this,
const_cast<ap_range_ref<_AP_W3, _AP_S3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (ap_int_base<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this, a2);
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (volatile ap_int_base<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this,
const_cast<ap_int_base<_AP_W3, _AP_S3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (const ap_int_base<_AP_W3, _AP_S3>& a2) {
ap_int_base<_AP_W3,_AP_S3> op(a2);
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this,
const_cast<ap_int_base<_AP_W3, _AP_S3>& >(op));
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (const volatile ap_int_base<_AP_W3, _AP_S3>& a2) {
ap_int_base<_AP_W3,_AP_S3> op(a2);
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this,
const_cast<ap_int_base<_AP_W3, _AP_S3>& >(op));
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, 1, ap_bit_ref<_AP_W3, _AP_S3> >
operator, (const ap_bit_ref<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
1, ap_bit_ref<_AP_W3, _AP_S3> >(*this,
const_cast<ap_bit_ref<_AP_W3, _AP_S3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, typename _AP_T3, int _AP_W4, typename _AP_T4>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3+_AP_W4,
ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4> >
operator, (const ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3+_AP_W4, ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4> >(
*this, const_cast<ap_concat_ref<_AP_W3,_AP_T3,
_AP_W4,_AP_T4>& >(a2));
}
#pragma empty_line
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator, (const af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, af_range_ref<_AP_W3,
_AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(*this,
const_cast<af_range_ref< _AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3>& >(a2));
}
#pragma empty_line
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, 1, af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator, (const af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, 1, af_bit_ref<_AP_W3,
_AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(*this,
const_cast<af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator & (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() & a2;
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator | (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() | a2;
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator ^ (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() ^ a2;
}
#pragma line 835 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) ap_int_base<_AP_WR,false> get() const {
ap_int_base<_AP_WR,false> tmpVal(0);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
tmpVal.V = ({ typeof(tmpVal.V) __Result__ = 0; typeof(tmpVal.V) __Val2__ = tmpVal.V; typeof((ap_int_base<_AP_W2,false>(mbv2)).V) __Repl2__ = (ap_int_base<_AP_W2,false>(mbv2)).V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, W_ref2-1); __Result__; });
#pragma empty_line
tmpVal.V = ({ typeof(tmpVal.V) __Result__ = 0; typeof(tmpVal.V) __Val2__ = tmpVal.V; typeof((ap_int_base<_AP_W1,false>(mbv1)).V) __Repl2__ = (ap_int_base<_AP_W1,false>(mbv1)).V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), W_ref2, W_ref1+W_ref2-1); __Result__; });
#pragma empty_line
return tmpVal;
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
ap_int_base<_AP_W1+_AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1,false> tmpVal1;
tmpVal1.V = ({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), W_ref2, W_ref1+W_ref2-1); __Result__; });
mbv1.set(tmpVal1);
ap_int_base<_AP_W2, false> tmpVal2;
tmpVal2.V=({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, W_ref2-1); __Result__; });
mbv2.set(tmpVal2);
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return mbv1.length() + mbv2.length();
}
};
#pragma line 874 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
/* Range (slice) reference.
----------------------------------------------------------------
*/
template<int _AP_W, bool _AP_S>
struct ap_range_ref {
ap_int_base<_AP_W,_AP_S> &d_bv;
int l_index;
int h_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) ap_range_ref(const ap_range_ref<_AP_W, _AP_S>& ref):
d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref(ap_int_base<_AP_W,_AP_S>* bv, int h, int l) :
d_bv(*bv), l_index(l), h_index(h) {
/*AP_ASSERT(h >= l, "Range must be (High, Low)");*/
}
#pragma empty_line
inline __attribute__((always_inline)) operator ap_int_base<_AP_W, false> () const {
ap_int_base<_AP_W,false> ret;
ret.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long long () const {
return to_uint64();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref& operator = (unsigned long long val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator = (const ap_int_base<_AP_W2,_AP_S2>& val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_range_ref<_AP_W2,_AP_S2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)val);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_range_ref<_AP_W, _AP_S>& val) {
return operator=((const ap_int_base<_AP_W, false>)val);
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(val.to_ap_int_base());
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_range_ref<_AP_W2,_AP_S2> >
operator, (const ap_range_ref<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_range_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (ap_int_base<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W,ap_int_base<_AP_W,_AP_S> >
operator, (ap_int_base<_AP_W,_AP_S> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W, ap_int_base<_AP_W,_AP_S> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (volatile ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (const ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (const volatile ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,1,ap_bit_ref<_AP_W2,_AP_S2> >
operator, (const ap_bit_ref<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2,_AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2,_AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> hop(op2);
return lop == hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator == (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
#pragma empty_line
ap_int_base<_AP_W2, false> hop (op2);
return lop < hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
#pragma empty_line
ap_int_base<_AP_W2, false> hop (op2);
return lop <= hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator <= (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator < (op2));
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
#pragma empty_line
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return (unsigned)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) long to_long() const {
return (long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned long to_ulong() const {
return (unsigned long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return (ap_slong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return (ap_ulong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) bool and_reduce() const {
bool ret = true;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
_ssdm_Unroll(0,0,0, "");
ret &= (bool)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); __Result__; }));
}
return ret;
}
inline __attribute__((always_inline)) bool or_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
_ssdm_Unroll(0,0,0, "");
ret |= (bool)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); __Result__; }));
}
return ret;
}
inline __attribute__((always_inline)) bool xor_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
_ssdm_Unroll(0,0,0, "");
ret ^= (bool)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); __Result__; }));
}
return ret;
}
};
#pragma empty_line
#pragma empty_line
/* Bit reference.
----------------------------------------------------------------
*/
template<int _AP_W, bool _AP_S>
struct ap_bit_ref {
ap_int_base<_AP_W, _AP_S>& d_bv;
int d_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) ap_bit_ref(const ap_bit_ref<_AP_W, _AP_S>& ref):
d_bv(ref.d_bv), d_index(ref.d_index) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref(ap_int_base<_AP_W,_AP_S>* bv, int index=0) :
d_bv(*bv), d_index(index) { }
inline __attribute__((always_inline)) operator bool () const { return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); }); }
inline __attribute__((always_inline)) bool to_bool() const { return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); }); }
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref& operator = ( unsigned long long val ) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator = ( const ap_int_base<_AP_W2,_AP_S2> &val ) {
return operator =((unsigned long long)(val.V != 0));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator = ( const ap_range_ref<_AP_W2,_AP_S2> &val ) {
return operator =(val.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator = (const ap_bit_ref<_AP_W2,_AP_S2>& val) {
return operator =((unsigned long long) (bool) val);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref& operator = (const ap_bit_ref<_AP_W,_AP_S>& val) {
return operator =((unsigned long long) (bool) val);
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_bit_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_bit_ref& operator= (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_bit_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (volatile ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2>
>(*this, const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
ap_int_base<_AP_W2,_AP_S2> op(a2);
return ap_concat_ref<1,ap_bit_ref,_AP_W2,ap_int_base<_AP_W2,
_AP_S2> >(*this, const_cast<ap_int_base<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (const volatile ap_int_base<_AP_W2, _AP_S2>& a2) {
ap_int_base<_AP_W2,_AP_S2> op(a2);
return ap_concat_ref<1,ap_bit_ref,_AP_W2, ap_int_base<_AP_W2,_AP_S2>
>(*this, const_cast< ap_int_base<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2,_AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) {
return
ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2,
_AP_S2> >(*this, const_cast<ap_range_ref<_AP_W2, _AP_S2> &>(a2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2,_AP_S2>& >(a2));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> >
operator, (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> &a2) {
return ap_concat_ref<1,ap_bit_ref,_AP_W2+_AP_W3,ap_concat_ref<_AP_W2,
_AP_T2,_AP_W3,_AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> &>(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<1, ap_bit_ref, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() == op.get();
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() != op.get();
}
#pragma empty_line
inline __attribute__((always_inline)) bool get() const {
return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) bool get() {
return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
operator = (val);
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator ~() const {
bool bit = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
return bit ? false : true;
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const { return 1; }
};
#pragma empty_line
template <int _AP_N, bool _AP_S> struct retval;
#pragma empty_line
template <int _AP_N>
struct retval<_AP_N, true> {
typedef ap_slong Type;
};
template <int _AP_N>
struct retval<_AP_N, false> {
typedef ap_ulong Type;
};
#pragma empty_line
template<> struct retval<1, true> {
typedef signed char Type;
};
template<> struct retval<1, false> {
typedef unsigned char Type;
};
template<> struct retval<2, true> {
typedef short Type;
};
template<> struct retval<2, false> {
typedef unsigned short Type;
};
template<> struct retval<3, true> {
typedef int Type;
};
template<> struct retval<3, false> {
typedef unsigned int Type;
};
template<> struct retval<4, true> {
typedef int Type;
};
template<> struct retval<4, false> {
typedef unsigned int Type;
};
#pragma empty_line
/* ----------------------------------------------------------------
ap_int_base: AutoPilot integer/Arbitrary precision integer.
----------------------------------------------------------------
*/
#pragma empty_line
template<int _AP_W, bool _AP_S>
struct ap_int_base <_AP_W, _AP_S, true>: public ssdm_int<_AP_W,_AP_S> {
#pragma empty_line
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
#pragma empty_line
typedef typename retval< (_AP_W + 7)/8, _AP_S>::Type RetType;
#pragma empty_line
static const int width = _AP_W;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
struct RType {
enum {
mult_w = _AP_W+_AP_W2,
mult_s = _AP_S||_AP_S2,
plus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
plus_s = _AP_S||_AP_S2,
minus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
minus_s = true,
div_w = _AP_W+_AP_S2,
div_s = _AP_S||_AP_S2,
mod_w = ((_AP_W) < (_AP_W2+(!_AP_S2&&_AP_S)) ? (_AP_W) : (_AP_W2+(!_AP_S2&&_AP_S))),
mod_s = _AP_S,
logic_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2))),
logic_s = _AP_S||_AP_S2
};
#pragma empty_line
typedef ap_int_base<mult_w, mult_s> mult;
typedef ap_int_base<plus_w, plus_s> plus;
typedef ap_int_base<minus_w, minus_s> minus;
typedef ap_int_base<logic_w, logic_s> logic;
typedef ap_int_base<div_w, div_s> div;
typedef ap_int_base<mod_w, mod_s> mod;
typedef ap_int_base<_AP_W, _AP_S> arg1;
typedef bool reduce;
};
#pragma empty_line
/* Constructors.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base() {
/*
#ifdef __SC_COMPATIBLE__
Base::V = 0;
#endif
*/
}
#pragma empty_line
//INLINE ap_int_base(const ap_int_base& op) { Base::V = op.V; }
//INLINE ap_int_base(const volatile ap_int_base& op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const volatile ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
/* For C++ basic data types.*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) explicit ap_int_base(bool op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(signed char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_slong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_ulong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(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; }
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_range_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator ap_int_base<_AP_W2, false>().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_bit_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator bool();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base(const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& ref) {
const ap_int_base<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>::_AP_WR,false> tmp = ref.get();
Base::V = tmp.V;
}
#pragma empty_line
/* This constructor is not usable yet, because the second parameter of
__builtin_bit_from_string(...)
is required to be a constant C string.
*/
inline __attribute__((always_inline)) ap_int_base(const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), 10,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base(const char* str, signed char radix) {_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;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = (val.operator ap_int_base<_AP_W2, false> ()).V;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = val.operator bool ();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base read() volatile {
;
ap_int_base ret;
ret.V = Base::V;
return ret;
}
inline __attribute__((always_inline)) void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
;
Base::V = op2.V;
}
#pragma empty_line
/* Another form of "write".*/
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma line 1521 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str),
10, _AP_W, _AP_S, SC_TRN, SC_WRAP, 0,true);
Base::V = Result;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& set(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), radix,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (signed char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_slong op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_ulong op) { Base::V = op; return *this; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (bool) op2;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
return *this;
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& op2) {
Base::V = op2.get().V;
return *this;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
return *this;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = (bool) op;
return *this;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) operator RetType() const { return (RetType)(Base::V); }
#pragma empty_line
#pragma empty_line
/* Explicit conversions to C interger types.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool to_bool() const {return (bool)(Base::V);}
inline __attribute__((always_inline)) unsigned char to_uchar() const {return (unsigned char)(Base::V);}
inline __attribute__((always_inline)) signed char to_char() const {return (signed char)(Base::V);}
inline __attribute__((always_inline)) unsigned short to_ushort() const {return (unsigned short)(Base::V);}
inline __attribute__((always_inline)) short to_short() const {return (short)(Base::V);}
inline __attribute__((always_inline)) int to_int() const { return (int)(Base::V); }
inline __attribute__((always_inline)) unsigned to_uint() const { return (unsigned)(Base::V); }
inline __attribute__((always_inline)) long to_long() const { return (long)(Base::V); }
inline __attribute__((always_inline)) unsigned long to_ulong() const { return (unsigned long)(Base::V); }
inline __attribute__((always_inline)) ap_slong to_int64() const { return (ap_slong)(Base::V); }
inline __attribute__((always_inline)) ap_ulong to_uint64() const { return (ap_ulong)(Base::V); }
inline __attribute__((always_inline)) double to_double() const { return (double)(Base::V); }
#pragma line 1640 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) int length() const { return _AP_W; }
inline __attribute__((always_inline)) int length() const volatile { return _AP_W; }
#pragma empty_line
/*INLINE operator ap_ulong () { return (ap_ulong)(Base::V); }*/
#pragma empty_line
/*Reverse the contents of ap_int_base instance. I.e. LSB becomes MSB and vise versa*/
inline __attribute__((always_inline)) ap_int_base& reverse () {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, 0); __Result__; });
return *this;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool iszero () const {
return Base::V == 0 ;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0 ;
}
#pragma empty_line
/* x < 0 */
inline __attribute__((always_inline)) bool sign () const {
if (_AP_S && ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }))
return true;
else
return false;
}
#pragma empty_line
/* x[i] = 0 */
inline __attribute__((always_inline)) void clear(int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
/* x[i] = !x[i]*/
inline __attribute__((always_inline)) void invert(int i) {
;
bool val = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
if (val) Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
else Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) bool test (int i) const {
;
return ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//Set the ith bit into 1
inline __attribute__((always_inline)) void set (int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set (int i, bool v) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the left
inline __attribute__((always_inline)) void lrotate(int n) {
;
typeof(Base::V) l_p = Base::V << n;
typeof(Base::V) r_p = Base::V >> (_AP_W - n);
Base::V = l_p | r_p;
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the right
inline __attribute__((always_inline)) void rrotate(int n) {
;
typeof(Base::V) l_p = Base::V << (_AP_W - n);
typeof(Base::V) r_p = Base::V >> n;
Base::V = l_p | r_p;
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set_bit (int i, bool v) {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Get the value of ith bit
inline __attribute__((always_inline)) bool get_bit (int i) const {
return (bool)({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//complements every bit
inline __attribute__((always_inline)) void b_not() {
Base::V = ~Base::V;
}
#pragma empty_line
// Count the number of zeros from the most significant bit
// to the first one bit. Note this is only for ap_fixed_base whose
// _AP_W <= 64, otherwise will incur assertion.
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctzll(t.V);
} else {
enum { __N = (_AP_W+63)/64 };
int NZeros = 0;
int i = 0;
bool hitNonZero = false;
for (i=0; i<__N-1; ++i) {
ap_int_base<64, false> t;
t.range(0, 63) = this->range(_AP_W - i*64 - 64, _AP_W - i*64 - 1);
NZeros += hitNonZero?0:__builtin_clzll(t.V);
hitNonZero |= (t.to_uint64() != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
t.range(63-(_AP_W-1)%64, 63) = this->range(0, (_AP_W-1)%64);
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
#pragma line 1774 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
/* Arithmetic assign.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator *= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V *= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator += ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V += op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator -= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V -= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator /= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V /= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator %= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V %= op2.V; return *this; }
#pragma empty_line
/* Bitwise assign: and, or, xor.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator &= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V &= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator |= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V |= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator ^= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V ^= op2.V; return *this; }
#pragma empty_line
#pragma empty_line
/* Prefix increment, decrement.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base& operator ++() {
operator+=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator --() {
operator-=((ap_int_base<1,false>) 1);
return *this;
}
#pragma empty_line
/* Postfix increment, decrement
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) const ap_int_base operator ++(int) {
ap_int_base t = *this;
operator+=((ap_int_base<1,false>) 1);
return t;
}
inline __attribute__((always_inline)) const ap_int_base operator --(int) {
ap_int_base t = *this;
operator-=((ap_int_base<1,false>) 1);
return t;
}
#pragma empty_line
/* Unary arithmetic.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base operator +() const {
return *this;
}
/* Not (!)
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool operator ! () const {
return Base::V == 0;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base<((64) < (_AP_W + 1) ? (64) : (_AP_W + 1)), true>
operator -() const {
return ((ap_int_base<1,false>) 0) - *this;
}
#pragma empty_line
/* Shift (result constrained by left operand).
----------------------------------------------------------------
*/
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator >> (sh);
} else
return operator << (sh);
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_int_base<_AP_W2,false> &op2 ) const {
ap_int_base r ;
r.V = Base::V << op2.to_uint();
return r;
}
#pragma empty_line
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator << (sh);
}
return operator >> (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_int_base<_AP_W2,false> &op2 ) const {
ap_int_base r;
r.V = Base::V >> op2.to_uint();
return r;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this << (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this >> (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
#pragma empty_line
/* Shift assign
----------------------------------------------------------------
*/
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator >>= (sh);
} else
return operator <<= (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,false> &op2 ) {
Base::V <<= op2.to_uint();
return *this;
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator <<= (sh);
}
return operator >>= (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_int_base<_AP_W2,false> &op2 ) {
Base::V >>= op2.to_uint();
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this <<= (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this >>= (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
/* Comparisons.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V == op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return !(Base::V == op2.V);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V < op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V >= op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V > op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V <= op2.V;
}
#pragma empty_line
#pragma empty_line
/* Bit and Part Select
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) const {
;
return ap_range_ref<_AP_W,_AP_S>(const_cast<ap_int_base*>(this), Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#pragma line 1998 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator [] (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator [] (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this),
index.to_int());
return br.to_bool();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool bit (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool bit (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br = bit(index);
return br.to_bool();
}
#pragma line 2061 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(const ap_int_base<_AP_W2,_AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(ap_int_base<_AP_W2,_AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this), const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator & (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this & a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator | (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this | a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator ^ (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this ^ a2.get();
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
#pragma empty_line
/* Reduce operations.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool and_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
inline __attribute__((always_inline)) bool and_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
/* Output as a string.
----------------------------------------------------------------
*/
void to_string(char* str, int len, BaseMode mode, bool sign = false) const {
for (int i = 0; i <= len; ++i) str[i] = '\0';
if (mode == SC_BIN) {
int size = ((_AP_W) < (len) ? (_AP_W) : (len));
for (int bit = size; bit > 0; --bit) {
if (({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), bit-1, bit-1); (bool)(__Result__ & 1); })) str[size-bit] = '1';
else str[size-bit] = '0';
}
} /*else if (mode == AP_HEX) {
typeof(Base::V) tmpV = Base::V;
int idx = 0;
int size = AP_MIN((_AP_W+3)/4, len);
while (idx < size) {
char hexb = tmpV & 0xF;
if (hexb > 9) hexb = hexb - 10 + 'a';
else hexb += '0';
str[size-1-idx] = hexb;
tmpV >> 4;
idx ++;
}
} */ else if (mode == SC_OCT || mode == SC_DEC) {
;
} else {
;
}
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(BaseMode mode, bool sign=false) const {
return 0;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(signed char mode, bool sign=false) const {
return to_string(BaseMode(mode), sign);
}
};
template<int _AP_W, bool _AP_S>
struct ap_int_base<_AP_W, _AP_S, false> : public ssdm_int<_AP_W,_AP_S> {
#pragma empty_line
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
typedef typename retval<8, _AP_S>::Type RetType;
static const int width = _AP_W;
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
struct RType {
enum {
mult_w = _AP_W+_AP_W2,
mult_s = _AP_S||_AP_S2,
plus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
plus_s = _AP_S||_AP_S2,
minus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
minus_s = true,
div_w = _AP_W+_AP_S2,
div_s = _AP_S||_AP_S2,
mod_w = ((_AP_W) < (_AP_W2+(!_AP_S2&&_AP_S)) ? (_AP_W) : (_AP_W2+(!_AP_S2&&_AP_S))),
mod_s = _AP_S,
logic_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2))),
logic_s = _AP_S||_AP_S2
};
#pragma empty_line
typedef ap_int_base<mult_w, mult_s> mult;
typedef ap_int_base<plus_w, plus_s> plus;
typedef ap_int_base<minus_w, minus_s> minus;
typedef ap_int_base<logic_w, logic_s> logic;
typedef ap_int_base<div_w, div_s> div;
typedef ap_int_base<mod_w, mod_s> mod;
typedef ap_int_base<_AP_W, _AP_S> arg1;
typedef bool reduce;
};
#pragma empty_line
/* Constructors.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base() {
/*
#ifdef __SC_COMPATIBLE__
Base::V = 0;
#endif
*/
}
#pragma empty_line
//INLINE ap_int_base(const ap_int_base& op) { Base::V = op.V; }
//INLINE ap_int_base(const volatile ap_int_base& op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const volatile ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
/* For C++ basic data types.*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) explicit ap_int_base(bool op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(signed char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_slong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_ulong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(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; }
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_range_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator ap_int_base<_AP_W2, false>().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_bit_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator bool();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base(const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& ref) {
const ap_int_base<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>::_AP_WR,false> tmp = ref.get();
Base::V = tmp.V;
}
#pragma empty_line
/* This constructor is not usable yet, because the second parameter of
__builtin_bit_from_string(...)
is required to be a constant C string.
*/
inline __attribute__((always_inline)) ap_int_base(const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), 10,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base(const char* str, signed char radix) {_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;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = (val.operator ap_int_base<_AP_W2, false> ()).V;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = val.operator bool ();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base read() volatile {
;
ap_int_base ret;
ret.V = Base::V;
return ret;
}
inline __attribute__((always_inline)) void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
;
Base::V = op2.V;
}
#pragma empty_line
/* Another form of "write".*/
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma line 2463 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), 10,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& set(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), radix,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_slong op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_ulong op) { Base::V = op; return *this; }
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (bool) op2;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
return *this;
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& op2) {
Base::V = op2.get().V;
return *this;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
return *this;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = (bool) op;
return *this;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) operator RetType() const { return (RetType)(Base::V); }
#pragma empty_line
#pragma empty_line
/* Explicit conversions to C interger types.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool to_bool() const {return (bool)(Base::V);}
inline __attribute__((always_inline)) bool to_uchar() const {return (unsigned char)(Base::V);}
inline __attribute__((always_inline)) bool to_char() const {return (char)(Base::V);}
inline __attribute__((always_inline)) bool to_ushort() const {return (unsigned short)(Base::V);}
inline __attribute__((always_inline)) bool to_short() const {return (short)(Base::V);}
inline __attribute__((always_inline)) int to_int() const { return (int)(Base::V); }
inline __attribute__((always_inline)) unsigned to_uint() const { return (unsigned)(Base::V); }
inline __attribute__((always_inline)) long to_long() const { return (long)(Base::V); }
inline __attribute__((always_inline)) unsigned long to_ulong() const { return (unsigned long)(Base::V); }
inline __attribute__((always_inline)) ap_slong to_int64() const { return (ap_slong)(Base::V); }
inline __attribute__((always_inline)) ap_ulong to_uint64() const { return (ap_ulong)(Base::V); }
inline __attribute__((always_inline)) double to_double() const { return (double)(Base::V); }
#pragma line 2582 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) int length() const { return _AP_W; }
inline __attribute__((always_inline)) int length() const volatile { return _AP_W; }
#pragma empty_line
/*INLINE operator ap_ulong () { return (ap_ulong)(Base::V); }*/
#pragma empty_line
/*Reverse the contents of ap_int_base instance. I.e. LSB becomes MSB and vise versa*/
inline __attribute__((always_inline)) ap_int_base& reverse () {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, 0); __Result__; });
return *this;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool iszero () const {
return Base::V == 0 ;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0 ;
}
#pragma empty_line
/* x < 0 */
inline __attribute__((always_inline)) bool sign () const {
if (_AP_S && ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }))
return true;
else
return false;
}
#pragma empty_line
/* x[i] = 0 */
inline __attribute__((always_inline)) void clear(int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
/* x[i] = !x[i]*/
inline __attribute__((always_inline)) void invert(int i) {
;
bool val = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
if (val) Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
else Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) bool test (int i) const {
;
return ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//Set the ith bit into 1
inline __attribute__((always_inline)) void set (int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set (int i, bool v) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the left
inline __attribute__((always_inline)) void lrotate(int n) {
;
typeof(Base::V) l_p = Base::V << n;
typeof(Base::V) r_p = Base::V >> (_AP_W - n);
Base::V = l_p | r_p;
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the right
inline __attribute__((always_inline)) void rrotate(int n) {
;
typeof(Base::V) l_p = Base::V << (_AP_W - n);
typeof(Base::V) r_p = Base::V >> n;
Base::V = l_p | r_p;
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set_bit (int i, bool v) {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Get the value of ith bit
inline __attribute__((always_inline)) bool get_bit (int i) const {
return (bool)({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//complements every bit
inline __attribute__((always_inline)) void b_not() {
Base::V = ~Base::V;
}
#pragma empty_line
// Count the number of zeros from the most significant bit
// to the first one bit. Note this is only for ap_fixed_base whose
// _AP_W <= 64, otherwise will incur assertion.
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctzll(t.V);
} else {
enum { __N = (_AP_W+63)/64 };
int NZeros = 0;
unsigned i = 0;
bool hitNonZero = false;
for (i=0; i<__N-1; ++i) {
ap_int_base<64, false> t;
t.range(0, 63) = this->range(_AP_W - i*64 - 64, _AP_W - i*64 - 1);
NZeros += hitNonZero?0:__builtin_clzll(t.V);
hitNonZero |= (t.to_uint64() != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
t.range(63-(_AP_W-1)%64, 63) = this->range(0, (_AP_W-1)%64);
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
#pragma line 2716 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
/* Arithmetic assign.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator *= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V *= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator += ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V += op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator -= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V -= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator /= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V /= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator %= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V %= op2.V; return *this; }
#pragma empty_line
/* Bitwise assign: and, or, xor.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator &= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V &= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator |= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V |= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator ^= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V ^= op2.V; return *this; }
#pragma empty_line
#pragma empty_line
/* Prefix increment, decrement.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base& operator ++() {
operator+=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator --() {
operator-=((ap_int_base<1,false>) 1);
return *this;
}
#pragma empty_line
/* Postfix increment, decrement
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) const ap_int_base operator ++(int) {
ap_int_base t = *this;
operator+=((ap_int_base<1,false>) 1);
return t;
}
inline __attribute__((always_inline)) const ap_int_base operator --(int) {
ap_int_base t = *this;
operator-=((ap_int_base<1,false>) 1);
return t;
}
#pragma empty_line
/* Unary arithmetic.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base operator +() const{
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) typename RType<1,false>::minus operator -() const {
return ((ap_int_base<1,false>) 0) - *this;
}
#pragma empty_line
/* Not (!)
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool operator ! () const {
return Base::V == 0;
}
#pragma empty_line
/* Bitwise (arithmetic) unary: complement
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base<_AP_W+!_AP_S, true> operator ~() const {
ap_int_base<_AP_W+!_AP_S, true> r;
r.V = ~Base::V;
return r;
}
#pragma empty_line
/* Shift (result constrained by left operand).
----------------------------------------------------------------
*/
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator >> (sh);
} else
return operator << (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_int_base<_AP_W2,false> &op2 ) const {
ap_int_base r ;
r.V = Base::V << op2.to_uint();
return r;
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator << (sh);
}
return operator >> (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_int_base<_AP_W2,false> &op2 ) const {
ap_int_base r;
r.V = Base::V >> op2.to_uint();
return r;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this << (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this >> (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
/* Shift assign
----------------------------------------------------------------
*/
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator >>= (sh);
} else
return operator <<= (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,false> &op2 ) {
Base::V <<= op2.to_uint();
return *this;
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
operator <<= (sh);
}
return operator >>= (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_int_base<_AP_W2,false> &op2 ) {
Base::V >>= op2.to_uint();
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this <<= (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this >>= (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
/* Comparisons.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V == op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return !(Base::V == op2.V);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V < op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V >= op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V > op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V <= op2.V;
}
#pragma empty_line
#pragma empty_line
/* Bit and Part Select
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) const {
;
return ap_range_ref<_AP_W,_AP_S>(const_cast<ap_int_base*>(this), Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#pragma line 2945 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator [] (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator [] (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this),
index.to_int());
return br.to_bool();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool bit (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool bit (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br = bit(index);
return br.to_bool();
}
#pragma line 3008 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(const ap_int_base<_AP_W2,_AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(ap_int_base<_AP_W2,_AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this), const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator & (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this & a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator | (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this | a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator ^ (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this ^ a2.get();
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
#pragma empty_line
/* Reduce operations.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool and_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
inline __attribute__((always_inline)) bool and_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
/* Output as a string.
----------------------------------------------------------------
*/
void to_string(char* str, int len, BaseMode mode, bool sign = false) const {
for (int i = 0; i <= len; ++i) str[i] = '\0';
if (mode == SC_BIN) {
int size = ((_AP_W) < (len) ? (_AP_W) : (len));
for (int bit = size; bit > 0; --bit) {
if (({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), bit-1, bit-1); (bool)(__Result__ & 1); })) str[size-bit] = '1';
else str[size-bit] = '0';
}
} /*else if (mode == AP_HEX) {
typeof(Base::V) tmpV = Base::V;
int idx = 0;
int size = AP_MIN((_AP_W+3)/4, len);
while (idx < size) {
char hexb = tmpV & 0xF;
if (hexb > 9) hexb = hexb - 10 + 'a';
else hexb += '0';
str[size-1-idx] = hexb;
tmpV >> 4;
idx ++;
}
} */ else if (mode == SC_OCT || mode == SC_DEC) {
;
} else {
;
}
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(BaseMode mode, bool sign=false) const {
return 0;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(signed char mode, bool sign=false) const {
return to_string(BaseMode(mode), sign);
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Output streaming.
----------------------------------------------------------------
*/
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::ostream& operator << (std::ostream &os, const ap_int_base<_AP_W,_AP_S> &x) {
//os << x.to_string(AP_DEC);
return os;
}
#pragma empty_line
/* Input streaming.
......................................................
*/
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::istream& operator >> (std::istream& in, ap_int_base<_AP_W,_AP_S> &op) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return in;
}
#pragma empty_line
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::ostream& operator << (std::ostream &os, const ap_range_ref<_AP_W,_AP_S> &x) {
//os << x.to_string(AP_DEC);
return os;
}
#pragma empty_line
/* Input streaming.
......................................................
*/
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::istream& operator >> (std::istream& in, ap_range_ref<_AP_W,_AP_S> &op) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return in;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*Binary Arithmetic.
----------------------------------------------------------------
*/
#pragma line 3322 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult operator * (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult r ; r.V = lhs.V * rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus operator + (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus r ; r.V = lhs.V + rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus operator - (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus r ; r.V = lhs.V - rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::div r ; r.V = op.V / op2.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mod r ; r.V = op.V % op2.V; return r; }
#pragma empty_line
/* Bitwise and, or, xor.
----------------------------------------------------------------
*/
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic operator & (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic r ; r.V = lhs.V & rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic operator | (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic r ; r.V = lhs.V | rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic operator ^ (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic r ; r.V = lhs.V ^ rhs.V; return r; }
#pragma empty_line
#pragma empty_line
//FIXME
#pragma empty_line
//char a[100];
//char* ptr = a;
//ap_int<2> n = 3;
//char* ptr2 = ptr + n*2;
//avoid ambiguous errors
#pragma line 3357 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator + (PTR_TYPE* i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator + (const ap_int_base<_AP_W,_AP_S> &op, PTR_TYPE* i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return op2 + i_op; }
template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator - (PTR_TYPE* i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op - op2; } template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator - (const ap_int_base<_AP_W,_AP_S> &op, PTR_TYPE* i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return op2 - i_op; }
#pragma empty_line
//float OP ap_int
//when ap_int<wa>'s width > 64, then trunc ap_int<w> to ap_int<64>
#pragma line 3382 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/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; }
#pragma empty_line
/* Operators mixing Integers with AP_Int
----------------------------------------------------------------
*/
// partially specialize template argument _AP_C in order that:
// for _AP_W > 64, we will explicitly convert operand with native data type
// into corresponding ap_private
// for _AP_W <= 64, we will implicitly convert operand with ap_private into
// (unsigned) long long
#pragma line 3477 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mult operator * (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op * ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::plus operator + (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op + ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::minus operator - (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op - ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::div operator / (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op / ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mod operator % (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op % ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator & (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op & ap_int_base<1,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, bool op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, bool op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator | (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op | ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator ^ (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op ^ ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator != (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator += (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator -= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator *= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator /= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator %= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator >>= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator <<= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator &= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator |= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator ^= (ap_int_base<1,false>(op2)); }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op * ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op + ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op - ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op / ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op % ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op & ap_int_base<8,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op | ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op ^ ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator += (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator -= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator *= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator /= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator %= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator >>= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator <<= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator &= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator |= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator ^= (ap_int_base<8,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op * ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op + ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op - ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op / ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op % ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op & ap_int_base<8,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op | ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op ^ ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator += (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator -= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator *= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator /= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator %= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator >>= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator <<= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator &= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator |= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator ^= (ap_int_base<8,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mult operator * (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op * ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::plus operator + (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op + ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::minus operator - (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op - ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::div operator / (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op / ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mod operator % (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op % ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator & (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op & ap_int_base<8,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator | (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op | ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator ^ (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op ^ ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator != (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator += (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator -= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator *= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator /= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator %= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator >>= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator <<= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator &= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator |= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator ^= (ap_int_base<8,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mult operator * (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op * ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::plus operator + (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op + ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::minus operator - (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op - ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::div operator / (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op / ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mod operator % (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op % ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator & (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op & ap_int_base<16,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, short op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, short op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator | (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op | ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator ^ (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op ^ ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator != (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator += (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator -= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator *= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator /= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator %= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator >>= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator <<= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator &= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator |= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator ^= (ap_int_base<16,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mult operator * (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op * ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::plus operator + (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op + ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::minus operator - (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op - ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::div operator / (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op / ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mod operator % (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op % ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator & (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op & ap_int_base<16,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator | (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op | ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator ^ (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op ^ ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator != (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator += (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator -= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator *= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator /= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator %= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator >>= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator <<= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator &= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator |= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator ^= (ap_int_base<16,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mult operator * (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op * ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::plus operator + (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op + ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::minus operator - (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op - ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::div operator / (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op / ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mod operator % (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op % ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator & (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op & ap_int_base<32,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, int op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, int op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator | (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op | ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator ^ (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op ^ ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator += (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator -= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator *= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator /= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator %= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator >>= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator <<= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator &= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator |= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator ^= (ap_int_base<32,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mult operator * (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op * ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::plus operator + (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op + ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::minus operator - (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op - ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::div operator / (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op / ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mod operator % (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op % ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator & (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op & ap_int_base<32,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator | (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op | ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator ^ (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op ^ ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator += (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator -= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator *= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator /= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator %= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator >>= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator <<= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator &= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator |= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator ^= (ap_int_base<32,false>(op2)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mult operator * (long 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, long 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 + (long 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, long 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 - (long 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, long 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 / (long 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, long 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 % (long 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, long 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 & (long 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, long i_op) { return op & ap_int_base<32,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, long op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, long op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator | (long 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, long 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 ^ (long 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, long i_op) { return op ^ ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<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, long op2) { return op.operator == (ap_int_base<32,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<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, long op2) { return op.operator != (ap_int_base<32,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<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, long op2) { return op.operator > (ap_int_base<32,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<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, long op2) { return op.operator >= (ap_int_base<32,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<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, long op2) { return op.operator < (ap_int_base<32,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<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, long 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, long 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, long 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, long 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, long 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, long 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, long 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, long 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, long 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, long 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, long op2) { return op.operator ^= (ap_int_base<32,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mult operator * (unsigned long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long i_op) { return op & ap_int_base<32,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator | (unsigned long 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 long 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 long 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 long i_op) { return op ^ ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned long 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 long op2) { return op.operator == (ap_int_base<32,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<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 long op2) { return op.operator != (ap_int_base<32,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<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 long op2) { return op.operator > (ap_int_base<32,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<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 long op2) { return op.operator >= (ap_int_base<32,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<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 long op2) { return op.operator < (ap_int_base<32,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<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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long op2) { return op.operator ^= (ap_int_base<32,false>(op2)); }
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mult operator * (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op * ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::plus operator + (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op + ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::minus operator - (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op - ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::div operator / (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op / ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mod operator % (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op % ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator & (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op & ap_int_base<64,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator | (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op | ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator ^ (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op ^ ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator += (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator -= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator *= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator /= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator %= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator >>= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator <<= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator &= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator |= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator ^= (ap_int_base<64,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mult operator * (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op * ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::plus operator + (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op + ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::minus operator - (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op - ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::div operator / (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op / ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mod operator % (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op % ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator & (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op & ap_int_base<64,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator | (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op | ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator ^ (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op ^ ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator += (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator -= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator *= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator /= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator %= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator >>= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator <<= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator &= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator |= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator ^= (ap_int_base<64,false>(op2)); }
#pragma line 3536 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator += ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator += (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator += ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator += (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator -= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator -= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator -= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator -= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator *= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator *= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator *= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator *= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator /= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator /= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator /= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator /= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator %= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator %= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator %= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator %= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator >>= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >>= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator >>= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator >>= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator <<= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <<= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator <<= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator <<= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator &= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator &= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator &= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator &= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator |= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator |= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator |= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator |= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator ^= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator ^= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator ^= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator ^= (op2); op1 = tmp; return op1; }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator == (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator == (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator != (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator != (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator > (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator > (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator >= (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >= (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator < (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator < (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator <= (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <= (op2.operator ap_int_base<_AP_W2, false>()); }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::plus operator + ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) + (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::plus operator + ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 + (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::minus operator - ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) - (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::minus operator - ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 - (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mult operator * ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) * (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mult operator * ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 * (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::div operator / ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) / (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::div operator / ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 / (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mod operator % ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) % (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mod operator % ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 % (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator >> ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) >> (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator >> ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 >> (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator << ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) << (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator << ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 << (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator & ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) & (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator & ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 & (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator | ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) | (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator | ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 | (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator ^ ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) ^ (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator ^ ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 ^ (ap_int_base<_AP_W2, false>(op2)); }
#pragma line 3592 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator += ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator += (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator += ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator += (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator -= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator -= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator -= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator -= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator *= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator *= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator *= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator *= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator /= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator /= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator /= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator /= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator %= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator %= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator %= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator %= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator >>= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >>= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator >>= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator >>= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator <<= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <<= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator <<= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator <<= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator &= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator &= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator &= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator &= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator |= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator |= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator |= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator |= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator ^= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator ^= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator ^= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator ^= (op2); op1 = tmp; return op1; }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator == (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator != (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator > (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >= (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator < (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <= (ap_int_base<1, false>(op2)); }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::plus operator + ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 + (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::minus operator - ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 - (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::mult operator * ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 * (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::div operator / ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 / (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::mod operator % ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 % (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::arg1 operator >> ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 >> (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::arg1 operator << ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 << (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::logic operator & ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 & (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::logic operator | ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 | (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::logic operator ^ ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 ^ (ap_int_base<1, false>(op2)); }
#pragma line 3648 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<1,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<8,(-127 -1) != 0>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<8,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<8,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<16,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<16,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<32,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<32,false>(op2)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, long 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, 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<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, long 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, 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<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, long 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, 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<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, long 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, 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<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, long 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, 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<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, long 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, 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<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 long 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 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<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 long 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 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<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 long 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 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<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 long 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 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<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 long 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 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<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 long 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 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<32,false>(op2)); }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<64,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<64,false>(op2)); }
#pragma line 3690 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::plus operator + ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::minus operator - ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::mult operator * ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::div operator / ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::mod operator % ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::arg1 operator >> ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::arg1 operator << ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::logic operator & ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::logic operator | ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::logic operator ^ ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::plus operator + ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::minus operator - ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::mult operator * ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::div operator / ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::mod operator % ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::arg1 operator >> ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::arg1 operator << ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::logic operator & ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::logic operator | ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::logic operator ^ ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::plus operator + ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::minus operator - ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::mult operator * ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::div operator / ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::mod operator % ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::arg1 operator >> ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::arg1 operator << ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::logic operator & ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::logic operator | ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::logic operator ^ ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::plus operator + ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::minus operator - ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::mult operator * ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::div operator / ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::mod operator % ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::arg1 operator >> ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::arg1 operator << ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::logic operator & ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::logic operator | ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::logic operator ^ ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::plus operator + ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::minus operator - ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::mult operator * ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::div operator / ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::mod operator % ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::arg1 operator >> ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::arg1 operator << ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::logic operator & ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::logic operator | ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,true>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::logic operator ^ ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::plus operator + ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::minus operator - ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::mult operator * ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::div operator / ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::mod operator % ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::arg1 operator >> ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::arg1 operator << ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::logic operator & ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::logic operator | ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,false>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::logic operator ^ ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::plus operator + ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::minus operator - ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::mult operator * ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::div operator / ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::mod operator % ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::arg1 operator >> ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::arg1 operator << ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::logic operator & ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::logic operator | ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,true>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::logic operator ^ ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::plus operator + ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::minus operator - ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::mult operator * ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::div operator / ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::mod operator % ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::arg1 operator >> ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::arg1 operator << ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::logic operator & ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::logic operator | ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,false>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::logic operator ^ ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<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 + ( long 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, long 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 - ( long 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, long 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 * ( long 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, long 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 / ( long 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, long 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 % ( long 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, long 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 >> ( long 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, long 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 << ( long 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, long 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 & ( long 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, long 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 | ( long 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, long 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 ^ ( long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::plus operator + ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::minus operator - ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::mult operator * ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::div operator / ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::mod operator % ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::arg1 operator >> ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::arg1 operator << ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator & ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator | ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,true>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator ^ ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::plus operator + ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::minus operator - ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::mult operator * ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::div operator / ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::mod operator % ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::arg1 operator >> ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::arg1 operator << ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator & ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator | ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,false>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator ^ ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
#pragma line 3715 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::plus operator + (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) + (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::minus operator - (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) - (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::mult operator * (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) * (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::div operator / (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) / (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::mod operator % (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) % (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator >> (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) >> (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator << (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) << (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator & (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) & (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator | (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) | (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator ^ (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) ^ (ap_int_base<_AP_W2, false>(rhs)); }
#pragma line 3867 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); ret <<= 1; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (bool op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 1; ret >>= 1; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); ret <<= 1; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (bool op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<1 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + 1, false> val(op2); val[1] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<1 + 1, false > operator, (bool op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<1 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 1, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, bool op2) { ap_int_base<1 + _AP_W + _AP_W2, false> val(op2); ap_int_base<1 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 1; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 1, false > operator, (bool op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<1 + _AP_W + _AP_W2, false> val(op1); ap_int_base<1 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 1; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (bool op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 1, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, bool op2) { ap_int_base<1 + 1, false> val(op2); val[1] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 1, false> operator, (bool op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<1 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if ((-127 -1) != 0) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (char op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if ((-127 -1) != 0) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, char op2) { ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> val(op2); ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> ret(op1); if ((-127 -1) != 0) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> val(op1); ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if ((-127 -1) != 0) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, char op2) { ap_int_base<8 + 1, (-127 -1) != 0> val(op2); val[8] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, (-127 -1) != 0> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (signed char op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (signed char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (signed char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, signed char op2) { ap_int_base<8 + _AP_W + _AP_W2, true> val(op2); ap_int_base<8 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (signed char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, true> val(op1); ap_int_base<8 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (signed char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, signed char op2) { ap_int_base<8 + 1, true> val(op2); val[8] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (signed char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (unsigned char op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (unsigned char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (unsigned char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned char op2) { ap_int_base<8 + _AP_W + _AP_W2, false> val(op2); ap_int_base<8 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (unsigned char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, false> val(op1); ap_int_base<8 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (unsigned char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (unsigned char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (short op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 16; ret >>= 16; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (short op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, short op2) { ap_int_base<16 + 1, false> val(op2); val[16] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (short op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, short op2) { ap_int_base<16 + _AP_W + _AP_W2, true> val(op2); ap_int_base<16 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 16; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (short op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<16 + _AP_W + _AP_W2, true> val(op1); ap_int_base<16 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 16; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (short op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, short op2) { ap_int_base<16 + 1, true> val(op2); val[16] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, false> operator, (short op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<16 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (unsigned short op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 16; ret >>= 16; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (unsigned short op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<16 + 1, false> val(op2); val[16] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (unsigned short op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned short op2) { ap_int_base<16 + _AP_W + _AP_W2, false> val(op2); ap_int_base<16 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 16; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (unsigned short op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<16 + _AP_W + _AP_W2, false> val(op1); ap_int_base<16 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 16; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (unsigned short op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned short op2) { ap_int_base<16 + 1, false> val(op2); val[16] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, false> operator, (unsigned short op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<16 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (int op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 32; ret >>= 32; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (int op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, int op2) { ap_int_base<32 + 1, false> val(op2); val[32] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (int op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, int op2) { ap_int_base<32 + _AP_W + _AP_W2, true> val(op2); ap_int_base<32 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 32; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (int op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<32 + _AP_W + _AP_W2, true> val(op1); ap_int_base<32 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 32; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (int op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, int op2) { ap_int_base<32 + 1, true> val(op2); val[32] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, false> operator, (int op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<32 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (unsigned int op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 32; ret >>= 32; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (unsigned int op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<32 + 1, false> val(op2); val[32] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (unsigned int op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned int op2) { ap_int_base<32 + _AP_W + _AP_W2, false> val(op2); ap_int_base<32 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 32; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (unsigned int op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<32 + _AP_W + _AP_W2, false> val(op1); ap_int_base<32 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 32; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (unsigned int op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned int op2) { ap_int_base<32 + 1, false> val(op2); val[32] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, false> operator, (unsigned int op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<32 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, long 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, (long 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, long 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, (long 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, long 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, (long 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, long 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, (long 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, long 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, (long 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, long 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, (long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<32 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_slong op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 64; ret >>= 64; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_slong op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (ap_slong op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, ap_slong op2) { ap_int_base<64 + _AP_W + _AP_W2, true> val(op2); ap_int_base<64 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 64; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (ap_slong op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<64 + _AP_W + _AP_W2, true> val(op1); ap_int_base<64 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_slong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 64; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_slong op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_slong op2) { ap_int_base<64 + 1, true> val(op2); val[64] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, false> operator, (ap_slong op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<64 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_ulong op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 64; ret >>= 64; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_ulong op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (ap_ulong op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, ap_ulong op2) { ap_int_base<64 + _AP_W + _AP_W2, false> val(op2); ap_int_base<64 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 64; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (ap_ulong op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<64 + _AP_W + _AP_W2, false> val(op1); ap_int_base<64 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_ulong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 64; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_ulong op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_ulong op2) { ap_int_base<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, false> operator, (ap_ulong op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
#pragma line 3893 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned int rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_ulong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_slong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned int rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_ulong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_slong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 16 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\ap_int.h" 2
#pragma line 1 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h" 1
// -*- c++ -*-
#pragma empty_line
/*
* __VIVADO_HLS_COPYRIGHT-INFO__
*
*/
#pragma line 16 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
/// ap_fixed_base
// -----------------------------------------------------------------------------
//#include <math.h>
#pragma line 35 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
//enum ap_q_mode { SC_TRN, SC_RND, SC_TRN_ZERO, SC_RND_ZERO,
// SC_RND_INF, SC_RND_MIN_INF, SC_RND_CONV };
#pragma empty_line
//enum ap_o_mode { SC_WRAP, SC_SAT, SC_SAT_ZERO, SC_SAT_SYM,SC_WRAP_SM };
#pragma empty_line
/// Forward declaration.
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
struct ap_fixed_base;
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
struct af_bit_ref {
ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& d_bv;
int d_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) af_bit_ref(const af_bit_ref<_AP_W,_AP_I,_AP_S,
_AP_Q,_AP_O,_AP_N>&ref):
d_bv(ref.d_bv), d_index(ref.d_index) {}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref(ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>* bv, int index = 0) :
d_bv(*bv), d_index(index) {}
inline __attribute__((always_inline)) operator bool () const { return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); }); }
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref& operator = (unsigned long long val) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator = (const ap_int_base<_AP_W2,_AP_S2>& val) {
return operator =(val.to_uint64());
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_bit_ref& operator = (const af_bit_ref<_AP_W2,_AP_I2,
_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& val) {
return operator =((unsigned long long) (bool) val);
}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref& operator = (const af_bit_ref<_AP_W,_AP_I,
_AP_S,_AP_Q,_AP_O,_AP_N>& val) {
return operator =((unsigned long long) (bool) val);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator = ( const ap_bit_ref<_AP_W2, _AP_S2> &val) {
return operator =((unsigned long long) (bool) val);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator = ( const ap_range_ref<_AP_W2,_AP_S2>& val) {
return operator =((const ap_int_base<_AP_W2, false>) val);
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_bit_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) af_bit_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, op);
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, 1,
ap_bit_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this,
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& > (op));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<1, af_bit_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator == (const af_bit_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() == op.get();
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator != (const af_bit_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() != op.get();
}
#pragma empty_line
inline __attribute__((always_inline)) bool get() const {
return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator ~ () const {
bool bit = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
return bit ? false : true;
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return 1;
}
#pragma empty_line
};
/* Range (slice) reference.
----------------------------------------------------------------
*/
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
struct af_range_ref {
ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& d_bv;
int l_index;
int h_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) af_range_ref(const af_range_ref<_AP_W,_AP_I,_AP_S,
_AP_Q,_AP_O, _AP_N>&ref):
d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref(ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>* bv
, int h, int l) :
d_bv(*bv), l_index(l), h_index(h) {
}
#pragma empty_line
inline __attribute__((always_inline)) operator ap_int_base<_AP_W,false> () const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long long () const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret.to_uint64();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref& operator = (const char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const signed char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const long long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned long long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_ref& operator = (const ap_int_base<_AP_W2,_AP_S2>& val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref& operator = (const char* val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator= (const af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
ap_int_base<_AP_W2, false> tmp(val);
return operator=(tmp);
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator= (const ap_fixed_base<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(val.to_ap_int_base());
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref& operator= (const af_range_ref<_AP_W,
_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& val) {
ap_int_base<_AP_W, false> tmp(val);
return operator=(tmp);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_ref& operator= (const ap_range_ref<_AP_W2, _AP_S2>& val) {
return operator=((ap_int_base<_AP_W2, false>)val);
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator= (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_ref& operator= (const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) af_range_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop == rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator == (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop < rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop <= rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator <= (op2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator < (op2));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator == (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop == rop;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator != (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator == (op2));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator < (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop < rop;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator <= (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop( *this);
ap_int_base<_AP_W2, false> rop (op2);
return lop <= rop;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator > (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator <= (op2));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator >= (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator < (op2));
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, op);
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, 1,
ap_bit_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_range_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
#pragma empty_line
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return (unsigned)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) long to_long() const {
return (long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned long to_ulong() const {
return (unsigned long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return (ap_slong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return (ap_ulong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
};
#pragma empty_line
// -----------------------------------------------------------------------------
/// ap_fixed_base: AutoPilot fixed point.
// -----------------------------------------------------------------------------
template<int _AP_W, int _AP_I, bool _AP_S=true,
ap_q_mode _AP_Q=SC_TRN, ap_o_mode _AP_O=SC_WRAP, int _AP_N=0>
struct ap_fixed_base : ssdm_int<_AP_W, _AP_S> {
#pragma empty_line
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
#pragma empty_line
static const int width = _AP_W;
static const int iwidth = _AP_I;
static const ap_q_mode qmode = _AP_Q;
static const ap_o_mode omode = _AP_O;
#pragma empty_line
/*__attribute__((weak))*/ void overflow_adjust(bool underflow, bool overflow,bool lD, bool sign) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
#pragma empty_line
if (!underflow && !overflow) return;
if (_AP_O==SC_WRAP) {
if (_AP_N == 0)
return;
if (_AP_S) {
//signed SC_WRAP
//n_bits == 1
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(sign) __Repl2__ = !!sign; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
if (_AP_N > 1) {
//n_bits > 1
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 2); __Result__; });
#pragma empty_line
}
} else {
//unsigned SC_WRAP
ap_int_base<_AP_W, false> mask(-1);
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 1); __Result__; });
#pragma empty_line
}
} else if (_AP_O==SC_SAT_ZERO) {
Base::V = 0;
}
else if (_AP_O == SC_WRAP_SM && _AP_S) {
bool Ro = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); });
if (_AP_N == 0) {
if (lD != Ro) {
Base::V = ~Base::V;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(lD) __Repl2__ = !!lD; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
}
} else {
if (_AP_N == 1 && sign != Ro) {
Base::V = ~Base::V;
} else if (_AP_N > 1) {
bool lNo = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - _AP_N, _AP_W - _AP_N); (bool)(__Result__ & 1); });
if (lNo == sign)
Base::V = ~Base::V;
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 2); __Result__; });
#pragma empty_line
}
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(sign) __Repl2__ = !!sign; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
#pragma empty_line
}
} else {
if (_AP_S) {
if (overflow) {
Base::V = 1;
Base::V <<= _AP_W - 1;
Base::V = ~Base::V;
} else if (underflow) {
Base::V = 1;
Base::V <<= _AP_W - 1;
if (_AP_O==SC_SAT_SYM)
Base::V |= 1;
}
}
else {
if (overflow)
Base::V = ~(ap_int_base<_AP_W,false>(0).V);
else if (underflow)
Base::V = 0;
}
}
}
#pragma empty_line
/*__attribute__((weak))*/ bool quantization_adjust(bool qb, bool r, bool s) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
bool carry=(bool)({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W-1, _AP_W-1); (bool)(__Result__ & 1); });
if (_AP_Q==SC_TRN)
return false;
if (_AP_Q==SC_RND_ZERO)
qb &= s || r;
else if (_AP_Q==SC_RND_MIN_INF)
qb &= r;
else if (_AP_Q==SC_RND_INF)
qb &= !s || r;
else if (_AP_Q==SC_RND_CONV)
qb &= ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, 0); (bool)(__Result__ & 1); }) || r;
else if (_AP_Q==SC_TRN_ZERO)
qb = s && ( qb || r );
Base::V += qb;
//return qb;
return carry&&(!(bool)({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W-1, _AP_W-1); (bool)(__Result__ & 1); }));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2>
struct RType {
enum {
_AP_F=_AP_W-_AP_I,
F2=_AP_W2-_AP_I2,
mult_w = _AP_W+_AP_W2,
mult_i = _AP_I+_AP_I2,
mult_s = _AP_S||_AP_S2,
plus_w = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1+((_AP_F) > (F2) ? (_AP_F) : (F2)),
plus_i = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1,
plus_s = _AP_S||_AP_S2,
minus_w = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1+((_AP_F) > (F2) ? (_AP_F) : (F2)),
minus_i = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1,
minus_s = true,
#pragma empty_line
div_w = _AP_W + ((_AP_W2 - _AP_I2) > (0) ? (_AP_W2 - _AP_I2) : (0)) + _AP_S2,
#pragma empty_line
#pragma empty_line
#pragma empty_line
div_i = _AP_I + _AP_W2 -_AP_I2 + _AP_S2,
div_s = _AP_S||_AP_S2,
logic_w = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+((_AP_F) > (F2) ? (_AP_F) : (F2)),
logic_i = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2))),
logic_s = _AP_S||_AP_S2
};
#pragma empty_line
typedef ap_fixed_base<mult_w, mult_i, mult_s> mult;
typedef ap_fixed_base<plus_w, plus_i, plus_s> plus;
typedef ap_fixed_base<minus_w, minus_i, minus_s> minus;
typedef ap_fixed_base<logic_w, logic_i, logic_s> logic;
typedef ap_fixed_base<div_w, div_i, div_s> div;
typedef ap_fixed_base<_AP_W, _AP_I, _AP_S> arg1;
};
#pragma empty_line
/// Constructors.
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base() {
;
/*
#ifdef __SC_COMPATIBLE__
Base::V = 0;
#endif
*/
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
/*__attribute__((weak))*/ ap_fixed_base (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2> &op) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
enum { N2=_AP_W2, _AP_F=_AP_W-_AP_I, F2=_AP_W2-_AP_I2,
QUAN_INC = F2>_AP_F && !(_AP_Q==SC_TRN || (_AP_Q==SC_TRN_ZERO && !_AP_S2)) };
bool carry = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
// handle quantization
unsigned sh_amt = (F2 > _AP_F) ? F2 - _AP_F : _AP_F - F2;
bool signbit = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W2-1, _AP_W2-1); (bool)(__Result__ & 1); });
#pragma empty_line
bool isneg = signbit && _AP_S2;
if (F2 == _AP_F)
Base::V = op.V;
else if (F2 > _AP_F) {
if (sh_amt < _AP_W2)
Base::V = op.V >> sh_amt;
else {
static int AllOnesInt = -1;
if (isneg) Base::V = AllOnesInt;
else Base::V = 0;
}
if (_AP_Q!=SC_TRN && !(_AP_Q==SC_TRN_ZERO && !_AP_S2)) {
bool qbit = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), F2-_AP_F-1, F2-_AP_F-1); (bool)(__Result__ & 1); });
#pragma empty_line
bool qb = (F2-_AP_F > _AP_W2) ? _AP_S2 && signbit : qbit;
#pragma empty_line
bool r = (F2 > _AP_F+1) ?
({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, F2-_AP_F-2<_AP_W2?F2-_AP_F-2:_AP_W2-1); __Result__; })!=0 : false;
#pragma empty_line
#pragma empty_line
carry = quantization_adjust(qb, r, _AP_S2 && signbit);
}
}
else { // no quantization
Base::V = op.V;
if (sh_amt < _AP_W)
Base::V = Base::V << sh_amt;
else
Base::V = 0;
}
#pragma empty_line
// handle overflow/underflow
if ((_AP_O != SC_WRAP || _AP_N != 0) && ((!_AP_S && _AP_S2) ||
_AP_I-_AP_S < _AP_I2-_AP_S2+(QUAN_INC ||
(_AP_S2 && _AP_O==SC_SAT_SYM)))) { // saturation
bool deleted_zeros = _AP_S2?true:!carry,
deleted_ones = true;
bool neg_src = isneg;
bool lD = false;
#pragma empty_line
bool newsignbit = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W-1, _AP_W-1); (bool)(__Result__ & 1); });
int pos1 = F2 - _AP_F + _AP_W;
int pos2 = F2 - _AP_F + _AP_W + 1;
if (pos1 < _AP_W2 && pos1 >= 0)
lD = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos1, pos1); (bool)(__Result__ & 1); });
#pragma empty_line
#pragma empty_line
#pragma empty_line
if(pos1 < _AP_W2)
{
bool Range1_all_ones = true;
bool Range1_all_zeros = true;
bool Range2_all_ones = true;
ap_int_base<_AP_W2,false> Range1(0);
ap_int_base<_AP_W2,false> Range2(0);
ap_int_base<_AP_W2,false> all_ones(-1);
#pragma empty_line
if (pos2 < _AP_W2 && pos2 >= 0) {
Range2.V = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos2, _AP_W2-1); __Result__; });
#pragma empty_line
#pragma empty_line
Range2_all_ones = Range2 == (all_ones >> pos2);
} else if (pos2 < 0)
Range2_all_ones = false;
#pragma empty_line
if (pos1 >= 0 && pos2 < _AP_W2) {
Range1.V = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos1, _AP_W2-1); __Result__; });
#pragma empty_line
#pragma empty_line
#pragma empty_line
Range1_all_ones = Range1 == (all_ones >> pos1);
Range1_all_zeros = !Range1.V ;
} else if (pos2 == _AP_W2) {
Range1_all_ones = lD;
Range1_all_zeros = !lD;
} else if (pos1 < 0) {
Range1_all_zeros = !op.V;
Range1_all_ones = false;
}
#pragma empty_line
#pragma empty_line
deleted_zeros = deleted_zeros && (carry ? Range1_all_ones: Range1_all_zeros);
deleted_ones = carry ? Range2_all_ones &&
(pos1 < 0 || !lD): Range1_all_ones;
neg_src = isneg && !(carry&&Range1_all_ones);
} else
neg_src = isneg && newsignbit;
bool neg_trg = _AP_S && newsignbit;
bool overflow = (neg_trg || !deleted_zeros) && !isneg;
bool underflow = (!neg_trg || !deleted_ones) && neg_src;
if ((_AP_O == SC_SAT_SYM) && _AP_S2 && _AP_S)
underflow |= neg_src && (_AP_W > 1 ?
({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0 : true);
#pragma empty_line
overflow_adjust(underflow, overflow, lD, neg_src);
}
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base(const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &op) {
*this = const_cast<ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(op);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base (const ap_int_base<_AP_W2,_AP_S2>& op) {
;
ap_fixed_base<_AP_W2,_AP_W2,_AP_S2> f_op;
f_op.V = op.V;
*this = f_op;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base( bool b ) { *this = (ap_fixed_base<1, 1, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base( char b ) { *this = (ap_fixed_base<8, 8, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( signed char b ) { *this = (ap_fixed_base<8, 8, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned char b ) { *this = (ap_fixed_base<8, 8, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base( signed short b ) { *this = (ap_fixed_base<16, 16, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned short b ) { *this = (ap_fixed_base<16, 16, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base( signed int b ) { *this = (ap_fixed_base<32, 32, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned int b ) { *this = (ap_fixed_base<32, 32, false>) b; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base( signed long b ) { *this = (ap_fixed_base<32, 32, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned long b ) { *this = (ap_fixed_base<32, 32, false>) b; }
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base( ap_slong b ) { *this = (ap_fixed_base<64, 64, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( ap_ulong b ) { *this = (ap_fixed_base<64, 64, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base(const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str),
10, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N, true);
Base::V = Result;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str),
radix, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N, true);
Base::V = Result;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
*this = ((bool)op);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const ap_range_ref<_AP_W2, _AP_S2>& op) {
*this = (ap_int_base<_AP_W2, false>(op));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_fixed_base(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op) {
*this = (ap_int_base<_AP_W2 + _AP_W3, false>(op));
#pragma empty_line
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
*this = (bool(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base(const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
*this = (ap_int_base<_AP_W2, false>(op));
}
#pragma empty_line
// helper function.
inline __attribute__((always_inline)) unsigned long long doubleToRawBits(double pf) const {
union {
unsigned long long __L;
double __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline __attribute__((always_inline)) unsigned int floatToRawBits(float pf) const {
union {
unsigned int __L;
float __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline __attribute__((always_inline)) unsigned short halfToRawBits(half pf) const {
union {
unsigned short __L;
half __D;
} LD;
LD.__D = pf;
return LD.__L;
}
#pragma empty_line
inline __attribute__((always_inline)) double rawBitsToDouble(unsigned long long pi) const {
union {
unsigned long long __L;
double __D;
} LD;
LD.__L = pi;
return LD.__D;
}
#pragma empty_line
inline __attribute__((always_inline)) float rawBitsToFloat (unsigned int pi) const {
union {
unsigned int __L;
float __D;
} LD;
LD.__L = pi;
return LD.__D;
}
#pragma empty_line
inline __attribute__((always_inline)) half rawBitsToHalf (unsigned short pi) const {
union {
unsigned short __L;
half __D;
} LD;
LD.__L = pi;
return LD.__D;
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base(double d) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_int_base<64,false> ireg;
ireg.V = doubleToRawBits(d);
bool isneg = ({ typeof(ireg.V) __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 63, 63); (bool)(__Result__ & 1); });
#pragma empty_line
ap_int_base<11 + 1, true> exp;
ap_int_base<11, false> exp_tmp;
exp_tmp.V = ({ typeof(ireg.V) __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 52, 52 + 11 -1); __Result__; });
#pragma empty_line
exp = exp_tmp - ((1<<(11 -1))-1);
ap_int_base<52 + 2, true> man;
man.V = ({ typeof(ireg.V) __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, 52 - 1); __Result__; });
//do not support NaN
#pragma empty_line
;
man.V = ({ typeof(man.V) __Result__ = 0; typeof(man.V) __Val2__ = man.V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 52); __Result__; });
if(isneg) man = -man;
if ( (ireg.V & 0x7fffffffffffffffLL)==0 ) {
Base::V = 0;
} else {
int _AP_W2=52 +2, _AP_I2=exp.V+2, _AP_F=_AP_W-_AP_I, F2=_AP_W2-_AP_I2;
bool _AP_S2 = true,
QUAN_INC = F2>_AP_F && !(_AP_Q==SC_TRN || (_AP_Q==SC_TRN_ZERO && !_AP_S2));
bool carry = false;
// handle quantization
unsigned sh_amt = (F2 > _AP_F) ? F2 - _AP_F : _AP_F - F2;
if (F2 == _AP_F)
Base::V = man.V;
else if (F2 > _AP_F) {
if (sh_amt < 52 + 2)
Base::V = man.V >> sh_amt;
else {
static int AllOnesInt = -1;
if (isneg) Base::V = AllOnesInt;
else Base::V = 0;
}
if ((_AP_Q != SC_TRN) && !((_AP_Q == SC_TRN_ZERO) && !_AP_S2)) {
#pragma empty_line
bool qb = (F2-_AP_F > _AP_W2) ?
isneg : (bool) ({ typeof(man.V) __Result__ = 0; typeof(man.V) __Val2__ = man.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), F2 - _AP_F - 1, F2 - _AP_F - 1); (bool)(__Result__ & 1); });
bool r = (F2 > _AP_F + 1) ? ({ typeof(man.V) __Result__ = 0; typeof(man.V) __Val2__ = man.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, (F2 - _AP_F - 2 < _AP_W2) ? (F2 - _AP_F - 2): (_AP_W2 - 1)); __Result__; }) !=
#pragma empty_line
0 : false;
carry = quantization_adjust(qb, r, isneg);
}
}
else { // no quantization
Base::V = man.V;
if (sh_amt < _AP_W)
Base::V = Base::V << sh_amt;
else
Base::V = 0;
}
// handle overflow/underflow
if ((_AP_O != SC_WRAP || _AP_N != 0) && ((!_AP_S && _AP_S2)
|| _AP_I - _AP_S < _AP_I2 - _AP_S2 + (QUAN_INC ||
(_AP_S2 && (_AP_O == SC_SAT_SYM)))) ) { // saturation
bool deleted_zeros = _AP_S2?true:!carry,
deleted_ones = true;
bool neg_src = isneg;
bool lD = false;
int pos1 =F2 - _AP_F + _AP_W;
int pos2 =F2 - _AP_F + _AP_W + 1;
bool newsignbit = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); });
if (pos1 < _AP_W2 && pos1 >= 0)
//lD = _ssdm_op_get_bit(man.V, pos1);
lD = (man.V >> pos1) & 1;
if (pos1 < _AP_W2 ) {
bool Range1_all_ones = true;
bool Range1_all_zeros = true;
bool Range2_all_ones = true;
ap_int_base<52 +2,false> Range2;
ap_int_base<52 +2,false> all_ones(-1);
#pragma empty_line
if (pos2 >= 0 && pos2 < _AP_W2) {
//Range2.V = _ssdm_op_get_range(man.V,
// pos2, _AP_W2 - 1);
Range2.V = man.V;
Range2.V >>= pos2;
Range2_all_ones = Range2 == (all_ones >> pos2);
} else if (pos2 < 0)
Range2_all_ones = false;
if (pos1 >= 0 && pos2 < _AP_W2) {
Range1_all_ones = Range2_all_ones && lD;
Range1_all_zeros = !Range2.V && !lD;
} else if (pos2 == _AP_W2) {
Range1_all_ones = lD;
Range1_all_zeros = !lD;
} else if (pos1 < 0) {
Range1_all_zeros = !man.V;
Range1_all_ones = false;
}
#pragma empty_line
deleted_zeros = deleted_zeros && (carry ? Range1_all_ones: Range1_all_zeros);
deleted_ones = carry ? Range2_all_ones &&
( pos1 < 0 || !lD): Range1_all_ones;
neg_src=isneg && !(carry&&Range1_all_ones);
} else
neg_src = isneg && newsignbit;
bool neg_trg = _AP_S && newsignbit;
bool overflow = (neg_trg || !deleted_zeros) && !isneg;
bool underflow =(!neg_trg || !deleted_ones) && neg_src;
if ((_AP_O == SC_SAT_SYM) && _AP_S2 && _AP_S)
underflow |= neg_src && (_AP_W > 1 ?
({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0 : true);
overflow_adjust(underflow, overflow, lD, neg_src);
}
}
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base(float d) {
*this = ap_fixed_base(double(d));
}
#pragma empty_line
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));
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base& operator=(const ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op)
{
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base& operator=(const volatile ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op)
{
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator=(const ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op) volatile
{
Base::V = op.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator=(const volatile ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op) volatile
{
Base::V = op.V;
}
#pragma empty_line
// Set this ap_fixed_base with a bits string. That means the ssdm_int::V
// inside this ap_fixed_base is assigned by bv.
// Note the input parameter should be a fixed-point formatted bit string.
inline __attribute__((always_inline)) ap_fixed_base& setBits(unsigned long long bv) {
Base::V = bv;
return *this;
}
// Return a ap_fixed_base object whose ssdm_int::V is assigned by bv.
// Note the input parameter should be a fixed-point formatted bit string.
static inline __attribute__((always_inline)) ap_fixed_base bitsToFixed(unsigned long long bv) {
ap_fixed_base Tmp;
Tmp.V = bv;
return Tmp;
}
#pragma empty_line
// Explicit conversion functions to ap_int_base that captures
// all integer bits (bits are truncated)
inline __attribute__((always_inline)) ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)),_AP_S>
to_ap_int_base(bool Cnative = true) const {
//return ap_int_base<AP_MAX(_AP_I,1),_AP_S>(_AP_I > 1 ?
// _ssdm_op_get_range(const_cast<ap_fixed_base*>(this)->Base::V,_AP_W-_AP_I,_AP_W-1) : 0);
ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)),_AP_S> ret(0);
if(_AP_I > 0 && _AP_I <= _AP_W)
ret.V = ({ typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast< ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - _AP_I, _AP_W - 1); __Result__; });
#pragma empty_line
#pragma empty_line
else if (_AP_I > _AP_W)
{
ret.V = ({ typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast< ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 1); __Result__; });
#pragma empty_line
unsigned int shift = _AP_I - _AP_W;
ret.V <<= shift;
}
if (Cnative) {
//Follow C native data type, conversion from double to int
if (_AP_S && ({ typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast< ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); })
#pragma empty_line
&& (_AP_I < _AP_W) && (({ typeof(const_cast<ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast<ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_I >= 0 ? _AP_W - _AP_I - 1: _AP_W - 1); __Result__; }) != 0))
#pragma empty_line
#pragma empty_line
ret.V += 1;
} else {
//Follow OSCI library, conversion from sc_fixed to sc_int
}
return ret;
};
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) operator ap_int_base<_AP_W2,_AP_S2> () const {
return (ap_int_base<_AP_W2,_AP_S2>)to_ap_int_base();
}
#pragma empty_line
// Explicit conversion function to C built-in integral type.
inline __attribute__((always_inline)) int to_int() const {
return to_ap_int_base().to_int();
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return to_ap_int_base().to_uint();
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return to_ap_int_base().to_int64();
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return to_ap_int_base().to_uint64();
}
/*__attribute__((weak))*/ double to_double() const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (_AP_W - _AP_I > 0 && _AP_W <= 64) {
if (!Base::V)
return 0;
double dp = Base::V;
ap_int_base<64,true> res;
res.V = doubleToRawBits(dp);
ap_int_base<11, true> exp;
exp.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 52, 62); __Result__; });
exp -= _AP_W - _AP_I;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp.V) __Repl2__ = exp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 62); __Result__; });
dp = rawBitsToDouble(res.to_int64());
return dp;
} else if (_AP_I - _AP_W >= 0 && _AP_I <= 64) {
ap_int_base<((1) > (_AP_I) ? (1) : (_AP_I)), _AP_S> temp;
temp.V = Base::V;
temp <<= _AP_I - _AP_W;
double dp = temp.V;
return dp;
} else {
if (!Base::V)
return 0;
ap_int_base<64,true> res;
res.V = 0;
bool isneg = _AP_S ? ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }) : false;
#pragma empty_line
ap_int_base<_AP_W+_AP_S,_AP_S> tmp;
tmp.V = Base::V;
if (isneg) tmp.V = -Base::V;
#pragma empty_line
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(isneg) __Repl2__ = !!isneg; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 63, 63); __Result__; });
int j = _AP_W+_AP_S-1-tmp.countLeadingZeros();
#pragma empty_line
int exp = _AP_I-(_AP_W-j);
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp + ((1<<(11 -1))-1)) __Repl2__ = exp + ((1<<(11 -1))-1); __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 62); __Result__; });
if (j == 0)
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(0) __Repl2__ = 0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 52 - 1); __Result__; });
else {
ap_int_base<52,false> man;
man.V = ({ typeof(tmp.V) __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), j > 52 ? j - 52 : 0, j - 1); __Result__; });
#pragma empty_line
man.V <<= 52 > j ? 52 -j : 0;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(man.V) __Repl2__ = man.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 52 - 1); __Result__; });
}
double dp = rawBitsToDouble(res.to_int64());
return dp;
}
#pragma empty_line
}
#pragma empty_line
/*__attribute__((weak))*/ float to_float() const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (_AP_W - _AP_I > 0 && _AP_W <= 64) {
if (!Base::V)
return 0;
float dp = Base::V;
ap_int_base<32,true> res;
res.V = floatToRawBits(dp);
ap_int_base<8, true> exp;
exp.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 23, 30); __Result__; });
exp -= _AP_W - _AP_I;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp.V) __Repl2__ = exp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 23, 30); __Result__; });
dp = rawBitsToFloat(res.to_int());
return dp;
} else if (_AP_I - _AP_W >= 0 && _AP_I <= 64) {
ap_int_base<((1) > (_AP_I) ? (1) : (_AP_I)), _AP_S> temp;
temp.V = Base::V;
temp <<= _AP_I - _AP_W;
float dp = temp.V;
return dp;
} else {
if (!Base::V)
return 0;
ap_int_base<32,true> res;
res.V = 0;
bool isneg = _AP_S ? ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }) : false;
#pragma empty_line
ap_int_base<_AP_W+_AP_S,_AP_S> tmp;
tmp.V = Base::V;
if (isneg) tmp.V = -Base::V;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(isneg) __Repl2__ = !!isneg; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 31, 31); __Result__; });
int j = _AP_W+_AP_S-1-tmp.countLeadingZeros();
#pragma empty_line
int exp = _AP_I-(_AP_W-j);
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp + ((1<<(8 -1))-1)) __Repl2__ = exp + ((1<<(8 -1))-1); __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 23, 30); __Result__; });
if (j == 0)
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(0) __Repl2__ = 0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 23 - 1); __Result__; });
else {
ap_int_base<23,false> man;
man.V = ({ typeof(tmp.V) __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), j > 23 ? j - 23 : 0, j - 1); __Result__; });
#pragma empty_line
man.V <<= 23 > j ? 23 -j: 0;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(man.V) __Repl2__ = man.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 23 - 1); __Result__; });
}
return rawBitsToFloat(res.to_int());
}
}
inline __attribute__((always_inline)) half to_half() const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
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;
#pragma empty_line
ap_int_base<_AP_W+_AP_S,_AP_S> tmp;
tmp.V = Base::V;
if (isneg) tmp.V = -Base::V;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(isneg) __Repl2__ = !!isneg; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 31, 31); __Result__; });
int j = _AP_W+_AP_S-1-tmp.countLeadingZeros();
#pragma empty_line
int exp = _AP_I-(_AP_W-j);
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp + ((1<<(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__; });
#pragma empty_line
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());
}
}
#pragma empty_line
inline __attribute__((always_inline)) operator double () const {
return to_double();
}
#pragma empty_line
inline __attribute__((always_inline)) operator float () const {
return to_float();
}
inline __attribute__((always_inline)) operator half () const {
return to_half();
}
inline __attribute__((always_inline)) operator char () const {
return (char) to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator signed char () const {
return (signed char) to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned char () const {
return (unsigned char) to_uint();
}
#pragma empty_line
inline __attribute__((always_inline)) operator short () const {
return (short) to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned short () const {
return (unsigned short) to_uint();
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) operator int () const {
return to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned int () const {
return to_uint();
}
#pragma line 1267 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
inline __attribute__((always_inline)) operator long () const {
return (long)to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long () const {
return (unsigned long) to_uint();
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long long () const {
return to_uint64();
}
#pragma empty_line
inline __attribute__((always_inline)) operator long long () const {
return to_int64();
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const { return _AP_W; };
// Count the number of zeros from the most significant bit
// to the first one bit. Note this is only for ap_fixed_base whose
// _AP_W <= 64, otherwise will incur assertion.
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctzll(t.V);
} else {
enum { __N = (_AP_W+63)/64 };
int NZeros = 0;
unsigned i = 0;
bool hitNonZero = false;
for (i=0; i<__N-1; ++i) {
ap_int_base<64, false> t;
t.range(0, 63) = this->range(_AP_W - i*64 - 64, _AP_W - i*64 - 1);
NZeros += hitNonZero?0:__builtin_clzll(t.V);
hitNonZero |= (t != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
t.range(63-(_AP_W-1)%64, 63) = this->range(0, (_AP_W-1)%64);
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
#pragma empty_line
// Arithmetic : Binary
// -------------------------------------------------------------------------
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::mult
operator *(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const {
typename RType<_AP_W2,_AP_I2,_AP_S2>::mult r;
ap_int_base<_AP_W+_AP_W2,_AP_S> OP1;
OP1.V = Base::V;
ap_int_base<_AP_W+_AP_W2,_AP_S2> OP2;
OP2.V = op2.V ;
r.V = OP1.V * OP2.V;
return r;
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::div
operator /(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const {
typename RType<_AP_W2,_AP_I2,_AP_S2>::div r;
#pragma empty_line
ap_fixed_base<_AP_W + ((_AP_W2 - _AP_I2) > (0) ? (_AP_W2 - _AP_I2) : (0)),
_AP_I, _AP_S> t(*this);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
r.V = t.V / op2.V;
//r = double(to_double() / op2.to_double());
return r;
}
#pragma line 1360 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::plus operator + (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { ; enum { _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::plus r, lhs(*this), rhs(op2); ; r.V = lhs.V + rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::minus operator - (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { ; enum { _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::minus r, lhs(*this), rhs(op2); ; r.V = lhs.V - rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::logic operator & (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { ; enum { _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::logic r, lhs(*this), rhs(op2); ; r.V = lhs.V & rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::logic operator | (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { ; enum { _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::logic r, lhs(*this), rhs(op2); ; r.V = lhs.V | rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::logic operator ^ (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { ; enum { _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::logic r, lhs(*this), rhs(op2); ; r.V = lhs.V ^ rhs.V; return r; }
#pragma empty_line
#pragma empty_line
// Arithmetic : assign
// -------------------------------------------------------------------------
#pragma line 1378 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator += (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator + (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator -= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator - (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator *= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator * (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator /= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator / (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator &= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator & (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator |= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator | (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator ^= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator ^ (op2); return *this; }
#pragma empty_line
#pragma empty_line
// Prefix increment, decrement.
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base& operator ++() {
operator+=(ap_fixed_base<_AP_W-_AP_I+1,1,false>(1));
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& operator --() {
operator-=(ap_fixed_base<_AP_W-_AP_I+1,1,false>(1));
return *this;
}
#pragma empty_line
// Postfix increment, decrement
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) const ap_fixed_base
operator ++(int) {
ap_fixed_base t(*this);
operator++();
return t;
}
inline __attribute__((always_inline)) const ap_fixed_base
operator --(int) {
ap_fixed_base t(*this);
operator--();
return t;
}
#pragma empty_line
// Unary arithmetic.
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base operator +() {
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base<_AP_W + 1, _AP_I + 1, true> operator -() const {
ap_fixed_base<_AP_W + 1, _AP_I + 1, true> ret(*this);
ret.V = - ret.V;
return ret;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,true,_AP_Q,_AP_O,_AP_N> getNeg() {
ap_fixed_base<_AP_W,_AP_I,true,_AP_Q,_AP_O,_AP_N> Tmp(*this);
Tmp.V = -Tmp.V;
return Tmp;
}
#pragma empty_line
// Not (!)
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) bool operator !() const {
return Base::V == 0;
}
#pragma empty_line
// Bitwise complement
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S> operator ~() const {
ap_fixed_base<_AP_W, _AP_I, _AP_S> ret;
ret.V=~Base::V;
return ret;
}
#pragma empty_line
// Shift
// -------------------------------------------------------------------------
template<int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> lshift () const {
ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
#pragma empty_line
template<int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> rshift () const {
ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator << (int sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
if (isNeg) r.V = Base::V >> sh;
else r.V = Base::V << sh;
#pragma line 1509 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
return r;
#pragma empty_line
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator << (const ap_int_base<_AP_W2,true>& op2) const {
int sh = op2.to_int();
return operator << (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator << (unsigned int sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
r.V = Base::V << sh;
#pragma line 1554 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
return r;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator << (const ap_int_base<_AP_W2,false>& op2) const {
unsigned int sh = op2.to_uint();
return operator << (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator >> (int sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
if (isNeg) r.V = Base::V << sh;
else r.V = Base::V >> sh;
#pragma line 1612 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
return r;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_int_base<_AP_W2,true>& op2) const {
int sh = op2.to_int();
return operator >> (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator >> (unsigned sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
r.V = Base::V >> sh;
#pragma line 1644 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
return r;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_int_base<_AP_W2,false>& op2) const {
unsigned int sh = op2.to_uint();
return operator >> (sh);
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator >> (op2.to_ap_int_base());
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base
operator << (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator << (op2.to_ap_int_base());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Shift assign
// -------------------------------------------------------------------------
/*__attribute__((weak))*/ ap_fixed_base&
operator <<= (int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (sh == 0) return *this;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
#pragma line 1713 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
if (isNeg) Base::V >>= sh;
else Base::V <<= sh;
#pragma line 1727 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator <<= (const ap_int_base<_AP_W2,true>& op2) {
int sh = op2.to_int();
return operator <<= (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base&
operator <<= (unsigned int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma line 1762 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
Base::V <<= sh;
#pragma line 1774 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator <<= (const ap_int_base<_AP_W2,false>& op2) {
unsigned int sh = op2.to_uint();
return operator <<= (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base&
operator >>= (int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (sh == 0) return *this;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
#pragma line 1822 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
if (isNeg) Base::V <<= sh;
else Base::V >>= sh;
#pragma line 1836 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator >>= (const ap_int_base<_AP_W2,true>& op2) {
int sh = op2.to_int();
return operator >>= (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base&
operator >>= (unsigned int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma line 1866 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
Base::V >>= sh;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator >>= (const ap_int_base<_AP_W2,false>& op2) {
unsigned int sh = op2.to_uint();
return operator >>= (sh);
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base&
operator >>= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator >>= (op2.to_ap_int_base());
}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base&
operator <<= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator <<= (op2.to_ap_int_base());
}
#pragma empty_line
// Comparisons.
// -------------------------------------------------------------------------
#pragma line 1913 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator == (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V == op2.V; else if (_AP_F > F2) return Base::V == ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V == op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator != (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V != op2.V; else if (_AP_F > F2) return Base::V != ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V != op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator > (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V > op2.V; else if (_AP_F > F2) return Base::V > ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V > op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator >= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V >= op2.V; else if (_AP_F > F2) return Base::V >= ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V >= op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator < (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V < op2.V; else if (_AP_F > F2) return Base::V < ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V < op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator <= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V <= op2.V; else if (_AP_F > F2) return Base::V <= ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V <= op2.V; return false; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) bool operator == (double d) const { return to_double() == d; }
inline __attribute__((always_inline)) bool operator != (double d) const { return to_double() != d; }
inline __attribute__((always_inline)) bool operator > (double d) const { return to_double() > d; }
inline __attribute__((always_inline)) bool operator >= (double d) const { return to_double() >= d; }
inline __attribute__((always_inline)) bool operator < (double d) const { return to_double() < d; }
inline __attribute__((always_inline)) bool operator <= (double d) const { return to_double() <= d; }
#pragma empty_line
// Bit and Slice Select
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> operator[] (unsigned index) {
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> operator [] (const ap_int_base<_AP_W2,_AP_S2>& index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index.to_int());
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator [] (unsigned index) const {
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index, index); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> bit(unsigned index) {
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index);
}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> bit (const ap_int_base<_AP_W2,_AP_S2>& index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index.to_int());
}
#pragma empty_line
inline __attribute__((always_inline)) bool bit (unsigned index) const {
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index, index); (bool)(__Result__ & 1); });
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> get_bit (const ap_int_base<_AP_W2, true>& index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index.to_int() + _AP_W - _AP_I);
}
#pragma empty_line
inline __attribute__((always_inline)) bool get_bit (int index) const {
;
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index + _AP_W - _AP_I, index + _AP_W - _AP_I); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> get_bit (int index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index + _AP_W - _AP_I);
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) bool get_bit (const ap_int_base<_AP_W2, true>& index) const {
;
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index.to_int() + _AP_W - _AP_I, index.to_int() + _AP_W - _AP_I); (bool)(__Result__ & 1); });
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
range(int Hi, int Lo) {
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
operator () (int Hi, int Lo) {
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range(int Hi, int Lo) const {
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(const_cast<
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>*>(this),
Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
range(const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
operator () (const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
range(const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(const_cast<
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>*>(this),
Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
operator () (const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range() {
return this->range(_AP_W - 1, 0);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range() const {
return this->range(_AP_W - 1, 0);
}
#pragma empty_line
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0;
}
#pragma empty_line
inline __attribute__((always_inline)) bool is_neg () const {
if (_AP_S && ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }))
return true;
return false;
}
#pragma empty_line
inline __attribute__((always_inline)) int wl () const {
return _AP_W;
}
#pragma empty_line
inline __attribute__((always_inline)) int iwl () const {
return _AP_I;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_q_mode q_mode () const {
return _AP_Q;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_o_mode o_mode () const {
return _AP_O;
}
#pragma empty_line
inline __attribute__((always_inline)) int n_bits () const {
return _AP_N;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(BaseMode mode) {
return 0;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(signed char mode) {
return to_string(BaseMode(mode));
}
};
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_not(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) {
ret.V = ~ op.V;
}
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_and(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V & op2.V;
}
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_or(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V | op2.V;
}
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_xor(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V ^ op2.V;
}
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N, int _AP_W2, int _AP_I2,
bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) void neg(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
ap_fixed_base<_AP_W2+!_AP_S2, _AP_I2+!_AP_S2, true, _AP_Q2, _AP_O2, _AP_N2> Tmp;
Tmp.V = - op.V;
ret = Tmp;
}
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N, int _AP_W2, int _AP_I2,
bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) void lshift(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op,
int i) {
ap_fixed_base<_AP_W2 - _AP_I2 + ((_AP_I) > (_AP_I2) ? (_AP_I) : (_AP_I2)), ((_AP_I) > (_AP_I2) ? (_AP_I) : (_AP_I2)), _AP_S2, _AP_Q2, _AP_O2, _AP_N2> Tmp;
Tmp.V = op.V;
Tmp.V <<= i;
ret = Tmp;
}
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N, int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) void rshift(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op,
int i) {
ap_fixed_base<_AP_I2 + ((_AP_W - _AP_I) > (_AP_W2 - _AP_I2) ? (_AP_W - _AP_I) : (_AP_W2 - _AP_I2)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> Tmp;
const int val = _AP_W - _AP_I - (_AP_W2 - _AP_I2);
Tmp.V = op.V;
if (val > 0) Tmp.V <<= val;
Tmp.V >>= i;
ret = Tmp;
}
#pragma line 2186 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<> inline __attribute__((always_inline)) ap_fixed_base<1,1,true,SC_TRN,SC_WRAP>::ap_fixed_base(bool i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<1,1,false,SC_TRN,SC_WRAP>::ap_fixed_base(bool i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,true,SC_TRN,SC_WRAP>::ap_fixed_base(char i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,false,SC_TRN,SC_WRAP>::ap_fixed_base(char i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,true,SC_TRN,SC_WRAP>::ap_fixed_base(signed char i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,false,SC_TRN,SC_WRAP>::ap_fixed_base(signed char i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,true,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned char i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,false,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned char i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,true,SC_TRN,SC_WRAP>::ap_fixed_base(signed short i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,false,SC_TRN,SC_WRAP>::ap_fixed_base(signed short i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,true,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned short i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,false,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned short i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,true,SC_TRN,SC_WRAP>::ap_fixed_base(signed int i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,false,SC_TRN,SC_WRAP>::ap_fixed_base(signed int i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,true,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned int i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,false,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned int i_op) { Base::V = i_op; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,true,SC_TRN,SC_WRAP>::ap_fixed_base(long i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,false,SC_TRN,SC_WRAP>::ap_fixed_base(long 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 long 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 long i_op) { Base::V = i_op; }
#pragma empty_line
template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,true,SC_TRN,SC_WRAP>::ap_fixed_base(ap_slong i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,false,SC_TRN,SC_WRAP>::ap_fixed_base(ap_slong i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,true,SC_TRN,SC_WRAP>::ap_fixed_base(ap_ulong i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,false,SC_TRN,SC_WRAP>::ap_fixed_base(ap_ulong i_op) { Base::V = i_op; }
#pragma empty_line
#pragma empty_line
/// Output streamimg.
// -----------------------------------------------------------------------------
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) std::ostream&
operator << (std::ostream& os, const ap_fixed_base<_AP_W,_AP_I,
_AP_S,_AP_Q,_AP_O, _AP_N>& x) {
// os << x.to_double();
return os;
}
#pragma empty_line
/// Input streamimg.
// -----------------------------------------------------------------------------
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) std::istream&
operator >> (std::istream& in, ap_fixed_base<_AP_W,_AP_I,
_AP_S,_AP_Q,_AP_O, _AP_N>& x) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return in;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
/// Operators mixing Integers with ap_fixed_base
// -----------------------------------------------------------------------------
#pragma line 2304 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator + (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::plus operator + ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator - (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::minus operator - ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator * (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::mult operator * ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator / (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::div operator / ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator >> (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator << (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator & (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator & ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator | (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator | ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator ^ (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator ^ ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator == (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator != (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator > (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator >= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator < (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator <= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator += (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator -= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator *= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator /= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator >>= (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator <<= (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator &= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator |= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator ^= (ap_fixed_base<1,1,false>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator + (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::plus operator + ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator - (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator * (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator / (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator >> (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator << (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator & (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator | (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator ^ (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator == (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator != (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator > (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator >= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator < (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator <= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator += (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator -= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator *= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator /= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator >>= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator <<= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator &= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator |= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator ^= (ap_fixed_base<8,8,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator + (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::plus operator + ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator - (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator * (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator / (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator >> (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator << (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator & (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator | (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator ^ (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator == (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator != (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator > (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator >= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator < (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator <= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator += (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator -= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator *= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator /= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator >>= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator <<= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator &= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator |= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator ^= (ap_fixed_base<8,8,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator + (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::plus operator + ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator - (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::minus operator - ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator * (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::mult operator * ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator / (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::div operator / ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >> (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator << (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator & (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator & ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator | (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator | ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator ^ (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator ^ ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator == (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator != (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator > (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator < (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator += (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator -= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator *= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator /= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >>= (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <<= (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator &= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator |= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator ^= (ap_fixed_base<8,8,false>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator + (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::plus operator + ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator - (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::minus operator - ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator * (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::mult operator * ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator / (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::div operator / ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator >> (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator << (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator & (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator & ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator | (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator | ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator ^ (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator ^ ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator == (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator != (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator > (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator >= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator < (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator <= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator += (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator -= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator *= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator /= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator >>= (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator <<= (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator &= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator |= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator ^= (ap_fixed_base<16,16,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator + (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::plus operator + ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator - (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::minus operator - ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator * (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::mult operator * ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator / (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::div operator / ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >> (ap_int_base<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator << (ap_int_base<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator & (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::logic operator & ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator | (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::logic operator | ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator ^ (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::logic operator ^ ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator == (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator != (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator > (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator < (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator += (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator -= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator *= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator /= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >>= (ap_int_base<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <<= (ap_int_base<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator &= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator |= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator ^= (ap_fixed_base<16,16,false>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator + (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::plus operator + ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator - (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::minus operator - ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator * (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::mult operator * ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator / (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::div operator / ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator >> (ap_int_base<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator << (ap_int_base<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator & (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::logic operator & ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator | (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::logic operator | ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator ^ (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::logic operator ^ ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator == (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator != (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator > (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator >= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator < (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator <= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator += (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator -= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator *= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator /= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator >>= (ap_int_base<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator <<= (ap_int_base<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator &= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator |= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator ^= (ap_fixed_base<32,32,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator + (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::plus operator + ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator - (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::minus operator - ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator * (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::mult operator * ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator / (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::div operator / ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >> (ap_int_base<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator << (ap_int_base<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator & (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::logic operator & ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator | (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::logic operator | ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator ^ (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::logic operator ^ ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator == (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator != (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator > (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator < (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator += (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator -= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator *= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator /= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >>= (ap_int_base<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <<= (ap_int_base<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator &= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator |= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator ^= (ap_fixed_base<32,32,false>(i_op)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<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 + ( long 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, long 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 - ( long 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, long 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 * ( long 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, long 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 / ( long 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, long 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, long 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, long 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 & ( long 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, long 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 | ( long 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, long 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 ^ ( long 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, long 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 == ( long 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, long 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 != ( long 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, long 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 > ( long 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, long 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 >= ( long 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, long 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 < ( long 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, long 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 <= ( long 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, long 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, long 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, long 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, long 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, long 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, long 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, long 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, long 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, long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long 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 long i_op) { return op.operator ^= (ap_fixed_base<32,32,false>(i_op)); }
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator + (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::plus operator + ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator - (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::minus operator - ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator * (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::mult operator * ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator / (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::div operator / ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >> (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator << (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator & (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::logic operator & ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator | (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::logic operator | ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator ^ (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::logic operator ^ ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator == (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator != (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator > (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator < (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator += (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator -= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator *= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator /= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >>= (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <<= (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator &= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator |= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator ^= (ap_fixed_base<64,64,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator + (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::plus operator + ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator - (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::minus operator - ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator * (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::mult operator * ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator / (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::div operator / ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >> (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator << (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator & (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::logic operator & ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator | (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::logic operator | ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator ^ (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::logic operator ^ ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator == (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator != (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator > (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator < (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator += (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator -= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator *= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator /= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >>= (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <<= (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator &= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator |= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator ^= (ap_fixed_base<64,64,false>(i_op)); }
#pragma line 2354 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::plus operator + ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::plus operator + ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator + (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::minus operator - ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::minus operator - ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator - (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::mult operator * ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::mult operator * ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator * (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::div operator / ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::div operator / ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator / (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::logic operator & ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::logic operator & ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator & (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::logic operator | ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::logic operator | ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator | (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::logic operator ^ ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::logic operator ^ ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator ^ (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator == ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator == (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator != ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator != (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator > ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator > (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator >= ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator >= (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator < ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator < (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator <= ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator <= (op); }
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator += (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator += ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator += (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator -= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator -= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator -= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator *= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator *= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator *= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator /= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator /= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator /= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator &= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator &= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator &= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator |= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator |= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator |= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator ^= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator ^= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator ^= (op.to_ap_int_base()); }
#pragma empty_line
// Relational Operators with double
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator == ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op2) {
return op2.operator == (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator != ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator != (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator > ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator < (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator >= ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op2) {
return op2.operator <= (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator < ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator > (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator <= ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator >= (op1);
}
#pragma line 2439 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
#pragma empty_line
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
#pragma line 2479 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator > (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator > (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator > (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator < (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator < (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator < (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator >= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator >= (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator <= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator <= (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator == (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator == (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator == (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator != (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator != (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator != (ap_int_base<1,false>(op)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 17 "D:/ProgramData/Xilinx/SDx/2016.4/Vivado_HLS/common/technology/autopilot\\ap_int.h" 2
//Forward declaration
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N> struct ap_fixed;
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N> struct ap_ufixed;
template<int _AP_W> struct ap_int;
template<int _AP_W> struct ap_uint;
#pragma empty_line
//AP_INT
//--------------------------------------------------------
template<int _AP_W>
struct ap_int: ap_int_base<_AP_W, true> {
typedef ap_int_base<_AP_W, true> Base;
//Constructor
inline __attribute__((always_inline)) ap_int(): Base() {}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int(const ap_int<_AP_W2> &op) {Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int(const volatile ap_int<_AP_W2> &op) {Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int(const ap_uint<_AP_W2> &op) { Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int(const volatile ap_uint<_AP_W2> &op) { Base::V = op.V;}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int(const ap_range_ref<_AP_W2, _AP_S2>& ref):Base(ref) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int(const ap_bit_ref<_AP_W2, _AP_S2>& ref):Base(ref) {}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& ref):Base(ref) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int(const ap_int_base<_AP_W2, _AP_S2>& op){ Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op):Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op):Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op):Base(op) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_int(bool val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(signed char val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned char val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(short val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned short val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(int val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned int val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned long long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(long long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(half val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(float val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(double val) {Base::V = val; }
#pragma empty_line
inline __attribute__((always_inline)) ap_int(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_int(const char* str, signed char radix):Base(str, radix) {}
//Assignment
//Assignment
//Another form of "write"
inline __attribute__((always_inline)) void operator = (const ap_int<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_int<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int& operator = (const volatile ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int& operator = (const ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
};
#pragma empty_line
//AP_UINT
//---------------------------------------------------------------
template<int _AP_W>
struct ap_uint: ap_int_base<_AP_W, false> {
typedef ap_int_base<_AP_W, false> Base;
//Constructor
inline __attribute__((always_inline)) ap_uint(): Base() {}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const ap_uint<_AP_W2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const ap_int<_AP_W2> &op) { Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_uint<_AP_W2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_int<_AP_W2> &op) { Base::V = op.V;}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_uint(const ap_range_ref<_AP_W2, _AP_S2>& ref):Base(ref) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_uint(const ap_bit_ref<_AP_W2, _AP_S2>& ref):Base(ref) {}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_uint(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& ref):Base(ref) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_uint(const ap_int_base<_AP_W2, _AP_S2>& op){ Base::V = op.V;}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op):Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op):Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op):Base(op) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_uint(bool val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(signed char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned long long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(long long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(half val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(float val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(double val) { Base::V = val; }
#pragma empty_line
inline __attribute__((always_inline)) ap_uint(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_uint(const char* str, signed char radix):Base(str, radix) {}
//Assignment
//Another form of "write"
inline __attribute__((always_inline)) void operator = (const ap_uint<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_uint<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_uint& operator = (const volatile ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_uint& operator = (const ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
};
#pragma empty_line
#pragma empty_line
//AP_FIXED
//---------------------------------------------------------------------
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q = SC_TRN,
ap_o_mode _AP_O = SC_WRAP, int _AP_N = 0>
struct ap_fixed: ap_fixed_base<_AP_W, _AP_I, true, _AP_Q, _AP_O, _AP_N> {
typedef ap_fixed_base<_AP_W, _AP_I, true, _AP_Q, _AP_O, _AP_N> Base;
//Constructor
inline __attribute__((always_inline)) ap_fixed():Base() {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2,
_AP_O2, _AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
true, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2,
_AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
false, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed(const ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed(const ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2,
_AP_O2, _AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
true, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2,
_AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
false, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op):Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_bit_ref<_AP_W2, _AP_S2>& op):
Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_range_ref<_AP_W2, _AP_S2>& op):
Base(op) {}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_fixed(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op):
Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op): Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op): Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_int_base<_AP_W2, _AP_S2>& op): Base(op) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed(bool v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(signed char v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned char v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(short v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned short v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(int v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned int v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned long long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(long long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(half v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(float v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(double v):Base(v) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_fixed(const char* str, signed char radix):Base(str, radix) {}
#pragma empty_line
//Assignment
inline __attribute__((always_inline)) ap_fixed& operator = (const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O,
_AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed& operator = (const volatile ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O,
_AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
//AP_UFIXED
//-------------------------------------------------------------------
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q = SC_TRN,
ap_o_mode _AP_O = SC_WRAP, int _AP_N = 0>
struct ap_ufixed: ap_fixed_base<_AP_W, _AP_I, false, _AP_Q, _AP_O, _AP_N> {
typedef ap_fixed_base<_AP_W, _AP_I, false, _AP_Q, _AP_O, _AP_N> Base;
//Constructor
inline __attribute__((always_inline)) ap_ufixed():Base() {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2,
_AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
true, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2,
_AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
false, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_ufixed(const ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_ufixed(const ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2,
_AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
true, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2,
_AP_N2>& op): Base(ap_fixed_base<_AP_W2, _AP_I2,
false, _AP_Q2, _AP_O2, _AP_N2>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op):Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const ap_bit_ref<_AP_W2, _AP_S2>& op):
Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const ap_range_ref<_AP_W2, _AP_S2>& op):
Base(op) {}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_ufixed(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op):
Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op): Base(op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op): Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const ap_int_base<_AP_W2, _AP_S2>& op): Base(op) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_ufixed(bool v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(signed char v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned char v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(short v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned short v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(int v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned int v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned long long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(long long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(half v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(float v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(double v):Base(v) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_ufixed(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_ufixed(const char* str, signed char radix):Base(str, radix) {}
#pragma empty_line
//Assignment
inline __attribute__((always_inline)) ap_ufixed& operator = (const ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_ufixed& operator = (const volatile ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 5 "conv_core_new/conv_core.h" 2
#pragma empty_line
#pragma empty_line
using namespace std;
#pragma empty_line
//typedef ap_int<8> Dtype_f;
//typedef ap_int<8> Dtype_w;
//typedef ap_int<15> Dtype_mul;
//typedef ap_int<32> Dtype_acc;
#pragma empty_line
typedef float Dtype_f;
typedef float Dtype_w;
typedef float Dtype_mul;
typedef float Dtype_acc;
#pragma empty_line
void Conv(ap_uint<16> CHin,ap_uint<16> Hin,ap_uint<16> Win,ap_uint<16> CHout,
ap_uint<8> Kx,ap_uint<8> Ky,ap_uint<8> Sx,ap_uint<8> Sy,ap_uint<1> mode,ap_uint<1> relu_en,
Dtype_f feature_in[],Dtype_w W[],Dtype_w bias[],Dtype_f feature_out[]
);//mode: 0:VALID, 1:SAME
#pragma line 2 "conv_core_new/conv_core.cpp" 2
#pragma empty_line
//Feature: [H][W][C]
//kernel: [Ky][Kx][CHin][CHout]
#pragma empty_line
void Conv(ap_uint<16> CHin,ap_uint<16> Hin,ap_uint<16> Win,ap_uint<16> CHout,
ap_uint<8> Kx,ap_uint<8> Ky,ap_uint<8> Sx,ap_uint<8> Sy,ap_uint<1> mode,ap_uint<1> relu_en,
Dtype_f feature_in[],Dtype_w W[],Dtype_w bias[],Dtype_f feature_out[]
)//mode: 0:VALID, 1:SAME
{
//#pragma HLS PIPELINE enable_flush
#pragma HLS INTERFACE m_axi depth=4294967295 port=feature_out offset=slave
#pragma HLS INTERFACE m_axi depth=4294967295 port=bias offset=slave
#pragma HLS INTERFACE m_axi depth=4294967295 port=W offset=slave
#pragma HLS INTERFACE m_axi depth=4294967295 port=feature_in offset=slave
#pragma HLS INTERFACE s_axilite port=&relu_en
#pragma HLS INTERFACE s_axilite port=&CHout
#pragma HLS INTERFACE s_axilite port=&Sx
#pragma HLS INTERFACE s_axilite port=&Hin
#pragma HLS INTERFACE s_axilite port=&CHin
#pragma HLS INTERFACE s_axilite port=&Kx
#pragma HLS INTERFACE s_axilite port=&mode
#pragma HLS INTERFACE s_axilite port=&Sy
#pragma HLS INTERFACE s_axilite port=&Ky
#pragma HLS INTERFACE s_axilite port=&Win
#pragma HLS INTERFACE s_axilite port=return
#pragma empty_line
ap_uint<8> pad_x,pad_y;
if(mode==0)
{
pad_x=0;pad_y=0;
}
else
{
pad_x=(Kx-1)/2;pad_y=(Ky-1)/2;
}
ap_uint<16> Hout,Wout;
Wout=(Win+2*pad_x-Kx)/Sx+1;
Hout=(Hin+2*pad_y-Ky)/Sy+1;
#pragma empty_line
for(int cout=0;cout<CHout;cout++) //channel output
for(int i=0;i<Wout;i++) //weight output
for(int j=0;j<Hout;j++) //height output
{
Dtype_acc sum=0;
for(int cin=0;cin<CHin;cin++)
{
for(int ii=0;ii<Kx;ii++)
for(int jj=0;jj<Ky;jj++)
{
ap_int<16> w=i*Sx-pad_x+ii;
ap_int<16> h=j*Sy-pad_y+jj;
if(h>=0 && w>=0 && h<Hin && w<Win)
{
//Feature [C][W][H]
//kernel: [Ky][Kx][CHin][CHout]
//Dtype_mul tp=feature_in[cin][w][h]*w[cout][cin][ii][jj];
// std::cout<<"cin:"<<cin<<",w"<<w<<",h"<<h<<"\n";
// std::cout<<"feature_in["<<cin*Hin*Win+w*Hin+h<<"]*W["<<cout*CHin*Kx*Ky+cin*Kx*Ky+ii*Ky+jj<<"]\n";
Dtype_mul tp=feature_in[cin*Hin*Win+w*Hin+h]*W[cout*CHin*Kx*Ky+cin*Kx*Ky+ii*Ky+jj];
sum+=tp;
}
}
}
sum+=bias[cout];
if(relu_en && sum<0)
sum=0;
//feature_out[cout][i][j]=sum;
feature_out[cout*Wout*Hout+i*Hout+j]=sum;
}
}
| [
"2322900041@qq.com"
] | 2322900041@qq.com |
4681be151be0b8ab8afb13ac602257e5ea9bbcfa | e743d2ac5954686fb787247602366c653cc079e2 | /Object2d.cpp | 203f2f692aa663b24ada1a851483e0d55e71f555 | [] | no_license | inirion/Systemy-Multimedialne---Projekt-sem-VI | 661c3a52114fd20829ac0bbddb12dc15fad09fdb | 1ac9179d63e4fce384474f7a299ff912bfb7b47b | refs/heads/master | 2020-12-02T19:27:19.410605 | 2017-07-05T17:04:34 | 2017-07-05T17:04:34 | 96,341,368 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 866 | cpp | /*
* Object2d.cpp
*
* Created on: 17.03.2017
* Author: jakub
*/
#include "Object2d.hpp"
Object2d::Object2d(sf::Vector2f p, sf::Vector2f s):
position(p),
size(s),
angle(0.f)
{
}
sf::Vector2f Object2d::getPosition() const {
return position;
}
void Object2d::setPosition(sf::Vector2f position) {
this->position = position;
}
sf::Vector2f Object2d::getSize() const {
return size;
}
void Object2d::setSize(sf::Vector2f size) {
this->size = size;
}
sf::Vector2f Object2d::getSizeReal() const {
return size;
}
float Object2d::getAngle() const {
return angle;
}
void Object2d::setAngle(float angle) {
if(angle > 360.f)
throw std::logic_error("Object2d::setAngle angle > 360.f");
else if(angle < 0.f)
throw std::logic_error("Object2d::setAngle angle < 0.f");
this->angle = angle;
}
float toRad(float deg) {
return deg * 0.017453293;
}
| [
"grzegorz.r.kokoszka@gmail.com"
] | grzegorz.r.kokoszka@gmail.com |
d9ed8129ebf068dd27f03fac2f9c613e26fb0091 | ca59d18e503ef22fbc920c6de48ffc8eac5a1443 | /samples/python/uff_custom_plugin/plugin/customClipPlugin.h | 24cfc6df048dd5d07942485d577894c49ed1a748 | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0",
"BSD-3-Clause",
"ISC",
"BSD-2-Clause",
"MIT"
] | permissive | boh-inspur/TensorRT | 9fc0ae0ad4e31da040d10728b63d9dc284852b67 | e4d2f7f4406f1c8f4632cc67de33728cef90ca29 | refs/heads/master | 2023-04-13T21:24:13.912673 | 2021-04-23T09:55:18 | 2021-04-23T09:55:18 | 265,431,588 | 0 | 0 | Apache-2.0 | 2021-04-23T09:55:19 | 2020-05-20T02:49:58 | null | UTF-8 | C++ | false | false | 3,419 | h | /*
* Copyright (c) 2021, NVIDIA 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.
*/
#ifndef CUSTOM_CLIP_PLUGIN_H
#define CUSTOM_CLIP_PLUGIN_H
#include "NvInferPlugin.h"
#include <string>
#include <vector>
using namespace nvinfer1;
// One of the preferred ways of making TensorRT to be able to see
// our custom layer requires extending IPluginV2 and IPluginCreator classes.
// For requirements for overriden functions, check TensorRT API docs.
class ClipPlugin : public IPluginV2
{
public:
ClipPlugin(const std::string name, float clipMin, float clipMax);
ClipPlugin(const std::string name, const void* data, size_t length);
// It doesn't make sense to make ClipPlugin without arguments, so we delete default constructor.
ClipPlugin() = delete;
int getNbOutputs() const noexcept override;
Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) noexcept override;
int initialize() noexcept override;
void terminate() noexcept override;
size_t getWorkspaceSize(int) const noexcept override
{
return 0;
};
int enqueue(int batchSize, const void* const* inputs, void** outputs, void* workspace,
cudaStream_t stream) noexcept override;
size_t getSerializationSize() const noexcept override;
void serialize(void* buffer) const noexcept override;
void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, DataType type,
PluginFormat format, int maxBatchSize) noexcept override;
bool supportsFormat(DataType type, PluginFormat format) const noexcept override;
const char* getPluginType() const noexcept override;
const char* getPluginVersion() const noexcept override;
void destroy() noexcept override;
nvinfer1::IPluginV2* clone() const noexcept override;
void setPluginNamespace(const char* pluginNamespace) noexcept override;
const char* getPluginNamespace() const noexcept override;
private:
const std::string mLayerName;
float mClipMin, mClipMax;
size_t mInputVolume;
std::string mNamespace;
};
class ClipPluginCreator : public IPluginCreator
{
public:
ClipPluginCreator();
const char* getPluginName() const noexcept override;
const char* getPluginVersion() const noexcept override;
const PluginFieldCollection* getFieldNames() noexcept override;
IPluginV2* createPlugin(const char* name, const PluginFieldCollection* fc) noexcept override;
IPluginV2* deserializePlugin(const char* name, const void* serialData, size_t serialLength) noexcept override;
void setPluginNamespace(const char* pluginNamespace) noexcept override;
const char* getPluginNamespace() const noexcept override;
private:
static PluginFieldCollection mFC;
static std::vector<PluginField> mPluginAttributes;
std::string mNamespace;
};
#endif
| [
"rajeevsrao@users.noreply.github.com"
] | rajeevsrao@users.noreply.github.com |
7ef8b77ffb6c38b0362c71a8f0f70a5bff55005c | b33a9177edaaf6bf185ef20bf87d36eada719d4f | /qtbase/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h | 48c808a26148c0262445a90dc9a2de22122940a9 | [
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-commercial-license",
"LGPL-2.0-or-later",
"LGPL-2.1-only",
"GFDL-1.3-only",
"LicenseRef-scancode-qt-commercial-1.1",
"LGPL-3.0-only",
"LicenseRef-scancode-qt-company-exception-lgpl-2.1",
... | permissive | wgnet/wds_qt | ab8c093b8c6eead9adf4057d843e00f04915d987 | 8db722fd367d2d0744decf99ac7bafaba8b8a3d3 | refs/heads/master | 2021-04-02T11:07:10.181067 | 2020-06-02T10:29:03 | 2020-06-02T10:34:19 | 248,267,925 | 1 | 0 | Apache-2.0 | 2020-04-30T12:16:53 | 2020-03-18T15:20:38 | null | UTF-8 | C++ | false | false | 2,880 | h | //
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// SwapChain11.h: Defines a back-end specific class for the D3D11 swap chain.
#ifndef LIBANGLE_RENDERER_D3D_D3D11_SWAPCHAIN11_H_
#define LIBANGLE_RENDERER_D3D_D3D11_SWAPCHAIN11_H_
#include "common/angleutils.h"
#include "libANGLE/renderer/d3d/SwapChainD3D.h"
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
namespace rx
{
class Renderer11;
class SwapChain11 : public SwapChainD3D
{
public:
SwapChain11(Renderer11 *renderer, NativeWindow nativeWindow, HANDLE shareHandle,
GLenum backBufferFormat, GLenum depthBufferFormat);
virtual ~SwapChain11();
EGLint resize(EGLint backbufferWidth, EGLint backbufferHeight);
virtual EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval);
virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
virtual void recreate();
RenderTargetD3D *getColorRenderTarget() override { return &mColorRenderTarget; }
RenderTargetD3D *getDepthStencilRenderTarget() override { return &mDepthStencilRenderTarget; }
virtual ID3D11Texture2D *getOffscreenTexture();
virtual ID3D11RenderTargetView *getRenderTarget();
virtual ID3D11ShaderResourceView *getRenderTargetShaderResource();
virtual ID3D11Texture2D *getDepthStencilTexture();
virtual ID3D11DepthStencilView *getDepthStencil();
virtual ID3D11ShaderResourceView *getDepthStencilShaderResource();
EGLint getWidth() const { return mWidth; }
EGLint getHeight() const { return mHeight; }
virtual void *getDevice();
static SwapChain11 *makeSwapChain11(SwapChainD3D *swapChain);
private:
void release();
void initPassThroughResources();
void releaseOffscreenTexture();
EGLint resetOffscreenTexture(int backbufferWidth, int backbufferHeight);
Renderer11 *mRenderer;
EGLint mHeight;
EGLint mWidth;
bool mAppCreatedShareHandle;
unsigned int mSwapInterval;
bool mPassThroughResourcesInit;
DXGISwapChain *mSwapChain;
ID3D11Texture2D *mBackBufferTexture;
ID3D11RenderTargetView *mBackBufferRTView;
ID3D11Texture2D *mOffscreenTexture;
ID3D11RenderTargetView *mOffscreenRTView;
ID3D11ShaderResourceView *mOffscreenSRView;
ID3D11Texture2D *mDepthStencilTexture;
ID3D11DepthStencilView *mDepthStencilDSView;
ID3D11ShaderResourceView *mDepthStencilSRView;
ID3D11Buffer *mQuadVB;
ID3D11SamplerState *mPassThroughSampler;
ID3D11InputLayout *mPassThroughIL;
ID3D11VertexShader *mPassThroughVS;
ID3D11PixelShader *mPassThroughPS;
SurfaceRenderTarget11 mColorRenderTarget;
SurfaceRenderTarget11 mDepthStencilRenderTarget;
};
}
#endif // LIBANGLE_RENDERER_D3D_D3D11_SWAPCHAIN11_H_
| [
"p_pavlov@wargaming.net"
] | p_pavlov@wargaming.net |
c3aa086edf98a6dbcf02d6deb3089a0ec3e65394 | 21205efc28da02bd7755250e0c47f636f89756f3 | /runtime/src/main/cpp/MemorySharedRefs.cpp | fab850cf73aa23db15422b9c728a3a8bd88e9d7c | [
"Apache-2.0"
] | permissive | koush/kotlin-native | 9d3686642b265c946c0d26cb1865e97dc2192795 | 6a2812a2d514cecf6d98abc7ae01c6e1e8e2927a | refs/heads/master | 2023-08-17T12:53:50.966819 | 2019-10-18T15:54:52 | 2019-10-18T15:54:52 | 216,081,668 | 1 | 1 | Apache-2.0 | 2019-10-18T18:08:44 | 2019-10-18T18:08:43 | null | UTF-8 | C++ | false | false | 3,610 | cpp | /*
* Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
* that can be found in the LICENSE file.
*/
#include "Exceptions.h"
#include "MemoryPrivate.hpp"
#include "MemorySharedRefs.hpp"
#include "Runtime.h"
void KRefSharedHolder::initLocal(ObjHeader* obj) {
RuntimeAssert(obj != nullptr, "must not be null");
context_ = InitLocalForeignRef(obj);
obj_ = obj;
}
void KRefSharedHolder::init(ObjHeader* obj) {
RuntimeAssert(obj != nullptr, "must not be null");
context_ = InitForeignRef(obj);
obj_ = obj;
}
ObjHeader* KRefSharedHolder::ref() const {
ensureRefAccessible();
return obj_;
}
static inline void ensureForeignRefAccessible(ObjHeader* object, ForeignRefContext context) {
if (!Kotlin_hasRuntime()) {
// So the object is either unowned or shared.
// In the former case initialized runtime is required to throw the exception below,
// in the latter case -- to provide proper execution context for caller.
Kotlin_initRuntimeIfNeeded();
}
if (!IsForeignRefAccessible(object, context)) {
// TODO: add some info about the context.
// Note: retrieving 'type_info()' is supposed to be correct even for unowned object.
ThrowIllegalObjectSharingException(object->type_info(), object);
}
}
void KRefSharedHolder::dispose() const {
if (obj_ == nullptr) {
// To handle the case when it is not initialized. See [KotlinMutableSet/Dictionary dealloc].
return;
}
DeinitForeignRef(obj_, context_);
}
void KRefSharedHolder::ensureRefAccessible() const {
ensureForeignRefAccessible(obj_, context_);
}
void BackRefFromAssociatedObject::initAndAddRef(ObjHeader* obj) {
RuntimeAssert(obj != nullptr, "must not be null");
obj_ = obj;
// Generally a specialized addRef below:
context_ = InitForeignRef(obj);
refCount = 1;
}
void BackRefFromAssociatedObject::addRef() {
if (atomicAdd(&refCount, 1) == 1) {
// There are no references to the associated object itself, so Kotlin object is being passed from Kotlin,
// and it is owned therefore.
ensureRefAccessible(); // TODO: consider removing explicit verification.
// Foreign reference has already been deinitialized (see [releaseRef]).
// Create a new one:
context_ = InitForeignRef(obj_);
}
}
bool BackRefFromAssociatedObject::tryAddRef() {
// Suboptimal but simple:
ObjHeader* obj = this->ref();
if (!TryAddHeapRef(obj)) return false;
this->addRef();
ReleaseHeapRef(obj); // Balance TryAddHeapRef.
// TODO: consider optimizing for non-shared objects.
return true;
}
void BackRefFromAssociatedObject::releaseRef() {
ForeignRefContext context = context_;
if (atomicAdd(&refCount, -1) == 0) {
// Note: by this moment "subsequent" addRef may have already happened and patched context_.
// So use the value loaded before refCount update:
DeinitForeignRef(obj_, context);
// From this moment [context] is generally a dangling pointer.
// This is handled in [IsForeignRefAccessible] and [addRef].
}
}
void BackRefFromAssociatedObject::ensureRefAccessible() const {
ensureForeignRefAccessible(obj_, context_);
}
extern "C" {
RUNTIME_NOTHROW void KRefSharedHolder_initLocal(KRefSharedHolder* holder, ObjHeader* obj) {
holder->initLocal(obj);
}
RUNTIME_NOTHROW void KRefSharedHolder_init(KRefSharedHolder* holder, ObjHeader* obj) {
holder->init(obj);
}
RUNTIME_NOTHROW void KRefSharedHolder_dispose(const KRefSharedHolder* holder) {
holder->dispose();
}
ObjHeader* KRefSharedHolder_ref(const KRefSharedHolder* holder) {
return holder->ref();
}
} // extern "C" | [
"Svyatoslav.Scherbina@jetbrains.com"
] | Svyatoslav.Scherbina@jetbrains.com |
fd015caf5a1c4ccd5d76a0b2db3e29566056dc4e | eb2b04a0eb683ef576b4e26c4cd5d01ca74e0d12 | /project/video/video/mainwindow.h | 714905093738cfdebb41b2e0fb88f634663480fa | [] | no_license | snail5201/Qt_example | 6ba3d181c7015ed1955c445ec41000bf697012b1 | 9cf123148c28cdeb6a9ea20b61149e90b141d162 | refs/heads/master | 2020-08-04T09:06:48.316615 | 2019-10-01T12:01:08 | 2019-10-01T12:01:08 | 212,083,990 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,000 | h | ๏ปฟ#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include<QMediaPlayer>
#include"qmyvideowidget.h"
#include<QDir>
#include<QFileDialog>
#include<QVideoWidget>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
private:
QMediaPlayer *player; //่ง้ขๆญๆพๅจ
QString durationTime;
QString positionTime;
public:
explicit MainWindow(QWidget *parent = nullptr);
~MainWindow();
private slots:
//่ชๅฎไนๆงฝๅฝๆฐ
void onStateChanged(QMediaPlayer::State state);
void onDurationChange(qint64 duration);
void onPositionChanged(qint64 position);
void on_file_pushButton_clicked();
void on_play_pushButton_clicked();
void on_pause_pushButton_clicked();
void on_stop_pushButton_clicked();
void on_horizontalSlider_valueChanged(int value);
void on_time_slider_valueChanged(int value);
void on_pushButton_5_clicked();
private:
Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H
| [
"1051994633@qq.com"
] | 1051994633@qq.com |
9a00c977c1b1b4feb4a140fb99898c20762f4b4e | 46f53e9a564192eed2f40dc927af6448f8608d13 | /components/gcm_driver/gcm_driver_android.h | 41c47b5f6999fe9d613668685ba9b8f7439a4a76 | [
"BSD-3-Clause"
] | permissive | sgraham/nope | deb2d106a090d71ae882ac1e32e7c371f42eaca9 | f974e0c234388a330aab71a3e5bbf33c4dcfc33c | refs/heads/master | 2022-12-21T01:44:15.776329 | 2015-03-23T17:25:47 | 2015-03-23T17:25:47 | 32,344,868 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 3,369 | h | // Copyright 2014 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.
#ifndef COMPONENTS_GCM_DRIVER_GCM_DRIVER_ANDROID_H
#define COMPONENTS_GCM_DRIVER_GCM_DRIVER_ANDROID_H
#include <jni.h>
#include "base/android/scoped_java_ref.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "components/gcm_driver/gcm_driver.h"
namespace gcm {
// GCMDriver implementation for Android, using Android GCM APIs.
class GCMDriverAndroid : public GCMDriver {
public:
GCMDriverAndroid();
~GCMDriverAndroid() override;
// Methods called from Java via JNI:
void OnRegisterFinished(JNIEnv* env,
jobject obj,
jstring app_id,
jstring registration_id,
jboolean success);
void OnUnregisterFinished(JNIEnv* env,
jobject obj,
jstring app_id,
jboolean success);
void OnMessageReceived(JNIEnv* env,
jobject obj,
jstring app_id,
jstring sender_id,
jstring collapse_key,
jobjectArray data_keys_and_values);
void OnMessagesDeleted(JNIEnv* env,
jobject obj,
jstring app_id);
// Register JNI methods.
static bool RegisterBindings(JNIEnv* env);
// GCMDriver implementation:
void OnSignedIn() override;
void OnSignedOut() override;
void Enable() override;
void AddConnectionObserver(GCMConnectionObserver* observer) override;
void RemoveConnectionObserver(GCMConnectionObserver* observer) override;
void Disable() override;
GCMClient* GetGCMClientForTesting() const override;
bool IsStarted() const override;
bool IsConnected() const override;
void GetGCMStatistics(const GetGCMStatisticsCallback& callback,
bool clear_logs) override;
void SetGCMRecording(const GetGCMStatisticsCallback& callback,
bool recording) override;
void SetAccountTokens(
const std::vector<GCMClient::AccountTokenInfo>& account_tokens) override;
void UpdateAccountMapping(const AccountMapping& account_mapping) override;
void RemoveAccountMapping(const std::string& account_id) override;
base::Time GetLastTokenFetchTime() override;
void SetLastTokenFetchTime(const base::Time& time) override;
void WakeFromSuspendForHeartbeat(bool wake) override;
protected:
// GCMDriver implementation:
GCMClient::Result EnsureStarted(GCMClient::StartMode start_mode) override;
void RegisterImpl(const std::string& app_id,
const std::vector<std::string>& sender_ids) override;
void UnregisterImpl(const std::string& app_id) override;
void UnregisterWithSenderIdImpl(const std::string& app_id,
const std::string& sender_id) override;
void SendImpl(const std::string& app_id,
const std::string& receiver_id,
const GCMClient::OutgoingMessage& message) override;
private:
base::android::ScopedJavaGlobalRef<jobject> java_ref_;
DISALLOW_COPY_AND_ASSIGN(GCMDriverAndroid);
};
} // namespace gcm
#endif // COMPONENTS_GCM_DRIVER_GCM_DRIVER_ANDROID_H
| [
"scottmg@chromium.org"
] | scottmg@chromium.org |
3e84489f252fc33f9d719f1cdbc6b2f8d824d62c | df8d9368c2912d4f90b0670484d76bd8544021c4 | /FaceAntiSpoofingX/seeta/CommonStruct.h | b1bffb793561e5fc1b203b13c9636d01acfe7201 | [] | no_license | wzjsword/FaceAntiSpoofingX6 | db5bcadea005c7f270912a2827ddda2bdf81e880 | f64b6c2faad79314a659e1e9d066b84938768d35 | refs/heads/master | 2022-12-08T19:39:26.198522 | 2020-08-26T08:30:45 | 2020-08-26T08:30:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,083 | h | #pragma once
#include "seeta/Common/Struct.h"
#include "DataHelper.h"
#include <sstream>
namespace seeta
{
class Meanshape
{
public:
std::vector<PointF> points;
Size size;
};
class Landmarks
{
public:
Landmarks() {};
std::vector<PointF> points;
};
class Image : public Blob<uint8_t>
{
public:
using self = Image;
using supper = Blob<uint8_t>;
using Datum = uint8_t;
Image(const SeetaImageData &vimg) : Image(vimg.data, vimg.width, vimg.height, vimg.channels) {}
operator SeetaImageData() const { SeetaImageData vimg = { width(), height(), channels(), const_cast<Datum *>(data()) }; return vimg; }
Image(const ImageData &vimg) : Image(vimg.data, vimg.width, vimg.height, vimg.channels) {}
operator ImageData() const { ImageData vimg(const_cast<Datum *>(data()), width(), height(), channels()); return std::move(vimg); }
Image(int width, int height, int channels)
: supper(height, width, channels)
{
}
Image(const uint8_t *data, int width, int height, int channels)
: supper(data, height, width, channels)
{
}
Image()
: Image(0, 0, 0)
{
}
int height() const
{
return supper::shape(1);
}
int width() const
{
return supper::shape(2);
}
int channels() const
{
return supper::shape(3);
}
template <typename U>
static Image FromBlob(const Blob<U> &blob)
{
if (blob.shape(0) != 1) throw std::logic_error("Can not convert multi images.");
Image image(blob.shape(2), blob.shape(1), blob.shape(3));
for (int i = 0; i < blob.count(); ++i)
{
image[i] = static_cast<uint8_t>(std::max<U>(0, std::min<U>(255, blob[i])));
}
return std::move(image);
}
};
inline void _out_str(std::ostream &out) { }
// there is no error anyway, this is a new feature about C++11
template<typename T, typename... Args>
inline void _out_str(std::ostream &out, const T &t, Args... args) { _out_str(out << t, args...); }
template<typename... Args>
inline const std::string str(Args... args) {
std::ostringstream oss;
_out_str(oss, args...);
return std::move(oss.str());
}
}
| [
"bo.zhang@seetatech.com"
] | bo.zhang@seetatech.com |
0a0635f3b92d701cbd05381ccd884019e9562c3a | c8a9d437f45fcba5dbb50c3bd6fa966927c77bb9 | /WS6/Basket.cpp | ccc39d515e53d48809713af90e976b01bee7d72d | [] | no_license | hthnguyen/hthnguyen_ws | 1599d971edead2b12745aa13b8b0511c30511ddb | b90cc913c561a99db1ee7a38fae765e5ce3d24e2 | refs/heads/master | 2023-03-27T17:01:48.479929 | 2021-03-28T05:49:07 | 2021-03-28T05:49:07 | 278,155,862 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,718 | cpp | // Student name: Nguyen Hoang Trung Hieu
// Student ID: 142914191
#define _CRT_SECURE_NO_WARNINGS
#include"Basket.h"
#include<cstring>
#include <iomanip>
#include<iostream>
#include<fstream>
using namespace std;
namespace sdds {
Basket::Basket()
{
emptyBasket();
}
Basket::operator bool() const
{
return (this->m_cnt > 0);
}
Basket::Basket(Fruit* fruits, int cnt, double price)
{
this->m_fruits = nullptr;
set(fruits, cnt, price);
}
void Basket::emptyBasket()
{
this->m_fruits = nullptr;
this->m_price = 0.0;
this->m_cnt = 0;
}
void Basket::set(Fruit* fruit, int cnt, double price)
{
if (this->m_fruits != nullptr)
{
delete[] this->m_fruits;
this->m_fruits = nullptr;
}
this->m_cnt = cnt;
this->m_fruits = new Fruit[this->m_cnt];
for (int i = 0; i < this->m_cnt; i++) {
this->m_fruits[i] = fruit[i];
}
setPrice(price);
}
void Basket::setPrice(double price)
{
if (price > 0.00)
this->m_price = price;
}
bool Basket::check() const
{
return (this->m_fruits && this->m_cnt > 0);
}
Basket::Basket(const Basket& fruit) {
this->m_cnt = fruit.m_cnt;
this->m_price = fruit.m_price;
if (fruit.m_fruits != nullptr) {
this->m_fruits = new Fruit[this->m_cnt];
for (int i = 0; i < this->m_cnt; i++)
{
this->m_fruits[i] = fruit.m_fruits[i];
}
}
else this->m_fruits = nullptr;
}
Basket& Basket::operator +=(Fruit fruit) {
Fruit* tmp = new Fruit[this->m_cnt];
for (int i = 0; i < this->m_cnt; i++)
{
tmp[i] = this->m_fruits[i];
}
delete[] this->m_fruits;
this->m_fruits = nullptr;
this->m_cnt += 1;
this->m_fruits = new Fruit[this->m_cnt];
for (int i = 0; i < this->m_cnt - 1; i++)
{
this->m_fruits[i] = tmp[i];
}
this->m_fruits[this->m_cnt - 1] = fruit;
delete[] tmp;
tmp = nullptr;
return *this;
}
Basket& Basket::operator=(const Basket& b)
{
if (this != &b) {
this->m_cnt = b.m_cnt;
this->m_price = b.m_price;
delete[] this->m_fruits;
if (b.m_fruits != nullptr) {
this->m_fruits = new Fruit[this->m_cnt];
for (int i = 0; i < this->m_cnt; i++) {
this->m_fruits[i] = b.m_fruits[i];
}
}
else this->m_fruits = nullptr;
}
return *this;
}
ostream& operator<<(ostream& cout, Basket& basket)
{
if (!basket) {
cout << "The basket is empty!" << endl;
}
else {
cout << "Basket Content:" << endl;
for (int i = 0; i < basket.m_cnt; i++) {
cout << fixed << setprecision(2) << setw(10) << right << basket.m_fruits[i].m_name << ": " << basket.m_fruits[i].m_qty << "kg" << endl;
}
cout << "Price: " << basket.m_price << endl;
}
return cout;
}
Basket::~Basket()
{
delete[] this->m_fruits;
this->m_fruits = nullptr;
}
} | [
"hthnguyen@myseneca.ca"
] | hthnguyen@myseneca.ca |
94e9a42e321105d499be7569d59c185f666a5194 | da05e666313b1a5a352d587289f7392b7ad90fa1 | /DR51/src/pacman/Bham/Control/Control.cpp | 45450629ef742ba71d70e96f6c94a46886c25d15 | [] | no_license | pacman-project/pacman-demo | 0f1312311b295f6ae054dace41d35e268ff74bb4 | df84d036aa04640dce6da5980afd2e8418d29bef | refs/heads/master | 2021-03-24T12:01:30.638153 | 2017-12-07T17:03:05 | 2017-12-07T17:03:05 | 12,973,255 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 10,979 | cpp | #include <pacman/Bham/Control/ControlImpl.h>
#include <Golem/Tools/Data.h>
#include <Golem/Tools/XMLData.h>
using namespace pacman;
using namespace golem;
//-----------------------------------------------------------------------------
BhamControlImpl::BhamControlImpl(golem::Controller& controller) : controller(controller), context(controller.getContext()), info(controller.getStateInfo()) {}
pacman::float_t BhamControlImpl::time() const {
return context.getTimer().elapsed();
}
pacman::float_t BhamControlImpl::cycleDuration() const {
return controller.getCycleDuration();
}
void BhamControlImpl::lookupState(pacman::float_t t, Robot::State& state) const {
Controller::State inp = controller.createState();
controller.lookupState((SecTmReal)t, inp);
convert(inp, state);
}
void BhamControlImpl::lookupCommand(pacman::float_t t, Robot::Command& command) const {
Controller::State inp = controller.createState();
controller.lookupCommand((SecTmReal)t, inp);
convert(inp, command);
}
void BhamControlImpl::send(const Robot::Command* command, std::uintptr_t size) {
if (size <= 0)
throw Message(Message::LEVEL_ERROR, "BhamControlImpl::send(): invalid number of commands %u", size);
Controller::State::Seq seq(size, controller.createState());
for (Controller::State::Seq::iterator i = seq.begin(); i != seq.end(); ++i) {
controller.setToDefault(*i);
convert((const Robot::Command&)(*command)(i - seq.begin()), *i);
}
controller.send(seq.data(), seq.data() + size);
}
bool BhamControlImpl::waitForCycleBegin(double timewait) {
return controller.waitForBegin(golem::SecToMSec(timewait));
}
bool BhamControlImpl::waitForTrajectoryEnd(double timewait) {
return controller.waitForEnd(golem::SecToMSec(timewait));
}
//-----------------------------------------------------------------------------
void BhamControlImpl::assertRobotUIBK() const {
assertConfig<RobotUIBK::Config::CHAINS, 7 + 3 + 3 + 2>(controller.getStateInfo());
}
void BhamControlImpl::assertRobotEddie() const {
assertConfig<RobotEddie::Config::CHAINS, 2*(7 + 3 + 3 + 2) + 7>(controller.getStateInfo());
}
//-----------------------------------------------------------------------------
void BhamControlImpl::convert(const ::golem::Controller::State& src, Robot::State& dst) const {
switch (dst.getType()) {
case Robot::Type::ROBOT_UIBK:
BhamControlImpl::assertRobotUIBK(); // throws
convert(src, (RobotUIBK::State&)dst);
break;
case Robot::Type::ROBOT_EDDIE:
BhamControlImpl::assertRobotEddie(); // throws
convert(src, (RobotEddie::State&)dst);
break;
default:
throw Message(Message::LEVEL_ERROR, "BhamControlImpl::convertState(): unknown robot type %u", dst.getType());
}
}
void BhamControlImpl::convert(const ::golem::Controller::State& src, Robot::Command& dst) const {
switch (dst.getType()) {
case Robot::Type::ROBOT_UIBK:
BhamControlImpl::assertRobotUIBK(); // throws
convert(src, (RobotUIBK::Command&)dst);
break;
case Robot::Type::ROBOT_EDDIE:
BhamControlImpl::assertRobotEddie(); // throws
convert(src, (RobotEddie::Command&)dst);
break;
default:
throw Message(Message::LEVEL_ERROR, "BhamControlImpl::convertCommand(): unknown robot type %u", dst.getType());
}
}
void BhamControlImpl::convert(const Robot::Command& src, ::golem::Controller::State& dst) const {
switch (src.getType()) {
case Robot::Type::ROBOT_UIBK:
BhamControlImpl::assertRobotUIBK(); // throws
convert((const RobotUIBK::Command&)src, dst);
break;
case Robot::Type::ROBOT_EDDIE:
BhamControlImpl::assertRobotEddie(); // throws
convert((const RobotEddie::Command&)src, dst);
break;
default:
throw Message(Message::LEVEL_ERROR, "BhamControlImpl::convertCommand(): unknown robot type %u", src.getType());
}
}
//-----------------------------------------------------------------------------
void BhamControlImpl::convert(const ::golem::Controller::State& src, RobotUIBK::State& dst) const {
// time
dst.t = (pacman::float_t)src.t;
// arm
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 0).begin()], dst.arm.pos);
// hand
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 1).begin()], dst.hand.pos);
}
void BhamControlImpl::convert(const ::golem::Controller::State& src, RobotUIBK::Command& dst) const {
// time
dst.t = (pacman::float_t)src.t;
// arm
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 0).begin()], dst.arm.pos);
configToPacman(&src.cvel[info.getJoints(info.getChains().begin() + 0).begin()], dst.arm.vel);
configToPacman(&src.cacc[info.getJoints(info.getChains().begin() + 0).begin()], dst.arm.acc);
// hand
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 1).begin()], dst.hand.pos);
configToPacman(&src.cvel[info.getJoints(info.getChains().begin() + 1).begin()], dst.hand.vel);
configToPacman(&src.cacc[info.getJoints(info.getChains().begin() + 1).begin()], dst.hand.acc);
}
void BhamControlImpl::convert(const RobotUIBK::Command& src, ::golem::Controller::State& dst) const {
// time
dst.t = (SecTmReal)src.t;
// arm
configToGolem(src.arm.pos, &dst.cpos[info.getJoints(info.getChains().begin() + 0).begin()]);
configToGolem(src.arm.vel, &dst.cvel[info.getJoints(info.getChains().begin() + 0).begin()]);
configToGolem(src.arm.acc, &dst.cacc[info.getJoints(info.getChains().begin() + 0).begin()]);
// hand
configToGolem(src.hand.pos, &dst.cpos[info.getJoints(info.getChains().begin() + 1).begin()]);
configToGolem(src.hand.vel, &dst.cvel[info.getJoints(info.getChains().begin() + 1).begin()]);
configToGolem(src.hand.acc, &dst.cacc[info.getJoints(info.getChains().begin() + 1).begin()]);
}
//-----------------------------------------------------------------------------
void BhamControlImpl::convert(const ::golem::Controller::State& src, RobotEddie::State& dst) const {
// time
dst.t = (pacman::float_t)src.t;
// arm
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 0).begin()], dst.armLeft.pos);
// hand
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 1).begin()], dst.handLeft.pos);
// arm
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 4).begin()], dst.armRight.pos);
// hand
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 5).begin()], dst.handRight.pos);
// head
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 8).begin()], dst.head.pos);
}
void BhamControlImpl::convert(const ::golem::Controller::State& src, RobotEddie::Command& dst) const {
// time
dst.t = (pacman::float_t)src.t;
// arm
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 0).begin()], dst.armLeft.pos);
configToPacman(&src.cvel[info.getJoints(info.getChains().begin() + 0).begin()], dst.armLeft.vel);
configToPacman(&src.cacc[info.getJoints(info.getChains().begin() + 0).begin()], dst.armLeft.acc);
// hand
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 1).begin()], dst.handLeft.pos);
configToPacman(&src.cvel[info.getJoints(info.getChains().begin() + 1).begin()], dst.handLeft.vel);
configToPacman(&src.cacc[info.getJoints(info.getChains().begin() + 1).begin()], dst.handLeft.acc);
// arm
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 4).begin()], dst.armRight.pos);
configToPacman(&src.cvel[info.getJoints(info.getChains().begin() + 4).begin()], dst.armRight.vel);
configToPacman(&src.cacc[info.getJoints(info.getChains().begin() + 4).begin()], dst.armRight.acc);
// hand
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 5).begin()], dst.handRight.pos);
configToPacman(&src.cvel[info.getJoints(info.getChains().begin() + 5).begin()], dst.handRight.vel);
configToPacman(&src.cacc[info.getJoints(info.getChains().begin() + 5).begin()], dst.handRight.acc);
// head
configToPacman(&src.cpos[info.getJoints(info.getChains().begin() + 8).begin()], dst.head.pos);
configToPacman(&src.cvel[info.getJoints(info.getChains().begin() + 8).begin()], dst.head.vel);
configToPacman(&src.cacc[info.getJoints(info.getChains().begin() + 8).begin()], dst.head.acc);
}
void BhamControlImpl::convert(const RobotEddie::Command& src, ::golem::Controller::State& dst) const {
// time
dst.t = (SecTmReal)src.t;
// arm
configToGolem(src.armLeft.pos, &dst.cpos[info.getJoints(info.getChains().begin() + 0).begin()]);
configToGolem(src.armLeft.vel, &dst.cvel[info.getJoints(info.getChains().begin() + 0).begin()]);
configToGolem(src.armLeft.acc, &dst.cacc[info.getJoints(info.getChains().begin() + 0).begin()]);
// hand
configToGolem(src.handLeft.pos, &dst.cpos[info.getJoints(info.getChains().begin() + 1).begin()]);
configToGolem(src.handLeft.vel, &dst.cvel[info.getJoints(info.getChains().begin() + 1).begin()]);
configToGolem(src.handLeft.acc, &dst.cacc[info.getJoints(info.getChains().begin() + 1).begin()]);
// arm
configToGolem(src.armRight.pos, &dst.cpos[info.getJoints(info.getChains().begin() + 4).begin()]);
configToGolem(src.armRight.vel, &dst.cvel[info.getJoints(info.getChains().begin() + 4).begin()]);
configToGolem(src.armRight.acc, &dst.cacc[info.getJoints(info.getChains().begin() + 4).begin()]);
// hand
configToGolem(src.handRight.pos, &dst.cpos[info.getJoints(info.getChains().begin() + 5).begin()]);
configToGolem(src.handRight.vel, &dst.cvel[info.getJoints(info.getChains().begin() + 5).begin()]);
configToGolem(src.handRight.acc, &dst.cacc[info.getJoints(info.getChains().begin() + 5).begin()]);
// head
configToGolem(src.head.pos, &dst.cpos[info.getJoints(info.getChains().begin() + 8).begin()]);
configToGolem(src.head.vel, &dst.cvel[info.getJoints(info.getChains().begin() + 8).begin()]);
configToGolem(src.head.acc, &dst.cacc[info.getJoints(info.getChains().begin() + 8).begin()]);
}
//-----------------------------------------------------------------------------
Context::Ptr context;
Controller::Desc::Ptr controllerDesc;
Controller::Ptr controller;
BhamControlImpl* pBhamControl = nullptr;
BhamControl::Ptr BhamControl::create(const std::string& path) {
// Create XML parser and load configuration file
XMLParser::Desc parserDesc;
XMLParser::Ptr pParser = parserDesc.create();
FileReadStream fs(path.c_str());
pParser->load(fs);
// Find program XML root context
XMLContext* pXMLContext = pParser->getContextRoot()->getContextFirst("golem");
// Create program context
golem::Context::Desc contextDesc;
XMLData(contextDesc, pXMLContext);
context = contextDesc.create(); // throws
// Load driver
controllerDesc = Controller::Desc::load(context.get(), pXMLContext->getContextFirst("controller"));
// Create controller
context->info("Initialising controller...\n");
controller = controllerDesc->create(*context);
pBhamControl = new BhamControlImpl(*controller); //do not throw!
return BhamControl::Ptr(pBhamControl, [&] (BhamControl*) {
delete pBhamControl;
controller.release();
controllerDesc.release();
});
}
//-----------------------------------------------------------------------------
| [
"marek.kopicki@gmail.com"
] | marek.kopicki@gmail.com |
a17814021a60619f30521d6c3b3bbff4d0ed6f73 | 28a1ef8dda14c331ad3c7c298c28d2c2f28a6fcb | /Export/mac64/cpp/obj/src/com/danielfreeman/madcomponents/UILabelX.cpp | d13c8af16f828d4103d5da5c58230b1bd07da53a | [] | no_license | danfreeman/MadComponentsOpenFL | 3456fa779eeca64f6c902c70c31a5ea6b162f4b7 | 4fece9ec4f60a999949a6eb1cf77278a3b9cab65 | refs/heads/master | 2021-01-19T05:53:47.393376 | 2015-05-05T16:02:26 | 2015-05-05T16:02:26 | 33,678,887 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 16,483 | cpp | #include <hxcpp.h>
#ifndef INCLUDED_Std
#include <Std.h>
#endif
#ifndef INCLUDED_com_danielfreeman_MadXML
#include <com/danielfreeman/MadXML.h>
#endif
#ifndef INCLUDED_com_danielfreeman__MadXML_AttribAccess
#include <com/danielfreeman/_MadXML/AttribAccess.h>
#endif
#ifndef INCLUDED_com_danielfreeman__MadXML_HasAttribAccess
#include <com/danielfreeman/_MadXML/HasAttribAccess.h>
#endif
#ifndef INCLUDED_com_danielfreeman_madcomponents_Attributes
#include <com/danielfreeman/madcomponents/Attributes.h>
#endif
#ifndef INCLUDED_com_danielfreeman_madcomponents_IComponentUI
#include <com/danielfreeman/madcomponents/IComponentUI.h>
#endif
#ifndef INCLUDED_com_danielfreeman_madcomponents_UILabel
#include <com/danielfreeman/madcomponents/UILabel.h>
#endif
#ifndef INCLUDED_com_danielfreeman_madcomponents_UILabelX
#include <com/danielfreeman/madcomponents/UILabelX.h>
#endif
#ifndef INCLUDED_openfl_display_DisplayObject
#include <openfl/display/DisplayObject.h>
#endif
#ifndef INCLUDED_openfl_display_DisplayObjectContainer
#include <openfl/display/DisplayObjectContainer.h>
#endif
#ifndef INCLUDED_openfl_display_IBitmapDrawable
#include <openfl/display/IBitmapDrawable.h>
#endif
#ifndef INCLUDED_openfl_display_InteractiveObject
#include <openfl/display/InteractiveObject.h>
#endif
#ifndef INCLUDED_openfl_display_Sprite
#include <openfl/display/Sprite.h>
#endif
#ifndef INCLUDED_openfl_events_EventDispatcher
#include <openfl/events/EventDispatcher.h>
#endif
#ifndef INCLUDED_openfl_events_IEventDispatcher
#include <openfl/events/IEventDispatcher.h>
#endif
#ifndef INCLUDED_openfl_geom_Rectangle
#include <openfl/geom/Rectangle.h>
#endif
#ifndef INCLUDED_openfl_text_AntiAliasType
#include <openfl/text/AntiAliasType.h>
#endif
#ifndef INCLUDED_openfl_text_TextField
#include <openfl/text/TextField.h>
#endif
#ifndef INCLUDED_openfl_text_TextFieldAutoSize
#include <openfl/text/TextFieldAutoSize.h>
#endif
#ifndef INCLUDED_openfl_text_TextFormat
#include <openfl/text/TextFormat.h>
#endif
namespace com{
namespace danielfreeman{
namespace madcomponents{
Void UILabelX_obj::__construct(::openfl::display::Sprite screen,::com::danielfreeman::MadXML xml,::com::danielfreeman::madcomponents::Attributes attributes)
{
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","new",0x3b3bbdfe,"com.danielfreeman.madcomponents.UILabelX.new","com/danielfreeman/madcomponents/UILabelX.hx",15,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_ARG(screen,"screen")
HX_STACK_ARG(xml,"xml")
HX_STACK_ARG(attributes,"attributes")
{
HX_STACK_LINE(26)
this->_includeInLayout = true;
HX_STACK_LINE(25)
this->_clickable = true;
HX_STACK_LINE(30)
::String _g = xml->get_innerHTML(); HX_STACK_VAR(_g,"_g");
HX_STACK_LINE(30)
super::__construct(screen,attributes->x,attributes->y,_g,null());
HX_STACK_LINE(31)
bool _g2; HX_STACK_VAR(_g2,"_g2");
HX_STACK_LINE(31)
if ((xml->has->resolve(HX_CSTRING("embedFonts")))){
HX_STACK_LINE(31)
::String _g1 = xml->att->resolve(HX_CSTRING("embedFonts")); HX_STACK_VAR(_g1,"_g1");
HX_STACK_LINE(31)
_g2 = (_g1 == HX_CSTRING("true"));
}
else{
HX_STACK_LINE(31)
_g2 = false;
}
HX_STACK_LINE(31)
this->set_embedFonts(_g2);
HX_STACK_LINE(32)
if ((xml->has->resolve(HX_CSTRING("antiAliasType")))){
HX_STACK_LINE(33)
::openfl::text::AntiAliasType _g3; HX_STACK_VAR(_g3,"_g3");
HX_STACK_LINE(33)
_g3 = hx::TCast< openfl::text::AntiAliasType >::cast(xml->att->resolve(HX_CSTRING("antiAliasType")));
HX_STACK_LINE(33)
this->antiAliasType = _g3;
}
HX_STACK_LINE(35)
this->assignToLabel(xml);
HX_STACK_LINE(36)
if ((xml->has->resolve(HX_CSTRING("height")))){
HX_STACK_LINE(37)
::String _g4 = xml->att->resolve(HX_CSTRING("height")); HX_STACK_VAR(_g4,"_g4");
HX_STACK_LINE(37)
Float _g5 = ::Std_obj::parseFloat(_g4); HX_STACK_VAR(_g5,"_g5");
HX_STACK_LINE(37)
this->set_fixheight(_g5);
}
HX_STACK_LINE(39)
if ((( ((!(attributes->get_fillH()))) ? bool(xml->has->resolve(HX_CSTRING("height"))) : bool(true) ))){
HX_STACK_LINE(40)
Float _g6 = attributes->get_widthH(); HX_STACK_VAR(_g6,"_g6");
HX_STACK_LINE(40)
this->set_fixwidth(_g6);
HX_STACK_LINE(41)
::String textAlign = attributes->get_textAlign(); HX_STACK_VAR(textAlign,"textAlign");
HX_STACK_LINE(42)
if (((textAlign != HX_CSTRING("")))){
HX_STACK_LINE(43)
::openfl::text::TextFormat format = ::openfl::text::TextFormat_obj::__new(null(),null(),null(),null(),null(),null(),null(),null(),null(),null(),null(),null(),null()); HX_STACK_VAR(format,"format");
HX_STACK_LINE(45)
format->align = textAlign;
HX_STACK_LINE(46)
this->set_defaultTextFormat(format);
}
}
HX_STACK_LINE(49)
bool _g8; HX_STACK_VAR(_g8,"_g8");
HX_STACK_LINE(49)
if ((!((!(xml->has->resolve(HX_CSTRING("autosize"))))))){
HX_STACK_LINE(49)
::String _g7 = xml->att->resolve(HX_CSTRING("autosize")); HX_STACK_VAR(_g7,"_g7");
HX_STACK_LINE(49)
_g8 = (_g7 != HX_CSTRING("false"));
}
else{
HX_STACK_LINE(49)
_g8 = true;
}
HX_STACK_LINE(49)
this->_autoSize = _g8;
HX_STACK_LINE(50)
if ((this->_autoSize)){
HX_STACK_LINE(51)
this->set_autoSize(::openfl::text::TextFieldAutoSize_obj::LEFT);
}
}
;
return null();
}
//UILabelX_obj::~UILabelX_obj() { }
Dynamic UILabelX_obj::__CreateEmpty() { return new UILabelX_obj; }
hx::ObjectPtr< UILabelX_obj > UILabelX_obj::__new(::openfl::display::Sprite screen,::com::danielfreeman::MadXML xml,::com::danielfreeman::madcomponents::Attributes attributes)
{ hx::ObjectPtr< UILabelX_obj > result = new UILabelX_obj();
result->__construct(screen,xml,attributes);
return result;}
Dynamic UILabelX_obj::__Create(hx::DynamicArray inArgs)
{ hx::ObjectPtr< UILabelX_obj > result = new UILabelX_obj();
result->__construct(inArgs[0],inArgs[1],inArgs[2]);
return result;}
hx::Object *UILabelX_obj::__ToInterface(const hx::type_info &inType) {
if (inType==typeid( ::com::danielfreeman::madcomponents::IComponentUI_obj)) return operator ::com::danielfreeman::madcomponents::IComponentUI_obj *();
return super::__ToInterface(inType);
}
Void UILabelX_obj::assignToLabel( ::com::danielfreeman::MadXML xml){
{
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","assignToLabel",0x29ee4f28,"com.danielfreeman.madcomponents.UILabelX.assignToLabel","com/danielfreeman/madcomponents/UILabelX.hx",57,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_ARG(xml,"xml")
HX_STACK_LINE(57)
if ((xml->get_hasChildren())){
HX_STACK_LINE(58)
::String xmlString = xml->toXMLString(); HX_STACK_VAR(xmlString,"xmlString");
HX_STACK_LINE(59)
int _g = xmlString.indexOf(HX_CSTRING(">"),null()); HX_STACK_VAR(_g,"_g");
HX_STACK_LINE(59)
int _g1 = (_g + (int)1); HX_STACK_VAR(_g1,"_g1");
HX_STACK_LINE(59)
int _g2 = xmlString.lastIndexOf(HX_CSTRING("<"),null()); HX_STACK_VAR(_g2,"_g2");
HX_STACK_LINE(59)
::String htmlText = xmlString.substring(_g1,_g2); HX_STACK_VAR(htmlText,"htmlText");
HX_STACK_LINE(60)
this->set_xmlText(htmlText);
}
}
return null();
}
HX_DEFINE_DYNAMIC_FUNC1(UILabelX_obj,assignToLabel,(void))
Void UILabelX_obj::layout( ::com::danielfreeman::madcomponents::Attributes attributes){
{
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","layout",0xb83297cc,"com.danielfreeman.madcomponents.UILabelX.layout","com/danielfreeman/madcomponents/UILabelX.hx",65,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_ARG(attributes,"attributes")
HX_STACK_LINE(66)
this->_attributes = attributes;
HX_STACK_LINE(67)
if ((attributes->get_fillV())){
HX_STACK_LINE(68)
Float _g = attributes->get_heightV(); HX_STACK_VAR(_g,"_g");
HX_STACK_LINE(68)
this->set_fixheight(_g);
}
HX_STACK_LINE(70)
if ((attributes->get_fillH())){
HX_STACK_LINE(71)
Float _g1 = attributes->get_widthH(); HX_STACK_VAR(_g1,"_g1");
HX_STACK_LINE(71)
this->set_fixwidth(_g1);
}
HX_STACK_LINE(73)
if ((this->_autoSize)){
HX_STACK_LINE(74)
this->set_autoSize(::openfl::text::TextFieldAutoSize_obj::LEFT);
}
}
return null();
}
HX_DEFINE_DYNAMIC_FUNC1(UILabelX_obj,layout,(void))
bool UILabelX_obj::set_clickable( bool value){
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","set_clickable",0x2f30c2e3,"com.danielfreeman.madcomponents.UILabelX.set_clickable","com/danielfreeman/madcomponents/UILabelX.hx",79,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_ARG(value,"value")
HX_STACK_LINE(80)
this->_clickable = value;
HX_STACK_LINE(81)
return value;
}
HX_DEFINE_DYNAMIC_FUNC1(UILabelX_obj,set_clickable,return )
bool UILabelX_obj::get_clickable( ){
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","get_clickable",0xea2ae0d7,"com.danielfreeman.madcomponents.UILabelX.get_clickable","com/danielfreeman/madcomponents/UILabelX.hx",85,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_LINE(85)
return this->_clickable;
}
HX_DEFINE_DYNAMIC_FUNC0(UILabelX_obj,get_clickable,return )
bool UILabelX_obj::set_includeInLayout( bool value){
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","set_includeInLayout",0x7b3b6678,"com.danielfreeman.madcomponents.UILabelX.set_includeInLayout","com/danielfreeman/madcomponents/UILabelX.hx",88,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_ARG(value,"value")
HX_STACK_LINE(89)
this->_includeInLayout = value;
HX_STACK_LINE(90)
return value;
}
HX_DEFINE_DYNAMIC_FUNC1(UILabelX_obj,set_includeInLayout,return )
bool UILabelX_obj::get_includeInLayout( ){
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","get_includeInLayout",0x3e9e736c,"com.danielfreeman.madcomponents.UILabelX.get_includeInLayout","com/danielfreeman/madcomponents/UILabelX.hx",94,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_LINE(94)
return this->_includeInLayout;
}
HX_DEFINE_DYNAMIC_FUNC0(UILabelX_obj,get_includeInLayout,return )
Void UILabelX_obj::touchCancel( ){
{
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","touchCancel",0xc6860e37,"com.danielfreeman.madcomponents.UILabelX.touchCancel","com/danielfreeman/madcomponents/UILabelX.hx",97,0x1d91accf)
HX_STACK_THIS(this)
}
return null();
}
HX_DEFINE_DYNAMIC_FUNC0(UILabelX_obj,touchCancel,(void))
::com::danielfreeman::madcomponents::Attributes UILabelX_obj::get_attributes( ){
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","get_attributes",0xca820c42,"com.danielfreeman.madcomponents.UILabelX.get_attributes","com/danielfreeman/madcomponents/UILabelX.hx",115,0x1d91accf)
HX_STACK_THIS(this)
HX_STACK_LINE(115)
return this->_attributes;
}
HX_DEFINE_DYNAMIC_FUNC0(UILabelX_obj,get_attributes,return )
Void UILabelX_obj::destructor( ){
{
HX_STACK_FRAME("com.danielfreeman.madcomponents.UILabelX","destructor",0x14d3fd5b,"com.danielfreeman.madcomponents.UILabelX.destructor","com/danielfreeman/madcomponents/UILabelX.hx",119,0x1d91accf)
HX_STACK_THIS(this)
}
return null();
}
HX_DEFINE_DYNAMIC_FUNC0(UILabelX_obj,destructor,(void))
UILabelX_obj::UILabelX_obj()
{
}
void UILabelX_obj::__Mark(HX_MARK_PARAMS)
{
HX_MARK_BEGIN_CLASS(UILabelX);
HX_MARK_MEMBER_NAME(_autoSize,"_autoSize");
HX_MARK_MEMBER_NAME(_attributes,"_attributes");
HX_MARK_MEMBER_NAME(_xml,"_xml");
HX_MARK_MEMBER_NAME(_clickable,"_clickable");
HX_MARK_MEMBER_NAME(_includeInLayout,"_includeInLayout");
::openfl::text::TextField_obj::__Mark(HX_MARK_ARG);
HX_MARK_END_CLASS();
}
void UILabelX_obj::__Visit(HX_VISIT_PARAMS)
{
HX_VISIT_MEMBER_NAME(_autoSize,"_autoSize");
HX_VISIT_MEMBER_NAME(_attributes,"_attributes");
HX_VISIT_MEMBER_NAME(_xml,"_xml");
HX_VISIT_MEMBER_NAME(_clickable,"_clickable");
HX_VISIT_MEMBER_NAME(_includeInLayout,"_includeInLayout");
::openfl::text::TextField_obj::__Visit(HX_VISIT_ARG);
}
Dynamic UILabelX_obj::__Field(const ::String &inName,bool inCallProp)
{
switch(inName.length) {
case 4:
if (HX_FIELD_EQ(inName,"_xml") ) { return _xml; }
break;
case 6:
if (HX_FIELD_EQ(inName,"layout") ) { return layout_dyn(); }
break;
case 9:
if (HX_FIELD_EQ(inName,"clickable") ) { return get_clickable(); }
if (HX_FIELD_EQ(inName,"_autoSize") ) { return _autoSize; }
break;
case 10:
if (HX_FIELD_EQ(inName,"attributes") ) { return get_attributes(); }
if (HX_FIELD_EQ(inName,"_clickable") ) { return _clickable; }
if (HX_FIELD_EQ(inName,"destructor") ) { return destructor_dyn(); }
break;
case 11:
if (HX_FIELD_EQ(inName,"_attributes") ) { return _attributes; }
if (HX_FIELD_EQ(inName,"touchCancel") ) { return touchCancel_dyn(); }
break;
case 13:
if (HX_FIELD_EQ(inName,"assignToLabel") ) { return assignToLabel_dyn(); }
if (HX_FIELD_EQ(inName,"set_clickable") ) { return set_clickable_dyn(); }
if (HX_FIELD_EQ(inName,"get_clickable") ) { return get_clickable_dyn(); }
break;
case 14:
if (HX_FIELD_EQ(inName,"get_attributes") ) { return get_attributes_dyn(); }
break;
case 15:
if (HX_FIELD_EQ(inName,"includeInLayout") ) { return get_includeInLayout(); }
break;
case 16:
if (HX_FIELD_EQ(inName,"_includeInLayout") ) { return _includeInLayout; }
break;
case 19:
if (HX_FIELD_EQ(inName,"set_includeInLayout") ) { return set_includeInLayout_dyn(); }
if (HX_FIELD_EQ(inName,"get_includeInLayout") ) { return get_includeInLayout_dyn(); }
}
return super::__Field(inName,inCallProp);
}
Dynamic UILabelX_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
switch(inName.length) {
case 4:
if (HX_FIELD_EQ(inName,"_xml") ) { _xml=inValue.Cast< ::com::danielfreeman::MadXML >(); return inValue; }
break;
case 9:
if (HX_FIELD_EQ(inName,"clickable") ) { return set_clickable(inValue); }
if (HX_FIELD_EQ(inName,"_autoSize") ) { _autoSize=inValue.Cast< bool >(); return inValue; }
break;
case 10:
if (HX_FIELD_EQ(inName,"_clickable") ) { _clickable=inValue.Cast< bool >(); return inValue; }
break;
case 11:
if (HX_FIELD_EQ(inName,"_attributes") ) { _attributes=inValue.Cast< ::com::danielfreeman::madcomponents::Attributes >(); return inValue; }
break;
case 15:
if (HX_FIELD_EQ(inName,"includeInLayout") ) { return set_includeInLayout(inValue); }
break;
case 16:
if (HX_FIELD_EQ(inName,"_includeInLayout") ) { _includeInLayout=inValue.Cast< bool >(); return inValue; }
}
return super::__SetField(inName,inValue,inCallProp);
}
void UILabelX_obj::__GetFields(Array< ::String> &outFields)
{
outFields->push(HX_CSTRING("attributes"));
outFields->push(HX_CSTRING("clickable"));
outFields->push(HX_CSTRING("includeInLayout"));
outFields->push(HX_CSTRING("_autoSize"));
outFields->push(HX_CSTRING("_attributes"));
outFields->push(HX_CSTRING("_xml"));
outFields->push(HX_CSTRING("_clickable"));
outFields->push(HX_CSTRING("_includeInLayout"));
super::__GetFields(outFields);
};
static ::String sStaticFields[] = {
String(null()) };
#if HXCPP_SCRIPTABLE
static hx::StorageInfo sMemberStorageInfo[] = {
{hx::fsBool,(int)offsetof(UILabelX_obj,_autoSize),HX_CSTRING("_autoSize")},
{hx::fsObject /*::com::danielfreeman::madcomponents::Attributes*/ ,(int)offsetof(UILabelX_obj,_attributes),HX_CSTRING("_attributes")},
{hx::fsObject /*::com::danielfreeman::MadXML*/ ,(int)offsetof(UILabelX_obj,_xml),HX_CSTRING("_xml")},
{hx::fsBool,(int)offsetof(UILabelX_obj,_clickable),HX_CSTRING("_clickable")},
{hx::fsBool,(int)offsetof(UILabelX_obj,_includeInLayout),HX_CSTRING("_includeInLayout")},
{ hx::fsUnknown, 0, null()}
};
#endif
static ::String sMemberFields[] = {
HX_CSTRING("_autoSize"),
HX_CSTRING("_attributes"),
HX_CSTRING("_xml"),
HX_CSTRING("_clickable"),
HX_CSTRING("_includeInLayout"),
HX_CSTRING("assignToLabel"),
HX_CSTRING("layout"),
HX_CSTRING("set_clickable"),
HX_CSTRING("get_clickable"),
HX_CSTRING("set_includeInLayout"),
HX_CSTRING("get_includeInLayout"),
HX_CSTRING("touchCancel"),
HX_CSTRING("get_attributes"),
HX_CSTRING("destructor"),
String(null()) };
static void sMarkStatics(HX_MARK_PARAMS) {
HX_MARK_MEMBER_NAME(UILabelX_obj::__mClass,"__mClass");
};
#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
HX_VISIT_MEMBER_NAME(UILabelX_obj::__mClass,"__mClass");
};
#endif
Class UILabelX_obj::__mClass;
void UILabelX_obj::__register()
{
hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("com.danielfreeman.madcomponents.UILabelX"), hx::TCanCast< UILabelX_obj> ,sStaticFields,sMemberFields,
&__CreateEmpty, &__Create,
&super::__SGetClass(), 0, sMarkStatics
#ifdef HXCPP_VISIT_ALLOCS
, sVisitStatics
#endif
#ifdef HXCPP_SCRIPTABLE
, sMemberStorageInfo
#endif
);
}
void UILabelX_obj::__boot()
{
}
} // end namespace com
} // end namespace danielfreeman
} // end namespace madcomponents
| [
"doc.android@gmail.com"
] | doc.android@gmail.com |
a9149d5fdc9b892738f751f05efb45e2772194a7 | 1bc8d532f358caec8f06f514dbfdd59eb7cf897e | /srcanamdw_os/leavescan/test/testcases/DEF-testcases/pct-leavescan-def-132384-010.cpp | 15e07d5a0c1af9303eeebe2994e4f79923975966 | [] | no_license | SymbianSource/oss.FCL.sf.os.buildtools | 9cd33884e5f7dd49dce8016a79b9443cc3551b07 | 7b35cd328d3a5e8e0bc177d0169fd409c3273193 | refs/heads/master | 2021-01-12T10:57:19.083691 | 2010-07-13T15:41:02 | 2010-07-13T15:41:02 | 72,765,750 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 575 | cpp | /*
* Copyright (c) 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:
*
*/
//desc:keyword:operator
//option:
//date:2008-12-22 14:58:10
//author:bolowy
//type: CT
void aoperator()
{
fooL(); //check:aoperator
}
| [
"kirill.dremov@nokia.com"
] | kirill.dremov@nokia.com |
7a0318bd7e95f06462b852b1f2d1a3a8296b2540 | e360ee97d1358959491a11e3c8db772c9a3c877a | /Floral/LTexture.h | 4d6cb8202ee0cf41274c898f11e6b82f8944398b | [] | no_license | yiochen/Floral328 | ed71b602ed71627dab0688127076858e9340f0da | 45a85960934ece52b3926b795df88dcb2f2c932b | refs/heads/master | 2021-01-21T12:58:04.298072 | 2016-05-10T00:44:46 | 2016-05-10T00:44:46 | 55,370,909 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 605 | h | #pragma once
#include "opengl_include.h"
#include "vector.h"
#include <string>
/*LTexture represent a texture read from file*/
class LTexture
{
public:
LTexture();
~LTexture();
void init();
bool loadTextureFromFile(std::string path);
//bool loadTextureFromPixels32(GLuint* pixels, GLuint width, GLuint height);
void freeTexture();
void render(GLfloat x, GLfloat y);
GLuint getTextureID();
GLint textureWidth();
GLint textureHeight();
void mapStart();
void mapEnd();
void mapPair(Vec v1, Vec v2, float ratio);
private:
GLuint mTextureID;
GLint mTextureWidth;
GLint mTextureHeight;
};
| [
"chen.yiou1992@gmail.com"
] | chen.yiou1992@gmail.com |
7da28a0c2d41843693db69c5fbadcee550bd2618 | aeff733cb0915515fd3de5a9991f2f2b54c7b00e | /cmakeStandardTemplate/src/test.cpp | 96f70da1d57fb2703d98935c1bac9f8e45c141c0 | [] | no_license | xiang-tao/c-primer-Plus | f67405a5f46b03bde58ef44c0ad172f0badafc18 | 0ce217449f1a5c599722e81c3e920dd812af1d18 | refs/heads/master | 2023-08-14T10:44:02.843105 | 2021-09-16T10:38:33 | 2021-09-16T10:38:33 | 371,877,637 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 119 | cpp | #include<iostream>
using namespace std;
int main()
{
cout<<"ไฝ ๅฏไปฅๅไธไบๆต่ฏๆๆกฃ"<<endl;
return 0;
}
| [
"1689415053@qq.com"
] | 1689415053@qq.com |
ac72d1b4f2ada1810953f4f3f91486f97652f5f0 | 90047daeb462598a924d76ddf4288e832e86417c | /chrome/browser/ui/views/try_chrome_dialog_view.h | 004cbbc63c1cfd2c72494a5863e108934b29bf11 | [
"BSD-3-Clause"
] | permissive | massbrowser/android | 99b8c21fa4552a13c06bbedd0f9c88dd4a4ad080 | a9c4371682c9443d6e1d66005d4db61a24a9617c | refs/heads/master | 2022-11-04T21:15:50.656802 | 2017-06-08T12:31:39 | 2017-06-08T12:31:39 | 93,747,579 | 2 | 2 | BSD-3-Clause | 2022-10-31T10:34:25 | 2017-06-08T12:36:07 | null | UTF-8 | C++ | false | false | 5,863 | h | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_UI_VIEWS_TRY_CHROME_DIALOG_VIEW_H_
#define CHROME_BROWSER_UI_VIEWS_TRY_CHROME_DIALOG_VIEW_H_
#include <stddef.h>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/controls/link_listener.h"
namespace views {
class RadioButton;
class Checkbox;
class Widget;
}
// This class displays a modal dialog using the views system. The dialog asks
// the user to give chrome another try. This class only handles the UI so the
// resulting actions are up to the caller. One flavor looks like this:
//
// +-----------------------------------------------+
// | |icon| There is a new, safer version [x] |
// | |icon| of Google Chrome available |
// | [o] Try it out (already installed) |
// | [ ] Uninstall Google Chrome |
// | [ OK ] [Don't bug me] |
// | _why_am_I_seeing this?_ |
// +-----------------------------------------------+
//
// Another flavor looks like:
// +-----------------------------------------------+
// | |icon| There is a new, safer version [x] |
// | |icon| of Google Chrome available |
// | [o] Try it out (already installed) |
// | [ ] Don't bug me |
// | [ OK ] |
// +-----------------------------------------------+
//
// And the 2013 version looks like:
// +-----------------------------------------------+
// | |icon| There is a new version of [x] |
// | |icon| Google Chrome available |
// | [o] Try it out (already installed) |
// | [ ] Don't bug me |
// | --------------------------------------------- |
// | [x] Make it the default browser [ OK ] |
// +-----------------------------------------------+
class TryChromeDialogView : public views::ButtonListener,
public views::LinkListener {
public:
// Receives a handle to the active modal dialog, or NULL when the active
// dialog is dismissed.
typedef base::Callback<void(gfx::NativeWindow active_dialog)>
ActiveModalDialogListener;
enum Result {
TRY_CHROME, // Launch chrome right now.
TRY_CHROME_AS_DEFAULT, // Launch chrome and make it the default.
NOT_NOW, // Don't launch chrome. Exit now.
UNINSTALL_CHROME, // Initiate chrome uninstall and exit.
DIALOG_ERROR, // An error occurred creating the dialog.
COUNT
};
// Shows a modal dialog asking the user to give chrome another try. See
// above for the possible outcomes of the function. This is an experimental,
// non-localized dialog.
// |flavor| can be 0, 1, 2 or 3 and selects what strings to present.
// |listener| will be notified when the dialog becomes active and when it is
// dismissed.
// Note that the dialog has no parent and it will position itself in a lower
// corner of the screen. The dialog does not steal focus and does not have an
// entry in the taskbar.
static Result Show(size_t flavor,
const ActiveModalDialogListener& listener);
private:
// Indicates whether the dialog is modal
enum class kDialogType {
MODAL, // Modal dialog.
MODELESS, // Modeless dialog.
};
// Indicates the usage type. Chrome or tests.
enum class kUsageType {
FOR_CHROME,
FOR_TESTING,
};
friend class TryChromeDialogTest;
explicit TryChromeDialogView(size_t flavor);
~TryChromeDialogView() override;
// Helper function to show the dialog.
// The |dialog_type| parameter indicates whether the dialog is modal.
// The |usage_type| parameter indicates whether this is being invoked by
// chrome or a test.
Result ShowDialog(const ActiveModalDialogListener& listener,
kDialogType dialog_type,
kUsageType usage_type);
// Returns a screen rectangle that is fit to show the window. In particular
// it has the following properties: a) is visible and b) is attached to the
// bottom of the working area. For LTR machines it returns a left side
// rectangle and for RTL it returns a right side rectangle so that the dialog
// does not compete with the standard place of the start menu.
gfx::Rect ComputeWindowPosition(const gfx::Size& size, bool is_RTL);
// Create a windows region that looks like a toast of width |w| and height
// |h|. This is best effort, so we don't care much if the operation fails.
void SetToastRegion(HWND window, int w, int h);
// views::ButtonListener:
// We have two buttons and according to what the user clicked we set |result_|
// and we should always close and end the modal loop.
void ButtonPressed(views::Button* sender, const ui::Event& event) override;
// views::LinkListener:
// If the user selects the link we need to fire off the default browser that
// by some convoluted logic should not be chrome.
void LinkClicked(views::Link* source, int event_flags) override;
// Controls which flavor of the heading text to use.
size_t flavor_;
// We don't own any of these pointers. The |popup_| owns itself and owns the
// other views.
views::Widget* popup_;
views::RadioButton* try_chrome_;
views::RadioButton* kill_chrome_;
views::RadioButton* dont_try_chrome_;
views::Checkbox* make_default_;
Result result_;
DISALLOW_COPY_AND_ASSIGN(TryChromeDialogView);
};
#endif // CHROME_BROWSER_UI_VIEWS_TRY_CHROME_DIALOG_VIEW_H_
| [
"xElvis89x@gmail.com"
] | xElvis89x@gmail.com |
e5ffed9fb526d2299d1ca35e713350caa1b2e15d | 61268bb5a5eaa24cd4fabcf3c25c4b993bf7c9dc | /STARTUP.cpp | 0dbf2985d0b96c4fd9ef6a7e0213fdba37183201 | [] | no_license | verge-rpg/verge2.6r2.1 | a55ad535e61d2db3f05538d6ac1e2af6d97d0b57 | eef0ab547ad8d0d89e089a8ff0144e6f82dc81d5 | refs/heads/master | 2021-03-03T08:34:01.743130 | 2020-03-09T04:54:45 | 2020-03-09T04:54:45 | 245,946,853 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,846 | cpp | /*
Copyright (C) 1998 BJ Eirich (aka vecna)
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// startup.c
// Copyright (C) 1998 BJ Eirich
// This shouldn't really be platform-dependent, but it's put in the platform
// dependent files because of Windows. :P
// tSB: Most of the Win32 crap is here. (the message pump, CreateWindowEx, etc...)
// Sometimes, the graphics driver plays with the window size and little things like that,
// And w_timer.cpp has a callback function.
//#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <time.h>
#include <stdarg.h> // va_*()
#include <stdlib.h>
//#define MAIN_H
#include "verge.h"
#define TITLE "VERGE v2.6"
#define NAME "MainWindow"
// in VERGE.CPP
extern int VMain();
extern void Log(const char* message);
extern void Logp(const char* message);
extern void InitLog();
extern char logoutput;
// Data
// Win32 stuff
HWND hWnd;
bool bActive;
static unsigned char vergepal[]=
{
0x00,0x00,0x00,0x02,0x02,0x02,0x03,0x03,0x03,0x05,0x05,0x05,0x07,
0x07,0x07,0x09,0x09,0x09,0x0a,0x0a,0x0a,0x0c,0x0c,0x0c,0x0e,0x0e,
0x0e,0x0f,0x0f,0x0f,0x11,0x11,0x11,0x13,0x13,0x13,0x15,0x15,0x15,
0x16,0x16,0x16,0x18,0x18,0x18,0x1a,0x1a,0x1a,0x1c,0x1c,0x1c,0x1d,
0x1d,0x1d,0x1f,0x1f,0x1f,0x21,0x21,0x21,0x22,0x22,0x22,0x24,0x24,
0x24,0x26,0x26,0x26,0x28,0x28,0x28,0x29,0x29,0x29,0x2b,0x2b,0x2b,
0x2e,0x2e,0x2e,0x31,0x31,0x31,0x34,0x34,0x34,0x36,0x36,0x36,0x39,
0x39,0x39,0x3c,0x3c,0x3c,0x3f,0x00,0x00,0x3b,0x00,0x00,0x38,0x00,
0x00,0x35,0x00,0x00,0x32,0x00,0x00,0x2f,0x00,0x00,0x2c,0x00,0x00,
0x29,0x00,0x00,0x26,0x00,0x00,0x22,0x00,0x00,0x1f,0x00,0x00,0x1c,
0x00,0x00,0x19,0x00,0x00,0x16,0x00,0x00,0x13,0x00,0x00,0x10,0x00,
0x00,0x3f,0x36,0x36,0x3f,0x2e,0x2e,0x3f,0x27,0x27,0x3f,0x1f,0x1f,
0x3f,0x17,0x17,0x3f,0x10,0x10,0x3f,0x08,0x08,0x3f,0x00,0x00,0x11,
0x0b,0x06,0x13,0x0d,0x07,0x15,0x0f,0x09,0x17,0x11,0x0a,0x18,0x13,
0x0b,0x1a,0x15,0x0c,0x1c,0x17,0x0e,0x1e,0x19,0x0f,0x3f,0x3f,0x36,
0x3f,0x3f,0x2e,0x3f,0x3f,0x27,0x3f,0x3f,0x1f,0x3f,0x3e,0x17,0x3f,
0x3d,0x10,0x3f,0x3d,0x08,0x3f,0x3d,0x00,0x39,0x36,0x00,0x33,0x31,
0x00,0x2d,0x2b,0x00,0x27,0x27,0x00,0x21,0x21,0x00,0x1c,0x1b,0x00,
0x16,0x15,0x00,0x10,0x10,0x00,0x34,0x3f,0x17,0x31,0x3f,0x10,0x2d,
0x3f,0x08,0x28,0x3f,0x00,0x24,0x39,0x00,0x20,0x33,0x00,0x1d,0x2d,
0x00,0x18,0x27,0x00,0x36,0x3f,0x36,0x2e,0x3d,0x2e,0x27,0x3b,0x27,
0x1f,0x39,0x1f,0x17,0x36,0x17,0x0f,0x34,0x0f,0x08,0x32,0x08,0x00,
0x30,0x00,0x00,0x2d,0x00,0x00,0x2b,0x00,0x00,0x28,0x00,0x00,0x26,
0x00,0x00,0x23,0x00,0x00,0x21,0x00,0x00,0x1e,0x00,0x00,0x1c,0x00,
0x00,0x19,0x00,0x00,0x17,0x00,0x00,0x14,0x00,0x00,0x12,0x00,0x00,
0x0f,0x00,0x02,0x0d,0x02,0x03,0x0a,0x03,0x05,0x08,0x05,0x36,0x3f,
0x3f,0x2e,0x3f,0x3f,0x27,0x3f,0x3f,0x1f,0x3f,0x3f,0x17,0x3f,0x3f,
0x0f,0x3f,0x3f,0x08,0x3f,0x3f,0x00,0x3f,0x3f,0x00,0x39,0x39,0x00,
0x33,0x33,0x00,0x2d,0x2d,0x00,0x27,0x27,0x00,0x22,0x22,0x00,0x1c,
0x1c,0x00,0x16,0x16,0x00,0x10,0x10,0x17,0x2f,0x3f,0x10,0x2c,0x3f,
0x08,0x2a,0x3f,0x00,0x27,0x3f,0x00,0x23,0x39,0x00,0x1f,0x33,0x00,
0x1b,0x2d,0x00,0x17,0x27,0x36,0x36,0x3f,0x2e,0x2f,0x3f,0x27,0x27,
0x3f,0x1f,0x20,0x3f,0x17,0x18,0x3f,0x10,0x10,0x3f,0x08,0x09,0x3f,
0x00,0x01,0x3f,0x00,0x00,0x3f,0x00,0x00,0x3b,0x00,0x00,0x38,0x00,
0x00,0x35,0x00,0x00,0x32,0x00,0x00,0x2f,0x00,0x00,0x2c,0x00,0x00,
0x29,0x00,0x00,0x26,0x00,0x00,0x22,0x00,0x00,0x1f,0x00,0x00,0x1c,
0x00,0x00,0x19,0x00,0x00,0x16,0x00,0x00,0x13,0x00,0x00,0x10,0x0d,
0x08,0x00,0x0f,0x09,0x00,0x12,0x0a,0x00,0x14,0x0b,0x00,0x16,0x0c,
0x00,0x19,0x0d,0x00,0x1b,0x0e,0x00,0x1e,0x0f,0x00,0x20,0x10,0x00,
0x22,0x11,0x00,0x25,0x12,0x00,0x28,0x15,0x03,0x2c,0x18,0x06,0x2f,
0x1b,0x09,0x32,0x1e,0x0c,0x35,0x21,0x0e,0x39,0x24,0x11,0x3c,0x27,
0x14,0x3f,0x2a,0x17,0x3f,0x2e,0x1c,0x3f,0x31,0x22,0x3f,0x35,0x27,
0x3f,0x38,0x2c,0x22,0x1c,0x12,0x25,0x1f,0x14,0x29,0x22,0x17,0x2c,
0x25,0x19,0x2f,0x28,0x1c,0x32,0x2a,0x1e,0x36,0x2d,0x20,0x39,0x30,
0x23,0x3c,0x33,0x25,0x3f,0x3a,0x37,0x3f,0x38,0x34,0x3f,0x36,0x31,
0x3f,0x35,0x2f,0x3f,0x33,0x2c,0x3f,0x31,0x29,0x3f,0x2f,0x27,0x3f,
0x2e,0x24,0x3f,0x2c,0x20,0x3f,0x29,0x1c,0x3f,0x27,0x18,0x3c,0x25,
0x17,0x3a,0x23,0x16,0x37,0x22,0x15,0x34,0x20,0x14,0x32,0x1f,0x13,
0x2f,0x1e,0x12,0x2d,0x1c,0x11,0x2a,0x1a,0x10,0x28,0x19,0x0f,0x27,
0x18,0x0e,0x24,0x17,0x0d,0x22,0x16,0x0c,0x20,0x14,0x0b,0x1d,0x13,
0x0a,0x1b,0x12,0x09,0x17,0x10,0x08,0x15,0x0f,0x07,0x12,0x0e,0x06,
0x10,0x0c,0x06,0x0e,0x0b,0x05,0x0a,0x08,0x03,0x3f,0x00,0x00,0x3f,
0x04,0x00,0x3f,0x08,0x00,0x3f,0x0d,0x00,0x3f,0x11,0x00,0x3f,0x15,
0x00,0x3f,0x19,0x00,0x3f,0x1d,0x00,0x3f,0x22,0x00,0x3f,0x26,0x00,
0x3f,0x2a,0x00,0x3f,0x2e,0x00,0x3f,0x32,0x00,0x3f,0x37,0x00,0x3f,
0x3b,0x00,0x3f,0x3f,0x00,0x3f,0x2f,0x00,0x36,0x28,0x00,0x2d,0x22,
0x00,0x24,0x1b,0x00,0x1b,0x14,0x00,0x12,0x0d,0x00,0x09,0x07,0x00,
0x00,0x00,0x00,0x29,0x00,0x28,0x23,0x00,0x2b,0x1d,0x00,0x2f,0x17,
0x00,0x32,0x12,0x00,0x35,0x0c,0x00,0x38,0x06,0x00,0x3c,0x3f,0x3f,
0x3f,0x3f
}; // gah!
int hicolour =0; // bleh --tSB
int fullscreenmode =1; // ditto
char* strbuf =0; // Universal temporary string buffer. :)
char joyflag =0;
int vidxres =0;
int vidyres =0;
char nocdaudio =0; // do not use CD audio
string_k startmap; // start map
// ================================= Code ====================================
void V_memset (void *dest, int fill, int count)
{
int i;
for (i=0 ; i<count ; i++)
((byte *)dest)[i] = (byte)fill;
}
void V_memcpy (void *dest, const void *src, int count)
{
int i;
if (( ( (long)dest | (long)src | count) & 3) == 0 )
{
count>>=2;
for (i=0 ; i<count ; i++)
((int *)dest)[i] = ((int *)src)[i];
}
else
for (i=0 ; i<count ; i++)
((byte *)dest)[i] = ((byte *)src)[i];
}
int V_memcmp (const void *m1, const void *m2, int count)
{
while(count)
{
count--;
if (((byte *)m1)[count] != ((byte *)m2)[count])
return -1;
}
return 0;
}
void V_strcpy (char *dest, const char *src)
{
while (*src)
{
*dest++ = *src++;
}
*dest++ = 0;
}
void V_strncpy(char* dest, const char* src, int count)
{
while (*src && count--)
{
*dest++ = *src++;
}
if (count)
*dest++ = 0;
}
int V_strlen (const char *str)
{
int count;
count = 0;
while (str[count])
count++;
return count;
}
void V_strcat (char *dest, char *src)
{
dest += V_strlen(dest);
V_strcpy (dest, src);
}
int V_strcmp(const char* s1, const char* s2)
{
while (1)
{
if (*s1 < *s2)
return -1; // strings not equal
if (*s1 > *s2)
return +1;
if (!*s1)
return 0; // strings are equal
s1++;
s2++;
}
//return 666;
}
int V_atoi (const char *str)
{
int val;
int sign;
int c;
if (*str == '-')
{
sign = -1;
str++;
}
else
sign = 1;
val = 0;
//
// check for hex
//
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
{
str += 2;
while (1)
{
c = *str++;
if (c >= '0' && c <= '9')
val = (val<<4) + c - '0';
else if (c >= 'a' && c <= 'f')
val = (val<<4) + c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
val = (val<<4) + c - 'A' + 10;
else
return val*sign;
}
}
//
// check for character
//
if (str[0] == '\'')
{
return sign * str[1];
}
//
// assume decimal
//
while (1)
{
c = *str++;
if (c <'0' || c > '9')
return val*sign;
val = val*10 + c - '0';
}
//return 0;
}
float V_atof (const char *str)
{
float val;
int sign;
int c;
int decimal, total;
if (*str == '-')
{
sign = -1;
str++;
}
else
sign = 1;
val = 0;
//
// check for hex
//
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
{
str += 2;
while (1)
{
c = *str++;
if (c >= '0' && c <= '9')
val = (val*16) + c - '0';
else if (c >= 'a' && c <= 'f')
val = (val*16) + c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
val = (val*16) + c - 'A' + 10;
else
return val*sign;
}
}
//
// check for character
//
if (str[0] == '\'')
{
return (float)(sign * str[1]);
}
//
// assume decimal
//
decimal = -1;
total = 0;
while (1)
{
c = *str++;
if (c == '.')
{
decimal = total;
continue;
}
if (c <'0' || c > '9')
break;
val = val*10 + c - '0';
total++;
}
if (decimal == -1)
return val*sign;
while (total > decimal)
{
val /= 10;
total--;
}
return val*sign;
}
char* va(char* format, ...)
{
va_list argptr;
static char string[1024];
va_start(argptr, format);
vsprintf(string, format, argptr);
va_end(argptr);
return string;
}
void Sys_Error(const char* format, ...)
{
va_list argptr;
static char string[1024];
va_start(argptr, format);
vsprintf(string, format, argptr);
va_end(argptr);
// <aen> why can't I nest another va() in here?
Logp("Sys: Exiting with message: ");
Log(string);
ShutdownTimer();
input.ShutDown();
gfx.ShutDown();
ShutdownMusicSystem();
//CD_Deinit();
/*MD_PlayStop();
MD_Exit();*/
// sound.init();
/*if (ShutdownVideo)
ShutdownVideo(1);*/ // grdriver's destructor handles this for us
DestroyWindow(hWnd); // is this necessary? --tSB
if (strcmp("",string))
MessageBox (NULL, string, "", 0);
fflush(stdout);
FreeAllMemory();
PostQuitMessage(0);
exit(-1);
}
int sgn(int x)
{
if (x>0)
return 1;
else if (x<0)
return -1;
return 0;
}
void InitializeDefaults()
{
/* kb1=K_ENTER; // default keyboard controls
kb2=K_ALT;
kb3=K_ESC;
kb4=' ';
jb1=1; // joystick aliases
jb2=2;
jb3=3;
jb4=4;
joyflag=0; */ // joystick defaults to disabled
vidxres=320; // default res is 320x240
vidyres=240;
logoutput=0; // Don't be annoyingly verbose
V_memset(bindarray, 0, sizeof(bindarray)); // clear this here so we don't trigger random events on the first keypress
strbuf=(char *) valloc(2000, "strbuf", OID_TEMP); // globally used string; TODO: remove all dependencies on this, and get rid of it
startmap=""; //test.map"; // default startup map
gfx.VSync(false); // no vsync by default
// default MikMod settings
/* md_mode =DMODE_STEREO|DMODE_16BITS|DMODE_INTERP;
md_mixfreq =22050;*/
// prep the joystick for use
//Calibrate();
}
// <aen, apr 21>
// + added these few static routines and made ParseStartupFiles() use'em
static VFILE *user_cfg_file=0;
static char parse_str[256];
static char *parse_cfg_token()
{ vscanf(user_cfg_file, "%s", parse_str); return parse_str; }
// compares string against parse_str (grabbed by parse_cfg_token())
// 0=mismatch, 1=match
static int parse_match(char *str)
{ return !strcmp(parse_str, str); }
// zero error correcting or detection; fix <aen, apr 21>
void ParseStartupFiles()
{
user_cfg_file = vopen("user.cfg");
if (!user_cfg_file)
{
return;
}
while (1)
{
parse_cfg_token();
// mounts a pack file; up to 3? (perhaps gaurd against more?)
if (parse_match("mount"))
{ MountVFile(parse_cfg_token()); continue; }
// set video resolution
else if (parse_match("vidmode"))
{
vidxres = V_atoi(parse_cfg_token());
vidyres = V_atoi(parse_cfg_token());
continue;
}
// log to VERGE.LOG
else if (parse_match("log"))
{ logoutput=1; continue; }
// disable CD playing
/* else if (parse_match("nocdaudio"))
{ nocdaudio=1; continue; }*/
// map VERGE.EXE will run first when executed
else if (parse_match("startmap"))
{ startmap = parse_cfg_token(); continue; } // --tSB why not?
// 0=auto detect, 1=???, 2=???, 3=nosound
else if (parse_match("sound_device"))
{
parse_cfg_token();
// md_device = (UWORD)V_atoi(parse_cfg_token());
continue;
}
// sound lib setting
else if (parse_match("mixrate"))
{
sfx_mixrate = (word)V_atoi(parse_cfg_token());
continue;
}
// sound lib setting
else if (parse_match("safemode"))
{
sfx_safemode=1;
continue;
}
else if (parse_match("dmabufsize"))
{
parse_cfg_token();
continue;
}
// sound lib setting
else if (parse_match("force8bit"))
{ continue; }
// sound lib setting
else if (parse_match("forcemono"))
{ continue; }
else if (parse_match("hicolor"))
{
hicolour=1;
continue;
}
else if (parse_match("window"))
{
fullscreenmode=0;
continue;
}
else if (parse_match("vsync"))
{
gfx.VSync(true);
continue;
}
// unknown command, assume end
break;
}
// done parsing config
vclose(user_cfg_file);
}
void ParseAutoCFG()
{
VFILE* vf;
int i;
vf =vopen("auto.cfg");
if (!vf) return;
while (1)
{
char temp[256+1]={0};
vgets(temp, 256, vf);
temp[256]='\0';
for (i=0; i<V_strlen(temp); i++) {
if (temp[i]==10 || temp[i]==13)
temp[i]=0;
}
if (V_strlen(temp)<2) {
break;
}
//cmd=temp;
Console_SendCommand(temp);
}
vclose(vf);
}
// --tSB moved Conlib_Ver() to conlib.h (that's the only place it's needed anyway :P
int CheckMessages()
{
// Win95 can bite me.
// mehehehe --tSB
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) || !bActive)
{
if (msg.message==WM_QUIT)
return msg.wParam;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
void InitSystems(HINSTANCE hInst)
{
InitLog();
Log("v2.6 startup. Logfile initialized.");
Logp("Sys: Initializing keyboard handler.");
if (!input.Init(hInst,hWnd))
Sys_Error("Error initializing keyboard handler");
memset(bindarray,0,256); // no keys bound yet
input.ClipMouse(0,0,vidxres,vidyres);
LogDone();
Logp("Sys: Initializing timer. Set 100hz.");
if (!InitTimer())
Sys_Error("Error initing timer");
LogDone();
/*
Logp("Sys: Initializing CD Audio.");
CD_Init();
LogDone();
*/
Logp("Sys: Initializing music system.");
InitMusicSystem((unsigned int)hWnd);
LogDone();
Logp("Sys: Initializing graphics.");
if (!gfx.Init(hWnd,vidxres, vidyres,hicolour?16:8,fullscreenmode))
Sys_Error("Error initizlizing graphics");
if (!gfx.SetPalette(vergepal))
Sys_Error("Error setting the palette");
LogDone();
}
LRESULT CALLBACK MainWinProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
// Mouse management
// General Win32 type crap
case WM_KEYDOWN: input.Poll();
case WM_KEYUP: input.Poll();
case WM_ACTIVATE: bActive=LOWORD(wParam)!=WA_INACTIVE; // I know it's ugly. Sue me, I'm lazy.
// if (bActive) Log("Re-activating..."); else Log("De-activating");
if (bActive)
{
SoundResume();
// Log("Restore! (activate)");
}
else
{
SoundPause();
// Log("Shutdown! (activate)");
}
return 0;
case WM_ACTIVATEAPP: bActive=(bool)wParam;
// if (bActive) Log("Re-activating..."); else Log("De-activating");
if (bActive)
{
SoundResume();
// Log("Restore! (activateapp)");
}
else
{
SoundPause();
// Log("Shutdown! (activateapp)");
}
InvalidateRect(hWnd,NULL,true);
return 0;
case WM_CLOSE: Sys_Error("");
return 0;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
//#include "dpmi.h"
int WINAPI
WinMain (HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmd, int nShow)
{
WNDCLASSEX wc; // Win32. blarg
/* if (1 == argc) {
printf("VERGE v.%s build %s at %s. \n",VERSION,__DATE__,__TIME__);
printf("Copyright (C)1998 vecna \n");
delay(500);
}*/
InitLog();
srand(timeGetTime());
// ---Directly from the DOS version -- used to be in VERGE.CPP but it fits here better. --tSB
InitializeDefaults();
ParseStartupFiles();
// set up and register window class
ZeroMemory(&wc,sizeof wc);
wc.cbSize=sizeof wc;
wc.style = 0;
wc.lpfnWndProc = MainWinProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInst;
wc.hIcon = LoadIcon( hInst, "AppIcon");
wc.hCursor = LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = NAME;
wc.cbClsExtra=0;
wc.cbWndExtra=0;
RegisterClassEx( &wc );
// Create it!
hWnd = CreateWindowEx(
0,
NAME,
TITLE,
0,//WS_SYSMENU,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
HWND_DESKTOP,
NULL,
hInst,
NULL );
ShowWindow(hWnd,nShow);
SetFocus(hWnd);
// ShowCursor(false);
InitSystems(hInst);
bActive=true;
return VMain();
}
| [
"overkill9999@gmail.com"
] | overkill9999@gmail.com |
0b152840f13734809f4b03daa3cd1c8620a131c9 | d0ab2cf17852953f57c4b7ee3e724d742f790d0a | /Graphics Programming with Shaders/Week6 - Render to Texture/Example6_RenderTexture/Example6_RenderTexture/App1.cpp | b1147be1a2628da08d66fab05e36ccfc9eaa9cdf | [] | no_license | d4ngus1/Graphics2018 | 4888137377482b673527cde2901d58f797900419 | ebe1613d62b2fa711a0df7c796b8305ee6f7960f | refs/heads/master | 2021-10-01T18:09:59.096794 | 2018-11-27T20:19:35 | 2018-11-27T20:19:35 | 159,210,759 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,183 | cpp | // Lab1.cpp
// Lab 1 example, simple coloured triangle mesh
#include "App1.h"
App1::App1()
{
}
void App1::init(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight, Input *in, bool VSYNC, bool FULL_SCREEN)
{
// Call super/parent init function (required!)
BaseApplication::init(hinstance, hwnd, screenWidth, screenHeight, in, VSYNC, FULL_SCREEN);
// Create Mesh object and shader object
textureMgr->loadTexture("brick", L"res/brick1.dds");
cubeMesh = new CubeMesh(renderer->getDevice(), renderer->getDeviceContext());
orthoMesh = new OrthoMesh(renderer->getDevice(), renderer->getDeviceContext(), screenWidth / 4, screenHeight / 4, -screenWidth / 2.7, screenHeight / 2.7);
orthoSphereMesh = new OrthoMesh(renderer->getDevice(), renderer->getDeviceContext(), screenWidth / 4, screenHeight / 4, 440, screenHeight / 2.7);
sphereMesh = new SphereMesh(renderer->getDevice(), renderer->getDeviceContext());
lightShader = new LightShader(renderer->getDevice(), hwnd);
textureShader = new TextureShader(renderer->getDevice(), hwnd);
renderTexture = new RenderTexture(renderer->getDevice(), screenWidth, screenHeight, SCREEN_NEAR, SCREEN_DEPTH);
sphereTexture = new RenderTexture(renderer->getDevice(), screenWidth, screenHeight, SCREEN_NEAR, SCREEN_DEPTH);
birdeyeCamera = new Camera;
birdeyeCamera->setPosition(0.0f, 5.0f, -4.0f);
birdeyeCamera->setRotation(0.0f, 0.0f, 50.0f);
sphereCamera = new Camera;
sphereCamera->setPosition(0.0f, 5.0f, -4.0f);
sphereCamera->setRotation(0.0f, 0.0f, 50.0f);
light = new Light;
light->setAmbientColour(0.0f, 0.0f, 0.0f, 1.0f);
light->setDiffuseColour(1.0f, 1.0f, 1.0f, 1.0f);
light->setDirection(0.7f, 0.0f, 0.7f);
}
App1::~App1()
{
// Run base application deconstructor
BaseApplication::~BaseApplication();
// Release the Direct3D object.
}
bool App1::frame()
{
bool result;
result = BaseApplication::frame();
if (!result)
{
return false;
}
// Render the graphics.
result = render();
if (!result)
{
return false;
}
return true;
}
bool App1::render()
{
// Render first pass to render texture
firstPass();
secondPass();
// Render final pass to frame buffer
finalPass();
return true;
}
void App1::firstPass()
{
// Set the render target to be the render to texture and clear it
renderTexture->setRenderTarget(renderer->getDeviceContext());
renderTexture->clearRenderTarget(renderer->getDeviceContext(), 1.0f, 0.0f, 0.0f, 1.0f);
// Get matrices
birdeyeCamera->update();
XMMATRIX worldMatrix = renderer->getWorldMatrix();
XMMATRIX viewMatrix = birdeyeCamera->getViewMatrix();
XMMATRIX projectionMatrix = renderer->getProjectionMatrix();
// Render shape with simple lighting shader set.
cubeMesh->sendData(renderer->getDeviceContext());
lightShader->setShaderParameters(renderer->getDeviceContext(), worldMatrix, viewMatrix, projectionMatrix, textureMgr->getTexture("default"), light);
lightShader->render(renderer->getDeviceContext(), cubeMesh->getIndexCount());
// Reset the render target back to the original back buffer and not the render to texture anymore.
renderer->setBackBufferRenderTarget();
}
void App1::secondPass()
{
// Set the render target to be the render to texture and clear it
sphereTexture->setRenderTarget(renderer->getDeviceContext());
sphereTexture->clearRenderTarget(renderer->getDeviceContext(), 1.0f, 0.0f, 0.0f, 1.0f);
// Get matrices
sphereCamera->update();
XMMATRIX worldMatrix = renderer->getWorldMatrix();
XMMATRIX viewMatrix = sphereCamera->getViewMatrix();
XMMATRIX projectionMatrix = renderer->getProjectionMatrix();
// Render shape with simple lighting shader set.
sphereMesh->sendData(renderer->getDeviceContext());
lightShader->setShaderParameters(renderer->getDeviceContext(), worldMatrix, viewMatrix, projectionMatrix, textureMgr->getTexture("default"), light);
lightShader->render(renderer->getDeviceContext(), sphereMesh->getIndexCount());
// Reset the render target back to the original back buffer and not the render to texture anymore.
renderer->setBackBufferRenderTarget();
}
void App1::finalPass()
{
// Clear the scene. (default blue colour)
renderer->beginScene(0.39f, 0.58f, 0.92f, 1.0f);
// Get matrices
camera->update();
XMMATRIX worldMatrix = renderer->getWorldMatrix();
XMMATRIX viewMatrix = camera->getViewMatrix();
XMMATRIX projectionMatrix = renderer->getProjectionMatrix();
// Render normal scene, with light shader set.
cubeMesh->sendData(renderer->getDeviceContext());
lightShader->setShaderParameters(renderer->getDeviceContext(), worldMatrix, viewMatrix, projectionMatrix, textureMgr->getTexture("brick"), light);
lightShader->render(renderer->getDeviceContext(), cubeMesh->getIndexCount());
// RENDER THE RENDER TEXTURE SCENE
// Requires 2D rendering and an ortho mesh.
renderer->setZBuffer(false);
XMMATRIX orthoMatrix = renderer->getOrthoMatrix(); // ortho matrix for 2D rendering
XMMATRIX orthoViewMatrix = camera->getOrthoViewMatrix(); // Default camera position for orthographic rendering
orthoMesh->sendData(renderer->getDeviceContext());
textureShader->setShaderParameters(renderer->getDeviceContext(), worldMatrix, orthoViewMatrix, orthoMatrix, renderTexture->getShaderResourceView());
textureShader->render(renderer->getDeviceContext(), orthoMesh->getIndexCount());
//new
orthoSphereMesh->sendData(renderer->getDeviceContext());
textureShader->setShaderParameters(renderer->getDeviceContext(), worldMatrix, orthoViewMatrix, orthoMatrix, sphereTexture->getShaderResourceView());
textureShader->render(renderer->getDeviceContext(), orthoSphereMesh->getIndexCount());
renderer->setZBuffer(true);
// Render GUI
gui();
// Present the rendered scene to the screen.
renderer->endScene();
}
void App1::gui()
{
// Force turn off unnecessary shader stages.
renderer->getDeviceContext()->GSSetShader(NULL, NULL, 0);
renderer->getDeviceContext()->HSSetShader(NULL, NULL, 0);
renderer->getDeviceContext()->DSSetShader(NULL, NULL, 0);
// Build UI
ImGui::Text("FPS: %.2f", timer->getFPS());
ImGui::Checkbox("Wireframe mode", &wireframeToggle);
// Render UI
ImGui::Render();
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
}
| [
"deanangus1@gmail.com"
] | deanangus1@gmail.com |
76aa529f40d2e13cedf0b295c66b953547717ddc | 77409ad5d4fd79d98f8dab385205cb4a6fbb45eb | /Code/Tools/OctreeBuilder/EntryPoint.cpp | b310014cc8e6ca3d9827cbfbd6587ddc65ea32df | [] | no_license | MuraliMohanRanganath/3DGameEngine | 78ab56072f86a8d11efac0dc6246a406bb4cf2c0 | 25ce991b2e484c7f563ce1a95c08d13d54ab1fdd | refs/heads/master | 2020-03-18T13:59:36.914398 | 2018-05-25T07:49:40 | 2018-05-25T07:49:40 | 134,822,792 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 322 | cpp | /*
The main() function is where the program starts execution
*/
// Header Files
//=============
#include "cOctreeDataBuilder.h"
// Entry Point
//============
int main(int i_argumentCount, char** i_arguments)
{
return eae6320::AssetBuild::Build<eae6320::AssetBuild::cOctreeDataBuilder>(i_arguments, i_argumentCount);
} | [
"muralimohan.ranganath@gmail.com"
] | muralimohan.ranganath@gmail.com |
e7a70e6cec7cb1dd56fd769ab3bb31463d740d37 | 367a7727c6db47c725d7fdda86c47936e0d8c16e | /mat.cpp | b0ceba9c0eeb9467821ec52cf5af710cb389587a | [] | no_license | bush-man92/markovujcic-bootcamp | 7191234c8848127f4bd2c23fcde00aa39db31c55 | 8dd2e141a09a6b3204a8659c370006142eb41c3b | refs/heads/master | 2020-04-08T11:16:44.901635 | 2019-01-19T15:53:38 | 2019-01-19T15:53:38 | 159,299,902 | 0 | 0 | null | 2018-11-27T08:54:21 | 2018-11-27T08:17:03 | null | UTF-8 | C++ | false | false | 253 | cpp | #include <iostream>
#include <iomanip>
using namespace std;
int zbroji(int x, int y) {
return x + y;
}
int oduzmi(int x, int y) {
return x - y;
}
int pomnozi(int x, int y) {
return x * y;
}
float podijeli(int x, int y) {
return float(x) / y;
}
| [
"42248918+bush-man92@users.noreply.github.com"
] | 42248918+bush-man92@users.noreply.github.com |
19016cdb800565e823ae7db02c86362ca3219032 | 2e40f11fa5abb4850882f333f656966265da682e | /Maze/Maze/DisjointSet.h | e64ab616f237c76b3edeeaa32ce9b306c24f826a | [] | no_license | jmd1011/Maze | a614d2a7beb4f346f8755172d572bdcac2bad3d7 | 50f2f515db2b190e572ade733d2c0865dae3e8b7 | refs/heads/master | 2016-09-15T18:09:03.417602 | 2013-07-16T02:02:57 | 2013-07-16T02:02:57 | 11,438,374 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,039 | h | #ifndef Maze_DisjointSet_h
#define Maze_DisjointSet_h
using namespace std;
class DisjointSet{
int* sets;
int numSets;
public:
DisjointSet(int size){
numSets=size;
sets=new int[size];
for(int i=0; i<size; i++)
sets[i]=-1;
}
~DisjointSet()
{
delete[] sets;
}
bool isOneSet()
{
return numSets == 1;
}
//finds the parent and performs path compression
int find(int box)
{
if (sets[box] < 0)
{
return box;
}
sets[box] = find(sets[box]);
return find(sets[box]);
}
//unions the two sets by rank, the parent with the larger estimated height becomes the root
bool unionByRank(int box1, int box2)
{
int temp1 = find(box1), temp2 = find(box2);
if (temp1 == temp2)
return false;
if (temp1 < temp2)
{
sets[temp2] = temp1;
sets[temp1]--;
}
else
{
sets[temp1] = temp2;
sets[temp2]--;
}
numSets--;//only do this if the union succeeds
return true;
}
};
#endif
| [
"james.m.decker@aggiemail.usu.edu"
] | james.m.decker@aggiemail.usu.edu |
bde0592950ddf517ca63fdc81dd487e26eecc70d | 87f0f7f5488bdbd95a6cfc50ce067863bfb5f1e8 | /fountainCircle.cpp | 4859647b589a2efe1584c847e18b19a37d3953be | [] | no_license | minamiliu/Time_To_Shoot | d0f1e321cb527a9958424c4b5e4d4193845ceadb | 09c668834374e7ade5d92c89f824164204172384 | refs/heads/master | 2021-01-10T06:39:29.449559 | 2016-11-22T02:05:46 | 2016-11-22T02:05:46 | 54,728,361 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 7,109 | cpp | /*******************************************************************************
*
* ใฟใคใใซ: ๅดๆฐดใฎใขใใซใฎ่กจ็คบๅฆ็
* ใใญใฐใฉใ ๅ: fountainCircle.cpp
* ไฝๆ่
: HALๆฑไบฌใฒใผใ ๅญฆ็งใๅๅๅฎ
*
*******************************************************************************/
/*******************************************************************************
* ใคใณใฏใซใผใใใกใคใซ
*******************************************************************************/
#include "fountainCircle.h"
#include "debugproc.h"
#include "input.h"
//*****************************************************************************
// ใใฏใญๅฎ็พฉ
//*****************************************************************************
#define NUM_VERTEX (4)
#define NUM_POLYGON (2)
#define MODEL_PLANE "data/MODEL/fountain.x" // ่ชญใฟ่พผใXใใกใคใซๅ
#define VALUE_MOVE (5.0f) // ็งปๅ้
#define VALUE_ROTATE (D3DX_PI * 0.1f) // ๅ่ปข้
#define MODEL_POS_X (-700)
#define MODEL_POS_Y (5)
#define MODEL_POS_Z (200)
#define MODEL_SPHERE (20)
//*****************************************************************************
// ใใญใใฟใคใๅฎฃ่จ
//*****************************************************************************
//*****************************************************************************
// ใฐใญใผใใซๅคๆฐ
//*****************************************************************************
FOUNTAIN_CIRCLE g_FountainCircle;
//=============================================================================
// ๅๆๅๅฆ็
//=============================================================================
HRESULT InitFountainCircle(void)
{
LPDIRECT3DDEVICE9 pDevice = GetDevice();
// ไฝ็ฝฎใปๅ่ปขใปในใฑใผใซใฎๅๆ่จญๅฎ
g_FountainCircle.pos = D3DXVECTOR3( MODEL_POS_X, MODEL_POS_Y, MODEL_POS_Z);
g_FountainCircle.rot = D3DXVECTOR3( 0.0f, 0.0f, 0.0f);
g_FountainCircle.scl = D3DXVECTOR3( 10.0f, 5.0f, 10.0f);
g_FountainCircle.move = D3DXVECTOR3( VALUE_MOVE, VALUE_MOVE, 0.0f);
g_FountainCircle.rotAngle = D3DXVECTOR3( 0.0f, 0.0f, 0.0f);
g_FountainCircle.rotTarget = D3DXVECTOR3( 0.0f, 0.0f, 0.0f);
g_FountainCircle.fRadius = 150.0f;
g_FountainCircle.bUse = true;
// ใขใใซใซ้ขใใๅคๆฐใฎๅๆๅ
g_FountainCircle.pD3DXMesh = NULL; // ใกใใทใฅๆ
ๅ ฑใธใฎใใคใณใฟ
g_FountainCircle.pD3DXBuffMat = NULL; // ใใใชใขใซๆ
ๅ ฑใธใฎใใคใณใฟ
g_FountainCircle.nNumMat = 0; // ใใใชใขใซๆ
ๅ ฑใฎๆฐ
// Xใใกใคใซใฎ่ชญใฟ่พผใฟ
if(FAILED(D3DXLoadMeshFromX(
MODEL_PLANE, // ่ชญใฟ่พผใใขใใซใใกใคใซๅ(Xใใกใคใซ)
D3DXMESH_SYSTEMMEM, // ใกใใทใฅใฎไฝๆใชใใทใงใณใๆๅฎ
pDevice, // IDirect3DDevice9ใคใณใฟใผใใงใคในใธใฎใใคใณใฟ
NULL, // ้ฃๆฅๆงใใผใฟใๅซใใใใใกใธใฎใใคใณใฟ
&g_FountainCircle.pD3DXBuffMat, // ใใใชใขใซใใผใฟใๅซใใใใใกใธใฎใใคใณใฟ
NULL, // ใจใใงใฏใใคใณในใฟใณในใฎ้
ๅใๅซใใใใใกใธใฎใใคใณใฟ
&g_FountainCircle.nNumMat, // D3DXMATERIALๆง้ ไฝใฎๆฐ
&g_FountainCircle.pD3DXMesh // ID3DXMeshใคใณใฟใผใใงใคในใธใฎใใคใณใฟใฎใขใใฌใน
)))
{
return E_FAIL;
}
//ใใฏในใใฃใธใฎใใคใณใฟใฎๅๆๅ
for(int nCntMat = 0; nCntMat < MAX_D3D_MAT; nCntMat++)
{
g_FountainCircle.pD3DTexture[nCntMat] = NULL; // ใใฏในใใฃใธใฎใใคใณใฟ
}
// ใใใชใขใซๆ
ๅ ฑใซๅฏพใใใใคใณใฟใๅๅพ
D3DXMATERIAL *pD3DXMat = (D3DXMATERIAL *)g_FountainCircle.pD3DXBuffMat->GetBufferPointer();
if((int)g_FountainCircle.nNumMat <= MAX_D3D_MAT)
{
for(int nCntMat = 0; nCntMat < (int)g_FountainCircle.nNumMat; nCntMat++)
{
// ใใฏในใใฃใฎ่ชญใฟ่พผใฟ
D3DXCreateTextureFromFile( pDevice, pD3DXMat[nCntMat].pTextureFilename, &g_FountainCircle.pD3DTexture[nCntMat]);
}
}
return S_OK;
}
//=============================================================================
// ็ตไบๅฆ็
//=============================================================================
void UninitFountainCircle(void)
{
// ใใฏในใใฃใฎ้ๆพ
for(int nCntMat = 0; nCntMat < MAX_D3D_MAT; nCntMat++)
{
if(g_FountainCircle.pD3DTexture[nCntMat] != NULL)
{
g_FountainCircle.pD3DTexture[nCntMat]->Release();
g_FountainCircle.pD3DTexture[nCntMat] = NULL;
}
}
// ใกใใทใฅใฎ้ๆพ
if(g_FountainCircle.pD3DXMesh != NULL)
{
g_FountainCircle.pD3DXMesh->Release();
g_FountainCircle.pD3DXMesh = NULL;
}
// ใใใชใขใซใฎ้ๆพ
if(g_FountainCircle.pD3DXBuffMat != NULL)
{
g_FountainCircle.pD3DXBuffMat->Release();
g_FountainCircle.pD3DXBuffMat = NULL;
}
g_FountainCircle.bUse = false;
}
//=============================================================================
// ๆดๆฐๅฆ็
//=============================================================================
void UpdateFountainCircle(void)
{
}
//=============================================================================
// ๆ็ปๅฆ็
//=============================================================================
void DrawFountainCircle(void)
{
if(!g_FountainCircle.bUse) return ;
LPDIRECT3DDEVICE9 pDevice = GetDevice();
D3DXMATRIX mtxScl, mtxRot, mtxTranslate;
D3DXMATERIAL *pD3DXMat;
D3DMATERIAL9 matDef;
// ใฏใผใซใใใใชใใฏในใฎๅๆๅ
D3DXMatrixIdentity( &g_FountainCircle.mtxWorld);
// ในใฑใผใซใๅๆ
D3DXMatrixScaling( &mtxScl, g_FountainCircle.scl.x, g_FountainCircle.scl.y, g_FountainCircle.scl.z);
D3DXMatrixMultiply( &g_FountainCircle.mtxWorld, &g_FountainCircle.mtxWorld, &mtxScl);
// ๅ่ปขใๅๆ
D3DXMatrixRotationYawPitchRoll( &mtxRot, g_FountainCircle.rot.y, g_FountainCircle.rot.x, g_FountainCircle.rot.z);
D3DXMatrixMultiply( &g_FountainCircle.mtxWorld, &g_FountainCircle.mtxWorld, &mtxRot);
// ็งปๅใๅๆ
D3DXMatrixTranslation( &mtxTranslate, g_FountainCircle.pos.x, g_FountainCircle.pos.y, g_FountainCircle.pos.z);
D3DXMatrixMultiply( &g_FountainCircle.mtxWorld, &g_FountainCircle.mtxWorld, &mtxTranslate);
// ใฏใผใซใใใใชใใฏในใฎ่จญๅฎ
pDevice->SetTransform( D3DTS_WORLD, &g_FountainCircle.mtxWorld);
// ็พๅจใฎใใใชใขใซใๅๅพ
pDevice->GetMaterial(&matDef);
// ใใใชใขใซๆ
ๅ ฑใซๅฏพใใใใคใณใฟใๅๅพ
pD3DXMat = (D3DXMATERIAL *)g_FountainCircle.pD3DXBuffMat->GetBufferPointer();
for(int nCntMat = 0; nCntMat < (int)g_FountainCircle.nNumMat; nCntMat++)
{
// ใใใชใขใซใฎ่จญๅฎ
pDevice->SetMaterial( &pD3DXMat[nCntMat].MatD3D);
// ใใฏในใใฃใฎ่จญๅฎ
pDevice->SetTexture( 0, g_FountainCircle.pD3DTexture[nCntMat]);
// ๆ็ป
g_FountainCircle.pD3DXMesh->DrawSubset( nCntMat);
}
// ใใใชใขใซใใใใฉใซใใซๆปใ
pDevice->SetMaterial( &matDef);
}
//=============================================================================
// ใขใใซใฎๅๅพ
//=============================================================================
FOUNTAIN_CIRCLE *GetFountainCircle(void)
{
return &g_FountainCircle;
}
| [
"josong04@gmail.com"
] | josong04@gmail.com |
e9e3de1908c6e16554cbda84f9f31b10820d3468 | ac34cad5e20b8f46c0b0aa67df829f55ed90dcb6 | /src/ballistica/ui_v1/widget/h_scroll_widget.h | 5655fab463c955bc97fa74af5f831cf693644f74 | [
"MIT"
] | permissive | sudo-logic/ballistica | fd3bf54a043717f874b71f4b2ccd551d61c65008 | 9aa73cd20941655e96b0e626017a7395ccb40062 | refs/heads/master | 2023-07-26T19:52:06.113981 | 2023-07-12T21:32:56 | 2023-07-12T21:37:46 | 262,056,617 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,499 | h | // Released under the MIT License. See LICENSE for details.
#ifndef BALLISTICA_UI_V1_WIDGET_H_SCROLL_WIDGET_H_
#define BALLISTICA_UI_V1_WIDGET_H_SCROLL_WIDGET_H_
#include <string>
#include "ballistica/ui_v1/widget/container_widget.h"
namespace ballistica::ui_v1 {
// A scroll-box container widget.
class HScrollWidget : public ContainerWidget {
public:
HScrollWidget();
~HScrollWidget() override;
void Draw(base::RenderPass* pass, bool transparent) override;
auto HandleMessage(const base::WidgetMessage& m) -> bool override;
auto GetWidgetTypeName() -> std::string override { return "scroll"; }
void set_capture_arrows(bool val) { capture_arrows_ = val; }
void SetWidth(float w) override {
trough_dirty_ = shadow_dirty_ = glow_dirty_ = thumb_dirty_ = true;
set_width(w);
MarkForUpdate();
}
void SetHeight(float h) override {
trough_dirty_ = shadow_dirty_ = glow_dirty_ = thumb_dirty_ = true;
set_height(h);
MarkForUpdate();
}
void SetCenterSmallContent(bool val) {
center_small_content_ = val;
MarkForUpdate();
}
void OnTouchDelayTimerExpired();
void setColor(float r, float g, float b) {
color_red_ = r;
color_green_ = g;
color_blue_ = b;
}
void set_highlight(bool val) { highlight_ = val; }
auto highlight() const -> bool { return highlight_; }
void setBorderOpacity(float val) { border_opacity_ = val; }
auto getBorderOpacity() const -> float { return border_opacity_; }
protected:
void UpdateLayout() override;
private:
void ClampThumb(bool velocity_clamp, bool position_clamp);
bool touch_mode_{};
float color_red_{0.55f};
float color_green_{0.47f};
float color_blue_{0.67f};
bool has_momentum_{true};
bool trough_dirty_{true};
bool shadow_dirty_{true};
bool glow_dirty_{true};
bool thumb_dirty_{true};
millisecs_t last_velocity_event_time_millisecs_{};
float touch_fade_{};
bool center_small_content_{};
float center_offset_x_{};
bool touch_held_{};
int touch_held_click_count_{};
float touch_down_x_{};
float touch_x_{};
float touch_y_{};
float touch_start_x_{};
float touch_start_y_{};
bool touch_is_scrolling_{};
bool touch_down_sent_{};
bool touch_up_sent_{};
bool new_scroll_touch_{};
float trough_width_{};
float trough_height_{};
float trough_center_x_{};
float trough_center_y_{};
float thumb_width_{}, thumb_height_{}, thumb_center_x_{}, thumb_center_y_{};
float smoothing_amount_{1.0f};
bool highlight_{true};
float glow_width_{};
float glow_height_{};
float glow_center_x_{};
float glow_center_y_{};
float outline_width_{};
float outline_height_{};
float outline_center_x_{};
float outline_center_y_{};
float border_opacity_{1.0f};
bool capture_arrows_{};
bool mouse_held_scroll_down_{};
bool mouse_held_scroll_up_{};
bool mouse_held_thumb_{};
float thumb_click_start_h_{};
float thumb_click_start_child_offset_h_{};
bool mouse_held_page_down_{};
bool mouse_held_page_up_{};
bool mouse_over_thumb_{};
bool mouse_over_{};
float scroll_bar_height_{10.0f};
float border_width_{2.0f};
float border_height_{2.0f};
float child_offset_h_{-9999.0f};
float child_offset_h_smoothed_{};
float child_max_offset_{};
float amount_visible_{};
bool have_drawn_{};
millisecs_t inertia_scroll_update_time_{};
float inertia_scroll_rate_{};
Object::Ref<base::AppTimer> touch_delay_timer_;
};
} // namespace ballistica::ui_v1
#endif // BALLISTICA_UI_V1_WIDGET_H_SCROLL_WIDGET_H_
| [
"ericfroemling@gmail.com"
] | ericfroemling@gmail.com |
a07639f365d9295a008cac128842ad2b38c8ec80 | 17f37b79643b9c6acd181c55c43a3ab4c889433e | /cavity/9.5/uniform/time | 63d7848b756bec6c48ae0e6f18bb7dde4500398c | [] | no_license | aashay201297/OpenFOAM-simulations | 5208b766ab1e715178e42c73d028cc43d17ec4c9 | 273f60ef66e6f5b0c99a53ac52de406be0e876a2 | refs/heads/master | 2021-01-23T06:34:17.044650 | 2017-06-04T19:02:27 | 2017-06-04T19:02:27 | 86,373,858 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 993 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "9.5/uniform";
object time;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
value 9.50000000000008527;
name "9.5";
index 1900;
deltaT 0.005;
deltaT0 0.005;
// ************************************************************************* //
| [
"aashay225@gmail.com"
] | aashay225@gmail.com | |
942ec0b5c4aa691cec1e2af2e9786f78f8710390 | fd48cf29ad132689488a0253a4e7d3c233320fa5 | /chapter7/0123/Prob07_2/check.cpp | d456621f2ec0e37bc71fa7052032fb3bcc2ab091 | [] | no_license | anorange7417/C_CPP-study | 4c4df20d2e96b7b052d74df8ab7d1290dd144246 | 14dca54b4020639b003dd489beb5e9711a07082a | refs/heads/master | 2020-12-05T02:54:54.787403 | 2020-01-29T06:12:53 | 2020-01-29T06:12:53 | 231,988,871 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 264 | cpp | #include <cstring>
#include <iostream>
using namespace std;
int main()
{
char *nameptr;
char name[20];
strcpy(nameptr, "cho");
// strcpy(name, "cho");
cout << "nameptr: " << nameptr << endl;
// << "name: " << name << endl;
return 0;
} | [
"201929291@snu.ac.kr"
] | 201929291@snu.ac.kr |
ae5e8438e151fdbfdfd031ee85fc4838e1f87606 | fae551eb54ab3a907ba13cf38aba1db288708d92 | /chrome/browser/ash/system_extensions/system_extensions_provider.cc | b8f1db6aae3f1342c00ed7d04a19c21eef563af0 | [
"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 | 913 | 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 "chrome/browser/ash/system_extensions/system_extensions_provider.h"
#include "chrome/browser/ash/system_extensions/system_extensions_install_manager.h"
#include "chrome/browser/ash/system_extensions/system_extensions_provider_factory.h"
#include "chrome/browser/ash/system_extensions/system_extensions_web_ui_config_map.h"
// static
SystemExtensionsProvider* SystemExtensionsProvider::Get(Profile* profile) {
return SystemExtensionsProviderFactory::GetForProfileIfExists(profile);
}
SystemExtensionsProvider::SystemExtensionsProvider() {
SystemExtensionsWebUIConfigMap::RegisterInstance();
install_manager_ = std::make_unique<SystemExtensionsInstallManager>();
}
SystemExtensionsProvider::~SystemExtensionsProvider() = default;
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
13a64aa690d2369e8208a057844a67606b4f431f | e222e5be832442abac5545236277671fea56a1d1 | /externals/boost/boost/stacktrace/detail/frame_decl.hpp | 9bd140735f0260120094e05239e3c629abce0b30 | [
"MIT"
] | permissive | YuukiTsuchida/v8_embeded | c28e208b6b4b73c41d0a5c81aeca71d1111c635c | c6e18f4e91fcc50607f8e3edc745a3afa30b2871 | refs/heads/master | 2020-12-31T22:56:33.725884 | 2020-11-10T04:00:12 | 2020-11-10T04:00:12 | 239,064,117 | 0 | 0 | MIT | 2020-05-20T08:24:54 | 2020-02-08T03:39:19 | C++ | UTF-8 | C++ | false | false | 5,228 | hpp | // Copyright Antony Polukhin, 2016-2018.
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_STACKTRACE_DETAIL_FRAME_DECL_HPP
#define BOOST_STACKTRACE_DETAIL_FRAME_DECL_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#include <iosfwd>
#include <string>
#include <boost/core/explicit_operator_bool.hpp>
#include <boost/stacktrace/safe_dump_to.hpp> // boost::stacktrace::detail::native_frame_ptr_t
#include <boost/stacktrace/detail/void_ptr_cast.hpp>
#include <boost/stacktrace/detail/push_options.h>
/// @file boost/stacktrace/detail/frame_decl.hpp
/// Use <boost/stacktrace/frame.hpp> header instead of this one!
namespace boost { namespace stacktrace {
/// @class boost::stacktrace::frame boost/stacktrace/detail/frame_decl.hpp <boost/stacktrace/frame.hpp>
/// @brief Class that stores frame/function address and can get information about it at runtime.
class frame {
public:
typedef boost::stacktrace::detail::native_frame_ptr_t native_frame_ptr_t;
private:
/// @cond
native_frame_ptr_t addr_;
/// @endcond
public:
/// @brief Constructs frame that references NULL address.
/// Calls to source_file() and source_line() will return empty string.
/// Calls to source_line() will return 0.
///
/// @b Complexity: O(1).
///
/// @b Async-Handler-Safety: Safe.
/// @throws Nothing.
BOOST_CONSTEXPR frame() BOOST_NOEXCEPT
: addr_(0)
{}
#ifdef BOOST_STACKTRACE_DOXYGEN_INVOKED
/// @brief Copy constructs frame.
///
/// @b Complexity: O(1).
///
/// @b Async-Handler-Safety: Safe.
/// @throws Nothing.
constexpr frame(const frame&) = default;
/// @brief Copy assigns frame.
///
/// @b Complexity: O(1).
///
/// @b Async-Handler-Safety: Safe.
/// @throws Nothing.
constexpr frame& operator=(const frame&) = default;
#endif
/// @brief Constructs frame that references addr and could later generate information about that address using platform specific features.
///
/// @b Complexity: O(1).
///
/// @b Async-Handler-Safety: Safe.
/// @throws Nothing.
BOOST_CONSTEXPR explicit frame(native_frame_ptr_t addr) BOOST_NOEXCEPT
: addr_(addr)
{}
/// @brief Constructs frame that references function_addr and could later generate information about that function using platform specific features.
///
/// @b Complexity: O(1).
///
/// @b Async-Handler-Safety: Safe.
/// @throws Nothing.
template <class T>
explicit frame(T* function_addr) BOOST_NOEXCEPT
: addr_(boost::stacktrace::detail::void_ptr_cast<native_frame_ptr_t>(function_addr))
{}
/// @returns Name of the frame (function name in a human readable form).
///
/// @b Complexity: unknown (lots of platform specific work).
///
/// @b Async-Handler-Safety: Unsafe.
/// @throws std::bad_alloc if not enough memory to construct resulting string.
BOOST_STACKTRACE_FUNCTION std::string name() const;
/// @returns Address of the frame function.
///
/// @b Complexity: O(1).
///
/// @b Async-Handler-Safety: Safe.
/// @throws Nothing.
BOOST_CONSTEXPR native_frame_ptr_t address() const BOOST_NOEXCEPT {
return addr_;
}
/// @returns Path to the source file, were the function of the frame is defined. Returns empty string
/// if this->source_line() == 0.
/// @throws std::bad_alloc if not enough memory to construct resulting string.
///
/// @b Complexity: unknown (lots of platform specific work).
///
/// @b Async-Handler-Safety: Unsafe.
BOOST_STACKTRACE_FUNCTION std::string source_file() const;
/// @returns Code line in the source file, were the function of the frame is defined.
/// @throws std::bad_alloc if not enough memory to construct string for internal needs.
///
/// @b Complexity: unknown (lots of platform specific work).
///
/// @b Async-Handler-Safety: Unsafe.
BOOST_STACKTRACE_FUNCTION std::size_t source_line() const;
/// @brief Checks that frame is not references NULL address.
/// @returns `true` if `this->address() != 0`
///
/// @b Complexity: O(1)
///
/// @b Async-Handler-Safety: Safe.
BOOST_EXPLICIT_OPERATOR_BOOL()
/// @brief Checks that frame references NULL address.
/// @returns `true` if `this->address() == 0`
///
/// @b Complexity: O(1)
///
/// @b Async-Handler-Safety: Safe.
BOOST_CONSTEXPR bool empty() const BOOST_NOEXCEPT { return !address(); }
/// @cond
BOOST_CONSTEXPR bool operator!() const BOOST_NOEXCEPT { return !address(); }
/// @endcond
};
namespace detail {
BOOST_STACKTRACE_FUNCTION std::string to_string(const frame* frames, std::size_t size);
} // namespace detail
}} // namespace boost::stacktrace
#include <boost/stacktrace/detail/pop_options.h>
#endif // BOOST_STACKTRACE_DETAIL_FRAME_DECL_HPP
| [
"dev.yuukitsuchida@gmail.com"
] | dev.yuukitsuchida@gmail.com |
9308419c858feee834d17acf81ff1f2432b4a085 | bb7016eb6b46f719f4398aca888b3f41ba846273 | /PBTForSCXT/hundsunPBTAgent/XtAgentCSV.h | 4aee7510b34696d90f8a232eb50ca38cd883b480 | [] | no_license | qiuyifan/XtPBTCodeWarehouse | a09111d52a59825c3f0b704334b99238fe405ad3 | c7f77b6c775fefed2adb55572b8906c1028e0323 | refs/heads/master | 2021-09-15T00:48:38.861540 | 2018-05-23T06:43:39 | 2018-05-23T06:43:39 | 112,569,979 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,049 | h | ๏ปฟ#ifndef XT_AGENT_CSVAPI_H
#define XT_AGENT_CSVAPI_H
#include "common/Stdafx.h"
#include <boost/filesystem.hpp>
#include "utils/BsonHelper.h"
#include "XtAgentMatchDef.h"
#include "XtAgentError.h"
namespace bson
{
class BSONObj;
typedef bson::BSONObj bo;
class BSONObjBuilder;
typedef bson::BSONObjBuilder bob;
}
namespace agent
{
class XtAgentCSVApi
{
public:
XtAgentCSVApi();
~XtAgentCSVApi();
bool getFuncMatchUnit(FuncMatchUnit& coverFuncUnit, int funcNo);
void loadNamePos(string line , std::map<string , int>& name2pos);
double getPerAmount(string str);
double getAmount(string str);
void genErrMsgData(const string& errMsg, bson::bo& errMsgBson);
bson::bo genData(vector<string>& dataFilesPath, int funcNo, string& strAccountID);
void coverField(vector<string>& lineParm, bson::BSONArrayBuilder& arrayBuilder, int funcNo, std::map<string , int>& name2pos);
string getTime(string str);
};
}
#endif /*XT_AGENT_DBFAPI_H*/ | [
"531987772@qq.com"
] | 531987772@qq.com |
c9eff0db7cc7d837a0a92a0d3621e46fb7bcec85 | da42621568efc5b02d99e273c8dc993b4dacd1d2 | /src/qt/sendcoinsentry.cpp | 8f435933ccf910dc5203bdcca50223cf26c9df27 | [
"MIT"
] | permissive | superstakecoin/sstcoin-core | d4c0e01255899ae8ae3bc29fe8f683a90b205953 | d5eaa15e64d93e494c0976c1660317c5428aca7a | refs/heads/master | 2022-03-14T04:21:11.859969 | 2019-10-31T03:17:31 | 2019-10-31T03:17:31 | 197,853,959 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,453 | cpp | // Copyright (c) 2011-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2018 The PIVX developers
// Copyright (c) 2019 The SuperStakeCoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "sendcoinsentry.h"
#include "ui_sendcoinsentry.h"
#include "addressbookpage.h"
#include "addresstablemodel.h"
#include "guiutil.h"
#include "optionsmodel.h"
#include "walletmodel.h"
#include <QApplication>
#include <QClipboard>
SendCoinsEntry::SendCoinsEntry(QWidget* parent) : QStackedWidget(parent),
ui(new Ui::SendCoinsEntry),
model(0)
{
ui->setupUi(this);
setCurrentWidget(ui->SendCoins);
#ifdef Q_OS_MAC
ui->payToLayout->setSpacing(4);
#endif
#if QT_VERSION >= 0x040700
ui->addAsLabel->setPlaceholderText(tr("Enter a label for this address to add it to your address book"));
#endif
// normal superstakecoin address field
GUIUtil::setupAddressWidget(ui->payTo, this);
// just a label for displaying superstakecoin address(es)
ui->payTo_is->setFont(GUIUtil::bitcoinAddressFont());
// Connect signals
connect(ui->payAmount, SIGNAL(valueChanged()), this, SIGNAL(payAmountChanged()));
connect(ui->deleteButton, SIGNAL(clicked()), this, SLOT(deleteClicked()));
connect(ui->deleteButton_is, SIGNAL(clicked()), this, SLOT(deleteClicked()));
connect(ui->deleteButton_s, SIGNAL(clicked()), this, SLOT(deleteClicked()));
}
SendCoinsEntry::~SendCoinsEntry()
{
delete ui;
}
void SendCoinsEntry::on_pasteButton_clicked()
{
// Paste text from clipboard into recipient field
ui->payTo->setText(QApplication::clipboard()->text());
}
void SendCoinsEntry::on_addressBookButton_clicked()
{
if (!model)
return;
AddressBookPage dlg(AddressBookPage::ForSelection, AddressBookPage::SendingTab, this);
dlg.setModel(model->getAddressTableModel());
if (dlg.exec()) {
ui->payTo->setText(dlg.getReturnValue());
ui->payAmount->setFocus();
}
}
void SendCoinsEntry::on_payTo_textChanged(const QString& address)
{
updateLabel(address);
}
void SendCoinsEntry::setModel(WalletModel* model)
{
this->model = model;
if (model && model->getOptionsModel())
connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
clear();
}
void SendCoinsEntry::clear()
{
// clear UI elements for normal payment
ui->payTo->clear();
ui->addAsLabel->clear();
ui->payAmount->clear();
ui->messageTextLabel->clear();
ui->messageTextLabel->hide();
ui->messageLabel->hide();
// clear UI elements for insecure payment request
ui->payTo_is->clear();
ui->memoTextLabel_is->clear();
ui->payAmount_is->clear();
// clear UI elements for secure payment request
ui->payTo_s->clear();
ui->memoTextLabel_s->clear();
ui->payAmount_s->clear();
// update the display unit, to not use the default ("BTC")
updateDisplayUnit();
}
void SendCoinsEntry::deleteClicked()
{
emit removeEntry(this);
}
bool SendCoinsEntry::validate()
{
if (!model)
return false;
// Check input validity
bool retval = true;
// Skip checks for payment request
if (recipient.paymentRequest.IsInitialized())
return retval;
if (!model->validateAddress(ui->payTo->text())) {
ui->payTo->setValid(false);
retval = false;
}
if (!ui->payAmount->validate()) {
retval = false;
}
// Sending a zero amount is invalid
if (ui->payAmount->value(0) <= 0) {
ui->payAmount->setValid(false);
retval = false;
}
// Reject dust outputs:
if (retval && GUIUtil::isDust(ui->payTo->text(), ui->payAmount->value())) {
ui->payAmount->setValid(false);
retval = false;
}
return retval;
}
SendCoinsRecipient SendCoinsEntry::getValue()
{
// Payment request
if (recipient.paymentRequest.IsInitialized())
return recipient;
// Normal payment
recipient.address = ui->payTo->text();
recipient.label = ui->addAsLabel->text();
recipient.amount = ui->payAmount->value();
recipient.message = ui->messageTextLabel->text();
return recipient;
}
QWidget* SendCoinsEntry::setupTabChain(QWidget* prev)
{
QWidget::setTabOrder(prev, ui->payTo);
QWidget::setTabOrder(ui->payTo, ui->addAsLabel);
QWidget* w = ui->payAmount->setupTabChain(ui->addAsLabel);
QWidget::setTabOrder(w, ui->addressBookButton);
QWidget::setTabOrder(ui->addressBookButton, ui->pasteButton);
QWidget::setTabOrder(ui->pasteButton, ui->deleteButton);
return ui->deleteButton;
}
void SendCoinsEntry::setValue(const SendCoinsRecipient& value)
{
recipient = value;
if (recipient.paymentRequest.IsInitialized()) // payment request
{
if (recipient.authenticatedMerchant.isEmpty()) // insecure
{
ui->payTo_is->setText(recipient.address);
ui->memoTextLabel_is->setText(recipient.message);
ui->payAmount_is->setValue(recipient.amount);
ui->payAmount_is->setReadOnly(true);
setCurrentWidget(ui->SendCoins_InsecurePaymentRequest);
} else // secure
{
ui->payTo_s->setText(recipient.authenticatedMerchant);
ui->memoTextLabel_s->setText(recipient.message);
ui->payAmount_s->setValue(recipient.amount);
ui->payAmount_s->setReadOnly(true);
setCurrentWidget(ui->SendCoins_SecurePaymentRequest);
}
} else // normal payment
{
// message
ui->messageTextLabel->setText(recipient.message);
ui->messageTextLabel->setVisible(!recipient.message.isEmpty());
ui->messageLabel->setVisible(!recipient.message.isEmpty());
ui->addAsLabel->clear();
ui->payTo->setText(recipient.address); // this may set a label from addressbook
if (!recipient.label.isEmpty()) // if a label had been set from the addressbook, dont overwrite with an empty label
ui->addAsLabel->setText(recipient.label);
ui->payAmount->setValue(recipient.amount);
}
}
void SendCoinsEntry::setAddress(const QString& address)
{
ui->payTo->setText(address);
ui->payAmount->setFocus();
}
bool SendCoinsEntry::isClear()
{
return ui->payTo->text().isEmpty() && ui->payTo_is->text().isEmpty() && ui->payTo_s->text().isEmpty();
}
void SendCoinsEntry::setFocus()
{
ui->payTo->setFocus();
}
void SendCoinsEntry::updateDisplayUnit()
{
if (model && model->getOptionsModel()) {
// Update payAmount with the current unit
ui->payAmount->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
ui->payAmount_is->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
ui->payAmount_s->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
}
}
bool SendCoinsEntry::updateLabel(const QString& address)
{
if (!model)
return false;
// Fill in label from address book, if address has an associated label
QString associatedLabel = model->getAddressTableModel()->labelForAddress(address);
if (!associatedLabel.isEmpty()) {
ui->addAsLabel->setText(associatedLabel);
return true;
}
return false;
}
| [
"53101399+superstakecoin@users.noreply.github.com"
] | 53101399+superstakecoin@users.noreply.github.com |
94653c3052e049849251937462cf2bad0796a2e7 | f73cfa6822f0feb9f60e74d3859f7d6e6645ea06 | /USB/Device - HID - Custom Demos/PnP Demo - Cross Platform Software/HID_PnP_Demo/ui_demoapp.h | d30f7fab5d27ef70eba8e0272a2c1b1529d019b1 | [] | no_license | ikalogic/Microchip | 16af7b5b705758251a736ace3c9b2b3219ce32d0 | ae5dabf9a9152953ea46f6de11a2b3c185535117 | refs/heads/master | 2021-01-18T10:30:34.215580 | 2014-01-08T23:29:04 | 2014-01-08T23:29:04 | 51,304,817 | 0 | 1 | null | 2016-02-08T15:07:59 | 2016-02-08T15:07:58 | null | UTF-8 | C++ | false | false | 4,737 | h | /********************************************************************************
** Form generated from reading UI file 'demoapp.ui'
**
** Created: Mon Jan 10 14:34:23 2011
** by: Qt User Interface Compiler version 4.7.0
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_DEMOAPP_H
#define UI_DEMOAPP_H
#include <QtCore/QVariant>
#include <QtGui/QAction>
#include <QtGui/QApplication>
#include <QtGui/QButtonGroup>
#include <QtGui/QHeaderView>
#include <QtGui/QLabel>
#include <QtGui/QLineEdit>
#include <QtGui/QMainWindow>
#include <QtGui/QMenuBar>
#include <QtGui/QProgressBar>
#include <QtGui/QPushButton>
#include <QtGui/QStatusBar>
#include <QtGui/QWidget>
QT_BEGIN_NAMESPACE
class Ui_DemoApp
{
public:
QWidget *centralWidget;
QProgressBar *progressBar;
QPushButton *pushButton;
QLabel *pushbuttonStatus;
QLabel *label_2;
QLabel *label_3;
QLineEdit *deviceConnectedStatus;
QMenuBar *menuBar;
QStatusBar *statusBar;
void setupUi(QMainWindow *DemoApp)
{
if (DemoApp->objectName().isEmpty())
DemoApp->setObjectName(QString::fromUtf8("DemoApp"));
DemoApp->resize(461, 165);
centralWidget = new QWidget(DemoApp);
centralWidget->setObjectName(QString::fromUtf8("centralWidget"));
progressBar = new QProgressBar(centralWidget);
progressBar->setObjectName(QString::fromUtf8("progressBar"));
progressBar->setEnabled(false);
progressBar->setGeometry(QRect(20, 100, 421, 21));
progressBar->setMaximum(1024);
progressBar->setValue(0);
progressBar->setTextVisible(false);
pushButton = new QPushButton(centralWidget);
pushButton->setObjectName(QString::fromUtf8("pushButton"));
pushButton->setEnabled(false);
pushButton->setGeometry(QRect(20, 50, 91, 21));
pushbuttonStatus = new QLabel(centralWidget);
pushbuttonStatus->setObjectName(QString::fromUtf8("pushbuttonStatus"));
pushbuttonStatus->setEnabled(false);
pushbuttonStatus->setGeometry(QRect(200, 50, 231, 20));
pushbuttonStatus->setCursor(QCursor(Qt::ArrowCursor));
pushbuttonStatus->setInputMethodHints(Qt::ImhNone);
pushbuttonStatus->setFrameShadow(QFrame::Plain);
pushbuttonStatus->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter);
label_2 = new QLabel(centralWidget);
label_2->setObjectName(QString::fromUtf8("label_2"));
label_2->setEnabled(false);
label_2->setGeometry(QRect(30, 80, 401, 20));
label_2->setAlignment(Qt::AlignCenter);
label_3 = new QLabel(centralWidget);
label_3->setObjectName(QString::fromUtf8("label_3"));
label_3->setEnabled(true);
label_3->setGeometry(QRect(410, 10, 41, 21));
label_3->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
deviceConnectedStatus = new QLineEdit(centralWidget);
deviceConnectedStatus->setObjectName(QString::fromUtf8("deviceConnectedStatus"));
deviceConnectedStatus->setEnabled(true);
deviceConnectedStatus->setGeometry(QRect(20, 10, 391, 20));
deviceConnectedStatus->setReadOnly(true);
DemoApp->setCentralWidget(centralWidget);
menuBar = new QMenuBar(DemoApp);
menuBar->setObjectName(QString::fromUtf8("menuBar"));
menuBar->setGeometry(QRect(0, 0, 461, 23));
DemoApp->setMenuBar(menuBar);
statusBar = new QStatusBar(DemoApp);
statusBar->setObjectName(QString::fromUtf8("statusBar"));
DemoApp->setStatusBar(statusBar);
retranslateUi(DemoApp);
QMetaObject::connectSlotsByName(DemoApp);
} // setupUi
void retranslateUi(QMainWindow *DemoApp)
{
DemoApp->setWindowTitle(QApplication::translate("DemoApp", "DemoApp", 0, QApplication::UnicodeUTF8));
pushButton->setText(QApplication::translate("DemoApp", "ToggleLED(s)", 0, QApplication::UnicodeUTF8));
pushbuttonStatus->setText(QApplication::translate("DemoApp", "Pushbutton State: Unknown", 0, QApplication::UnicodeUTF8));
label_2->setText(QApplication::translate("DemoApp", "ANx/POT Voltage", 0, QApplication::UnicodeUTF8));
label_3->setText(QApplication::translate("DemoApp", "Status", 0, QApplication::UnicodeUTF8));
deviceConnectedStatus->setText(QApplication::translate("DemoApp", "Device Not Detected: Verify Connection/Correct Firmware", 0, QApplication::UnicodeUTF8));
} // retranslateUi
};
namespace Ui {
class DemoApp: public Ui_DemoApp {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_DEMOAPP_H
| [
"shay.h.maor@gmail.com"
] | shay.h.maor@gmail.com |
977932136d1cc8f6f72653b33bfb1d4415a3f215 | 777a75e6ed0934c193aece9de4421f8d8db01aac | /src/Providers/UNIXProviders/BootServiceAccessBySAP/UNIX_BootServiceAccessBySAP_SOLARIS.hpp | 1167beda73c9902292ead6770064cd45ecb4971c | [
"MIT"
] | permissive | brunolauze/openpegasus-providers-old | 20fc13958016e35dc4d87f93d1999db0eae9010a | b00f1aad575bae144b8538bf57ba5fd5582a4ec7 | refs/heads/master | 2021-01-01T20:05:44.559362 | 2014-04-30T17:50:06 | 2014-04-30T17:50:06 | 19,132,738 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,021 | hpp | //%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// 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.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////
UNIX_BootServiceAccessBySAP::UNIX_BootServiceAccessBySAP(void)
{
}
UNIX_BootServiceAccessBySAP::~UNIX_BootServiceAccessBySAP(void)
{
}
Boolean UNIX_BootServiceAccessBySAP::getAntecedent(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_ANTECEDENT, getAntecedent());
return true;
}
CIMInstance UNIX_BootServiceAccessBySAP::getAntecedent() const
{
return CIMInstance(CIMName("CIM_Dependency"));
}
Boolean UNIX_BootServiceAccessBySAP::getDependent(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_DEPENDENT, getDependent());
return true;
}
CIMInstance UNIX_BootServiceAccessBySAP::getDependent() const
{
return CIMInstance(CIMName("CIM_Dependency"));
}
Boolean UNIX_BootServiceAccessBySAP::initialize()
{
return false;
}
Boolean UNIX_BootServiceAccessBySAP::load(int &pIndex)
{
return false;
}
Boolean UNIX_BootServiceAccessBySAP::finalize()
{
return false;
}
Boolean UNIX_BootServiceAccessBySAP::find(Array<CIMKeyBinding> &kbArray)
{
CIMKeyBinding kb;
String antecedentKey;
String dependentKey;
for(Uint32 i = 0; i < kbArray.size(); i++)
{
kb = kbArray[i];
CIMName keyName = kb.getName();
if (keyName.equal(PROPERTY_ANTECEDENT)) antecedentKey = kb.getValue();
else if (keyName.equal(PROPERTY_DEPENDENT)) dependentKey = kb.getValue();
}
/* EXecute find with extracted keys */
return false;
}
| [
"brunolauze@msn.com"
] | brunolauze@msn.com |
e01e1ee5dc47389edad2d199ce9d6d425fb6e47a | 0c8c07d1d3d0857b9a02a5f905b5d11caf99c944 | /vs_connect4/con4_fancy/main.cpp | feb58549310794e446e2fb598556c8d69c40a75f | [] | no_license | carsongmiller/connect4 | 9099100953d531e2c08eafcfcf41508644a536e9 | 4423df6a234698c4e118fa3fb88726db5416e9f0 | refs/heads/master | 2021-01-17T09:24:26.070954 | 2018-09-13T04:59:10 | 2018-09-13T04:59:10 | 25,881,831 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,756 | cpp | #include "brain.h"
#include "board.h"
#include <iostream>
#include <Windows.h>
#include <string>
#include <stdlib.h>
#include <cstdlib>
#include <cmath>
using namespace std;
const int w_ = 7, h_ = 6;
const int MAX_DEPTH = 4;
int main()
{
bool cont = true, validMove, newGame = true; //determines whether the game should continue
char whoFirst; //who will go first
int moveChoice; //human player's move choice
char yn; //takes input from player as to whether they want to play again
int rowPlayed; //stores the row in which the last disc was played
int colPlayed; //stores the column in which the last disc was played
int turn; //keeps track of which turn # it is
int tempScore = 0;
Board board(h_, w_);
Brain brain(h_, w_, MAX_DEPTH);
const int BLACK = 0;
const int BLUE = 1;
const int GREEN = 2;
const int CYAN = 3;
const int RED = 4;
const int MAGENTA = 5;
const int BROWN = 6;
const int LIGHTGRAY = 7;
const int DARKGRAY = 8;
const int LIGHTBLUE = 9;
const int LIGHTGREEN = 10;
const int LIGHTCYAN = 11;
const int LIGHTRED = 12;
const int LIGHTMAGENTA = 13;
const int YELLOW = 14;
const int WHITE = 15;
while (newGame)
{
turn = 0;
board.boardInit();
brain.scoreReset();
//First output of the program:
system("cls");
cout << "CONNECT 4!\n\nWho should go first? (m for me, c for computer): ";
cin >> whoFirst;
if (whoFirst == 'm' || whoFirst == 'M')
{
board.printScreen();
board.playerMove(turn, rowPlayed, colPlayed);
}
//MAIN GAME LOOP
while (cont)
{
board.printScreen(brain);
brain.scoreReset();
brain.rankedScoreReset();
cout << "Now its' the computer's turn\n\n";
cout << "thinking ...\n\n";
brain.minimax(board, tempScore, board.getDisc('c'), board.getDisc('c'), 0, turn);
brain.rankScores();
cout << endl << endl;
//now the computer will make its move
for (int i = 0; i < w_; i++)
{
rowPlayed = board.playMove(brain.getRankedScore(i), board.getDisc('c'), turn);
if (rowPlayed != -1)
{
colPlayed = brain.getRankedScore(i);
break;
}
}
board.printScreen(brain);
cout << "The computer played in column ";
board.printColor(colPlayed + 1, GREEN);
cout << "\n";
if (brain.winDetect(board, rowPlayed, colPlayed, board.getDisc('c')))
{
cout << "\nThe computer wins!\n";
break;
}
//now the player's turn
board.playerMove(turn, rowPlayed, colPlayed);
board.printScreen(brain);
//detecting a player win
if (brain.winDetect(board, rowPlayed, colPlayed - 1, board.getDisc('p')))
{
cout << "\nYou win!\n";
break;
}
}
cout << "Would you like to play again? (y/n): ";
cin >> yn;
if (yn != 'y' && yn != 'Y')
newGame = false;
}
return 0;
} | [
"carsongmiller@gmail.com"
] | carsongmiller@gmail.com |
9e1ac3251a6fedc3145fabf9ceb6700d4df3b2f7 | e35784eebbc939b9a8783a98d94e330cc07c3c05 | /Pattern/Pattern.h | 62a9c28fb5a23d643c97ab8740588c576845dfda | [] | no_license | endless2010/MFCDemo | 5c507994eba3f6786f427847ac443b218ccd3df7 | 33c12e185759f375b9c83e03aec933c66e778137 | refs/heads/master | 2021-01-10T12:35:48.288982 | 2015-12-13T12:57:30 | 2015-12-13T12:57:30 | 47,919,174 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,286 | h | // Pattern.h : main header file for the PATTERN application
//
#if !defined(AFX_PATTERN_H__5EA426D3_67F4_4A65_BC5B_457AD57516A6__INCLUDED_)
#define AFX_PATTERN_H__5EA426D3_67F4_4A65_BC5B_457AD57516A6__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#ifndef __AFXWIN_H__
#error include 'stdafx.h' before including this file for PCH
#endif
#include "resource.h" // main symbols
/////////////////////////////////////////////////////////////////////////////
// CPatternApp:
// See Pattern.cpp for the implementation of this class
//
class CPatternApp : public CWinApp
{
public:
CPatternApp();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CPatternApp)
public:
virtual BOOL InitInstance();
//}}AFX_VIRTUAL
// Implementation
//{{AFX_MSG(CPatternApp)
// NOTE - the ClassWizard will add and remove member functions here.
// DO NOT EDIT what you see in these blocks of generated code !
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_PATTERN_H__5EA426D3_67F4_4A65_BC5B_457AD57516A6__INCLUDED_)
| [
"chujiang131@163.com"
] | chujiang131@163.com |
b53b329c9f9d7f5cbc3aab68d35dbbf9b58da4c3 | a38a5e5e55f717191f055feea2abcf78eea343c3 | /translator/SVGTranslator.cpp | cb7f044d041ce2b2104ca264fb15e251d60f10c3 | [] | no_license | mmlr/libbsvg | 25b31c9181d03509329c8264dc876f5e9d537374 | a482206a6b41b35162424c25bd51af4355c3e6c3 | refs/heads/master | 2016-09-06T13:46:36.591117 | 2013-03-24T00:03:33 | 2014-07-05T19:04:23 | 21,526,426 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,951 | cpp | /*****************************************************************************/
// SVGTranslator
// Written by Michael Lotz
//
// SVGTranslator.cpp
//
// This BTranslator based object is for rasterizing SVG images.
//
//
// Copyright (c) 2003 OpenBeOS Project
//
// 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 <OS.h>
#include <stdio.h>
#include <string.h>
#include <String.h>
#include "SVGView.h"
#include "SVGDefs.h"
#include "SVGTranslator.h"
#include "SVGSettingsView.h"
// The input formats that this translator supports.
translation_format gInputFormats[] = {
{ SVG_FORMAT_CODE, B_TRANSLATOR_BITMAP, SVG_IN_QUALITY, SVG_IN_CAPABILITY,
"image/svg+xml", "SVG image" }
};
// The output formats that this translator supports.
translation_format gOutputFormats[] = {
};
// Long translator info
char translatorInfo[] = SVG_TRANSLATOR_INFO;
// Short name
char translatorName[] = SVG_TRANSLATOR_NAME;
// Translator version
int32 translatorVersion = SVG_TRANSLATOR_VERSION;
// Default settings for the Translator
TranSetting gDefaultSettings[] = {
{ B_TRANSLATOR_EXT_HEADER_ONLY, TRAN_SETTING_BOOL, false },
{ B_TRANSLATOR_EXT_DATA_ONLY, TRAN_SETTING_BOOL, false },
{ SVG_TRANSLATOR_EXT_SAMPLESIZE, TRAN_SETTING_INT32, 4},
{ SVG_TRANSLATOR_EXT_WIDTH, TRAN_SETTING_INT32, 256 },
{ SVG_TRANSLATOR_EXT_HEIGHT, TRAN_SETTING_INT32, 256 },
{ SVG_TRANSLATOR_EXT_SCALE_TO_FIT, TRAN_SETTING_BOOL, true },
{ SVG_TRANSLATOR_EXT_FIT_CONTENT, TRAN_SETTING_BOOL, true },
{ SVG_TRANSLATOR_EXT_BACK_COLOR, TRAN_SETTING_INT32, 0xffffffff }
};
// ---------------------------------------------------------------
// make_nth_translator
//
// Creates a SVGTranslator object to be used by BTranslatorRoster
//
// Preconditions:
//
// Parameters: n, The translator to return. Since
// SVGTranslator only publishes one
// translator, it only returns a
// SVGTranslator if n == 0
//
// you, The image_id of the add-on that
// contains code (not used).
//
// flags, Has no meaning yet, should be 0.
//
// Postconditions:
//
// Returns: NULL if n is not zero,
// a new SVGTranslator if n is zero
// ---------------------------------------------------------------
BTranslator *
make_nth_translator(int32 n, image_id you, uint32 flags, ...)
{
if (!n)
return new SVGTranslator();
else
return NULL;
}
// ---------------------------------------------------------------
// Constructor
//
// Sets up the version info and the name of the translator so that
// these values can be returned when they are requested.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
SVGTranslator::SVGTranslator()
: BaseTranslator("SVG Image", SVG_TRANSLATOR_INFO, SVG_TRANSLATOR_VERSION,
gInputFormats, sizeof(gInputFormats) / sizeof(translation_format),
gOutputFormats, sizeof(gOutputFormats) / sizeof(translation_format),
"SVGTranslator_Settings",
gDefaultSettings, sizeof(gDefaultSettings) / sizeof(TranSetting),
B_TRANSLATOR_BITMAP, SVG_FORMAT_CODE)
{
}
// ---------------------------------------------------------------
// Destructor
//
// Does nothing
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
SVGTranslator::~SVGTranslator()
{
}
// ---------------------------------------------------------------
// DerivedIdentify
//
// Examines the data from inSource and determines if it is in a
// format that this translator knows how to work with.
//
// Preconditions:
//
// Parameters: inSource, where the data to examine is
//
// inFormat, a hint about the data in inSource,
// it is ignored since it is only a hint
//
// ioExtension, configuration settings for the
// translator
//
// outInfo, information about what data is in
// inSource and how well this translator
// can handle that data is stored here
//
// outType, The format that the user wants
// the data in inSource to be
// converted to
//
// Postconditions:
//
// Returns: B_NO_TRANSLATOR, if this translator can't handle
// the data in inSource
//
// B_ERROR, if there was an error converting the data to the host
// format
//
// B_BAD_VALUE, if the settings in ioExtension are bad
//
// B_OK, if this translator understood the data and there were
// no errors found
//
// Other errors if BPositionIO::Read() returned an error value
// ---------------------------------------------------------------
status_t
SVGTranslator::DerivedIdentify(BPositionIO *inSource,
const translation_format *inFormat, BMessage *ioExtension,
translator_info *outInfo, uint32 outType)
{
char buffer[1024];
inSource->Read(buffer, 1024);
BString string(buffer);
if (string.IFindFirst("<!DOCTYPE svg ") < 0
&& string.IFindFirst("<path") < 0
&& string.FindFirst("linearGradient") < 0
&& string.FindFirst("radialGradient") < 0)
return B_NO_TRANSLATOR;
if (outInfo) {
outInfo->type = SVG_FORMAT_CODE;
outInfo->group = B_TRANSLATOR_BITMAP;
outInfo->quality = SVG_IN_QUALITY;
outInfo->capability = SVG_IN_CAPABILITY;
strcpy(outInfo->MIME, "image/svg+xml");
strcpy(outInfo->name, "SVG images");
}
return B_OK;
}
// ---------------------------------------------------------------
// DerivedTranslate
//
// Translates the data in inSource to the type outType and stores
// the translated data in outDestination.
//
// Preconditions:
//
// Parameters: inSource, the data to be translated
//
// inInfo, hint about the data in inSource (not used)
//
// ioExtension, configuration options for the
// translator
//
// outType, the type to convert inSource to
//
// outDestination, where the translated data is
// put
//
// baseType, indicates whether inSource is in the
// bits format, not in the bits format or
// is unknown
//
// Postconditions:
//
// Returns: B_BAD_VALUE, if the options in ioExtension are bad
//
// B_NO_TRANSLATOR, if this translator doesn't understand the data
//
// B_ERROR, if there was an error allocating memory or converting
// data
//
// B_OK, if all went well
// ---------------------------------------------------------------
status_t
SVGTranslator::DerivedTranslate(BPositionIO *inSource,
const translator_info *inInfo, BMessage *ioExtension, uint32 outType,
BPositionIO *outDestination, int32 baseType)
{
if (baseType != 0)
return B_NO_TRANSLATOR;
int32 width = 256;
int32 height = 256;
bool scale = true;
bool fit = true;
int32 color = 0xffffffff;
bool header = true;
bool data = true;
int32 samplesize = 4;
fSettings->LoadSettings();
if (!ioExtension
|| ioExtension->FindInt32(SVG_TRANSLATOR_EXT_WIDTH, &width) != B_OK)
width = fSettings->SetGetInt32(SVG_TRANSLATOR_EXT_WIDTH);
if (!ioExtension
|| ioExtension->FindInt32(SVG_TRANSLATOR_EXT_HEIGHT, &height) != B_OK)
height = fSettings->SetGetInt32(SVG_TRANSLATOR_EXT_HEIGHT);
if (!ioExtension
|| ioExtension->FindBool(SVG_TRANSLATOR_EXT_SCALE_TO_FIT, &scale) != B_OK)
scale = fSettings->SetGetBool(SVG_TRANSLATOR_EXT_SCALE_TO_FIT);
if (!ioExtension
|| ioExtension->FindBool(SVG_TRANSLATOR_EXT_FIT_CONTENT, &fit) != B_OK)
fit = fSettings->SetGetBool(SVG_TRANSLATOR_EXT_FIT_CONTENT);
if (!ioExtension
|| ioExtension->FindInt32(SVG_TRANSLATOR_EXT_SAMPLESIZE, &samplesize) != B_OK)
samplesize = fSettings->SetGetInt32(SVG_TRANSLATOR_EXT_SAMPLESIZE);
if (!ioExtension
|| ioExtension->FindInt32(SVG_TRANSLATOR_EXT_BACK_COLOR, &color) != B_OK)
color = fSettings->SetGetInt32(SVG_TRANSLATOR_EXT_BACK_COLOR);
if (!ioExtension
|| ioExtension->FindBool(B_TRANSLATOR_EXT_HEADER_ONLY, &header) != B_OK)
header = fSettings->SetGetBool(B_TRANSLATOR_EXT_HEADER_ONLY);
if (!ioExtension
|| ioExtension->FindBool(B_TRANSLATOR_EXT_DATA_ONLY, &data) != B_OK)
data = fSettings->SetGetBool(B_TRANSLATOR_EXT_DATA_ONLY);
if (header)
data = false;
else if (data)
header = false;
else {
data = true;
header = true;
}
BRect bounds(0, 0, width - 1, height - 1);
BBitmap *output = new BBitmap(bounds, B_RGBA32, true);
bounds.right += 1; bounds.bottom += 1;
uint32 *bits = (uint32 *)output->Bits();
int length = output->BitsLength();
BSVGView *view = NULL;
if (data) {
view = new BSVGView(bounds, "BSVGView", B_FOLLOW_NONE);
view->SetScaleToFit(scale);
view->SetFitContent(fit);
view->SetSampleSize(samplesize);
view->SetViewColor(color >> 16 & 0x000000ff, color >> 8 & 0x000000ff,
color >> 0 & 0x000000ff, color >> 24 & 0x000000ff);
fast_memset(length / 4, color, bits);
output->AddChild(view);
output->Lock();
if (view->LoadFromPositionIO(inSource) != B_OK) {
output->RemoveChild(view);
output->Unlock();
delete output;
delete view;
return B_ERROR;
}
view->Draw(bounds);
output->RemoveChild(view);
output->Unlock();
delete view;
}
// Write out the data to outDestination
// Construct and write Be bitmap header
TranslatorBitmap bitsHeader;
if (header) {
bounds.right -= 1; bounds.bottom -= 1;
bitsHeader.magic = B_TRANSLATOR_BITMAP;
bitsHeader.bounds = bounds;
bitsHeader.rowBytes = output->BytesPerRow();
bitsHeader.colors = B_RGBA32;
bitsHeader.dataSize = length;
if (swap_data(B_UINT32_TYPE, &bitsHeader,
sizeof(TranslatorBitmap), B_SWAP_HOST_TO_BENDIAN) != B_OK) {
delete output;
return B_ERROR;
}
}
if (header)
outDestination->Write(&bitsHeader, sizeof(TranslatorBitmap));
if (data)
outDestination->Write(bits, length);
delete output;
return B_OK;
}
BView *
SVGTranslator::NewConfigView(TranslatorSettings *settings)
{
return new SVGSettingsView(BRect(0, 0, SVG_VIEW_WIDTH, SVG_VIEW_HEIGHT),
"SVGTranslator Settings", B_FOLLOW_ALL, B_WILL_DRAW, settings);
}
| [
"mmlr@mlotz.ch"
] | mmlr@mlotz.ch |
4e92f79980bc8fd095b63c7a10fb0623102d1d39 | 603ad7bb3df5a02d222acefec08ce4f94d75409b | /rpc0419/c.cpp | fea8f113ec0efd20d7590d86f56beeacef9bd685 | [] | no_license | MijaelTola/icpc | 6fc43aa49f97cf951a2b2fcbd0becd8c895abf36 | ee2629ba087fbe7303743c84b509959f8d3fc9a0 | refs/heads/master | 2023-07-09T00:47:42.812242 | 2021-08-08T00:44:10 | 2021-08-08T00:44:10 | 291,160,127 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 448 | cpp | #include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
int ans = 1e9;
vector<int> dv;
for (int i = 1; i <= n; ++i)
if(n % i == 0) dv.push_back(i);
for (auto i: dv)
for (auto j: dv)
for (auto k: dv) {
if(i * j * k == n) {
ans = min(ans, i * j + j * k + i * k);
}
}
cout << 2 * ans << "\n";
return 0;
}
| [
"mija.tola.ap@gmail.com"
] | mija.tola.ap@gmail.com |
3363599cbdf91728ee40c3f613734c415619e632 | 3cf9e141cc8fee9d490224741297d3eca3f5feff | /C++ Benchmark Programs/Benchmark Files 1/classtester/autogen-sources/source-8627.cpp | a5b746404e0affb8fd353e817bef5b2f61dd745c | [] | no_license | TeamVault/tauCFI | e0ac60b8106fc1bb9874adc515fc01672b775123 | e677d8cc7acd0b1dd0ac0212ff8362fcd4178c10 | refs/heads/master | 2023-05-30T20:57:13.450360 | 2021-06-14T09:10:24 | 2021-06-14T09:10:24 | 154,563,655 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,007 | cpp | struct c0;
void __attribute__ ((noinline)) tester0(c0* p);
struct c0
{
bool active0;
c0() : active0(true) {}
virtual ~c0()
{
tester0(this);
active0 = false;
}
virtual void f0(){}
};
void __attribute__ ((noinline)) tester0(c0* p)
{
p->f0();
}
struct c1;
void __attribute__ ((noinline)) tester1(c1* p);
struct c1
{
bool active1;
c1() : active1(true) {}
virtual ~c1()
{
tester1(this);
active1 = false;
}
virtual void f1(){}
};
void __attribute__ ((noinline)) tester1(c1* p)
{
p->f1();
}
struct c2;
void __attribute__ ((noinline)) tester2(c2* p);
struct c2 : virtual c0, virtual c1
{
bool active2;
c2() : active2(true) {}
virtual ~c2()
{
tester2(this);
c0 *p0_0 = (c0*)(c2*)(this);
tester0(p0_0);
c1 *p1_0 = (c1*)(c2*)(this);
tester1(p1_0);
active2 = false;
}
virtual void f2(){}
};
void __attribute__ ((noinline)) tester2(c2* p)
{
p->f2();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
}
struct c3;
void __attribute__ ((noinline)) tester3(c3* p);
struct c3 : virtual c1, c2
{
bool active3;
c3() : active3(true) {}
virtual ~c3()
{
tester3(this);
c0 *p0_0 = (c0*)(c2*)(c3*)(this);
tester0(p0_0);
c1 *p1_0 = (c1*)(c3*)(this);
tester1(p1_0);
c1 *p1_1 = (c1*)(c2*)(c3*)(this);
tester1(p1_1);
c2 *p2_0 = (c2*)(c3*)(this);
tester2(p2_0);
active3 = false;
}
virtual void f3(){}
};
void __attribute__ ((noinline)) tester3(c3* p)
{
p->f3();
if (p->active2)
p->f2();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
}
struct c4;
void __attribute__ ((noinline)) tester4(c4* p);
struct c4 : virtual c2, virtual c0, virtual c1
{
bool active4;
c4() : active4(true) {}
virtual ~c4()
{
tester4(this);
c0 *p0_0 = (c0*)(c2*)(c4*)(this);
tester0(p0_0);
c0 *p0_1 = (c0*)(c4*)(this);
tester0(p0_1);
c1 *p1_0 = (c1*)(c2*)(c4*)(this);
tester1(p1_0);
c1 *p1_1 = (c1*)(c4*)(this);
tester1(p1_1);
c2 *p2_0 = (c2*)(c4*)(this);
tester2(p2_0);
active4 = false;
}
virtual void f4(){}
};
void __attribute__ ((noinline)) tester4(c4* p)
{
p->f4();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
if (p->active2)
p->f2();
}
int __attribute__ ((noinline)) inc(int v) {return ++v;}
int main()
{
c0* ptrs0[25];
ptrs0[0] = (c0*)(new c0());
ptrs0[1] = (c0*)(c2*)(new c2());
ptrs0[2] = (c0*)(c2*)(c3*)(new c3());
ptrs0[3] = (c0*)(c2*)(c4*)(new c4());
ptrs0[4] = (c0*)(c4*)(new c4());
for (int i=0;i<5;i=inc(i))
{
tester0(ptrs0[i]);
delete ptrs0[i];
}
c1* ptrs1[25];
ptrs1[0] = (c1*)(new c1());
ptrs1[1] = (c1*)(c2*)(new c2());
ptrs1[2] = (c1*)(c3*)(new c3());
ptrs1[3] = (c1*)(c2*)(c3*)(new c3());
ptrs1[4] = (c1*)(c2*)(c4*)(new c4());
ptrs1[5] = (c1*)(c4*)(new c4());
for (int i=0;i<6;i=inc(i))
{
tester1(ptrs1[i]);
delete ptrs1[i];
}
c2* ptrs2[25];
ptrs2[0] = (c2*)(new c2());
ptrs2[1] = (c2*)(c3*)(new c3());
ptrs2[2] = (c2*)(c4*)(new c4());
for (int i=0;i<3;i=inc(i))
{
tester2(ptrs2[i]);
delete ptrs2[i];
}
c3* ptrs3[25];
ptrs3[0] = (c3*)(new c3());
for (int i=0;i<1;i=inc(i))
{
tester3(ptrs3[i]);
delete ptrs3[i];
}
c4* ptrs4[25];
ptrs4[0] = (c4*)(new c4());
for (int i=0;i<1;i=inc(i))
{
tester4(ptrs4[i]);
delete ptrs4[i];
}
return 0;
}
| [
"ga72foq@mytum.de"
] | ga72foq@mytum.de |
5a295560638a9f0cdec6f3394aa0cd1d4b207be1 | b498021cbe439056615e943cffe41057e9299bf1 | /anagramsornot.cpp | 50bfbe1a2ae83af59862fc5c251bac72502aaaf4 | [] | no_license | sirgoyal/Striver-s-SDE-Sheet | d321e60c9b5bc7ad1768fc92ade8949cca36dabe | b3e5792ddffca4ccd3bf8cec04cc2defdb5c21ab | refs/heads/master | 2023-09-03T17:36:01.533373 | 2021-10-06T03:36:59 | 2021-10-06T03:36:59 | 395,528,128 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 546 | cpp | class Solution
{
public:
//Function is to check whether two strings are anagram of each other or not.
bool isAnagram(string a, string b){
// Your code here
if(a.size()!=b.size())
return 0;
unordered_map<char, int> mp1, mp2;
for(int i=0; i<a.size(); i++)
{
mp1[a[i]]++;
mp2[b[i]]++;
}
for(int i=0; i<a.size(); i++)
{
if(mp1[a[i]]==mp2[a[i]] && mp1[b[i]]==mp2[b[i]])
continue;
else return false;
}
return true;
} | [
"shriramgoyal31@gmail.com"
] | shriramgoyal31@gmail.com |
94b7d3f4f7aa1fe65bdaa1e8fddd8eaa9780becf | 16804ada1f93742f075f9a3c79201f514d1cd950 | /Array/118. Pascal's Triangle /Pascal'sTriangle.hpp | 220b6ebb44f5f5dbcd0cd4b0c1ffe2acfa045649 | [] | no_license | Jack--Ma/LeetCode | feff40b3aa880c62ff98e5812fb1a961f44caee9 | 86a10dc3adc6dc95e0bbd92be1ad7ac23e76f3b5 | refs/heads/master | 2023-06-13T01:14:37.706610 | 2023-06-05T15:09:43 | 2023-06-05T15:09:43 | 63,851,136 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 402 | hpp | //
// Pascal'sTriangle.hpp
// LeetCode-main
//
// Created by jackma on 2022/2/21.
// Copyright ยฉ 2022 JackMa. All rights reserved.
//
#ifndef Pascal_sTriangle_hpp
#define Pascal_sTriangle_hpp
#include <stdio.h>
// https://leetcode.com/problems/pascals-triangle/
class Solution {
public:
vector<vector<int>> generate(int numRows);
};
void testGenerate();
#endif /* Pascal_sTriangle_hpp */
| [
"100858433@qq.com"
] | 100858433@qq.com |
790373a5ce2380b1bb4aaf99a6a8f260c1fb0b6c | 15e84aaa0c700f846b4641f74aa72d69fde1ab8a | /relay/src/relay.ino | f5e5501a82bf953aa88d5c8b838ab8ac8346f6d8 | [] | no_license | edholmes2232/ArduinoLearn | eedb745f723c4c0a759ea80c7009ab147b9e5952 | 10b2cc44b1d9d5fa472076667e691b0a44ca903f | refs/heads/master | 2021-07-19T21:54:44.974758 | 2017-10-25T16:06:10 | 2017-10-25T16:06:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 145 | ino | // BLINK
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH);
delay(1000);
digitalWrite(ledPin,
| [
"ed.holmes@me.com"
] | ed.holmes@me.com |
0ff0e7d2a74821e1bbf6a4eb5a7a861a7a68da8a | 47c4bff4deea8c7ef1188761166ecb5b3a805601 | /Finite_composition_law.cpp | 47623c0a1bcdce36efe8e71c5167b34dc16ec479 | [] | no_license | bogdandv/Proiect-Poo-semestrul-2-anul-1-Criptografie | 07d056749a6863ca973aabb13926671b01de9ca1 | ddeb0ed2f975af054ee975c7fa3b9ce478112a0b | refs/heads/master | 2021-01-10T14:16:14.332579 | 2016-04-24T16:55:13 | 2016-04-24T16:55:13 | 53,876,362 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 574 | cpp | #include "Finite_composition_law.h"
int Finite_Composition_law::Count()
{
return Number_of_elements;
}
int Finite_Composition_law::Return_composite(int First_value,int Second_value)
{
return Caylay_table[First_value*Number_of_elements+Second_value];
}
Finite_Composition_law::Finite_Composition_law(int number_of_elements,int *caylay_table)
{
Number_of_elements=number_of_elements;
Caylay_table=caylay_table;
}
Finite_Composition_law::~Finite_Composition_law()
{
delete[] Caylay_table;
}
| [
"bogdandv_14@yahoo.com"
] | bogdandv_14@yahoo.com |
32d474c69dd17a37f6c4edac1f49bdc647115e62 | 3dcee3d005caa5ca9e565adebb33025ac89f8982 | /windows/runner/main.cpp | 462f63db65b5611fdadbf97f4609c32fd5692760 | [] | no_license | fikrirazzaq/MovieRaw | c88a00d3903fb1ace123b81fe312ed1eec66f33f | d231c981d7fb4addbdad4bd2e0b3a8fa321297d0 | refs/heads/master | 2023-08-21T10:06:38.679358 | 2021-10-16T07:29:30 | 2021-10-16T07:29:30 | 412,698,058 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,228 | cpp | #include <flutter/dart_project.h>
#include <flutter/flutter_view_controller.h>
#include <windows.h>
#include "flutter_window.h"
#include "run_loop.h"
#include "utils.h"
int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
_In_ wchar_t *command_line, _In_ int show_command) {
// Attach to console when present (e.g., 'flutter run') or create a
// new console when running with a debugger.
if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) {
CreateAndAttachConsole();
}
// Initialize COM, so that it is available for use in the library and/or
// plugins.
::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
RunLoop run_loop;
flutter::DartProject project(L"data");
std::vector<std::string> command_line_arguments =
GetCommandLineArguments();
project.set_dart_entrypoint_arguments(std::move(command_line_arguments));
FlutterWindow window(&run_loop, project);
Win32Window::Point origin(10, 10);
Win32Window::Size size(1280, 720);
if (!window.CreateAndShow(L"movies_starter_app", origin, size)) {
return EXIT_FAILURE;
}
window.SetQuitOnClose(true);
run_loop.Run();
::CoUninitialize();
return EXIT_SUCCESS;
}
| [
"fikri.arrasyid@fnbees.com"
] | fikri.arrasyid@fnbees.com |
b84e687c3c9e9efd231e05a5562a5076c744d700 | 86b49295796e559a01fd9495d6d5e6bf3030ce05 | /EventAnalyzer/src/ProductMakerUnion.cpp | d61a98ef93c176370df1178ce86d75ca837b8ef6 | [
"MIT"
] | permissive | peterthomassen/RutgersIAF | 88310697bd4fc8e1df913cac55c2c4486710ce7c | 50fd20b79b8bce30478d49e1ce7c763424e094f1 | refs/heads/master | 2020-05-29T09:15:38.571846 | 2016-09-22T10:27:09 | 2016-09-22T10:27:09 | 69,040,707 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,070 | cpp | #include "RutgersIAF/EventAnalyzer/interface/ProductMakerUnion.h"
using namespace std;
ClassImp(ProductMakerUnion)
ProductMakerUnion::ProductMakerUnion(TString source,TString name) : ProductMaker(source,name)
{
m_sources.push_back(source);
m_handler = NULL;
}
vector<SignatureObject*> ProductMakerUnion::makeProduct(BaseHandler* handler)
{
m_holder.clear();
m_source.clear();
if(!handler)return m_holder;
m_handler = handler;
for(int i = 0; i < (int)m_sources.size(); i++){
vector<SignatureObject*> source = m_handler->getProduct(m_sources[i]);
m_source.insert(m_source.end(),source.begin(),source.end());
}
sort(m_source.begin(),m_source.end(),SignatureObjectComparison);
m_holder = applyCuts(m_source);
m_holder = applySelfSeparations(m_holder);
m_holder = applySeparations(m_holder);
m_holder = doAssociations(m_holder);
makeAssociateVariables();
return m_holder;
}
void ProductMakerUnion::addSource(TString pname)
{
if(find(m_sources.begin(),m_sources.end(),pname) == m_sources.end())m_sources.push_back(pname);
}
| [
"mwalker@physics.rutgers.edu"
] | mwalker@physics.rutgers.edu |
7c436d0d21435df26f4c0e5a919a51114cfedffe | 0fed3d6c4a6dbdb49029913b6ce96a9ede9eac6c | /Summer2018/Personal02/L.cpp | 15a580135aad51763f0397966d617b5e6feb1710 | [] | no_license | 87ouo/The-road-to-ACMer | 72df2e834027dcfab04b02ba0ddd350e5078dfc0 | 0a39a9708a0e7fd0e3b2ffff5d1f4a793b031df5 | refs/heads/master | 2021-02-18T17:44:29.937434 | 2019-07-31T11:30:27 | 2019-07-31T11:30:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,258 | cpp | // 3-idiots, HDU4609
/*Sample Input
2
4
1 3 3 4
4
2 3 3 4
*/
#include <bits/stdc++.h>
using namespace std;
#define clr(a, x) memset(a, x, sizeof(a))
#define mp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define X first
#define Y second
#define fastin \
ios_base::sync_with_stdio(0); \
cin.tie(0);
typedef long long ll;
typedef long double ld;
typedef pair<int, int> PII;
typedef vector<int> VI;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
struct Complex
{
double x, y;
Complex(double x = 0.0, double y = 0.0) { this->x = x, this->y = y; }
Complex operator-(const Complex& b) const { return Complex(x - b.x, y - b.y); }
Complex operator+(const Complex& b) const { return Complex(x + b.x, y + b.y); }
Complex operator*(const Complex& b) const { return Complex(x * b.x - y * b.y, x * b.y + y * b.x); }
};
void fft(Complex y[], int len, int on)
{
for (int i = 1, j = len / 2; i < len - 1; i++)
{
if (i < j) swap(y[i], y[j]);
int k = len / 2;
while (j >= k) j -= k, k /= 2;
if (j < k) j += k;
}
for (int h = 2; h <= len; h <<= 1)
{
Complex wn(cos(-on * 2 * PI / h), sin(-on * 2 * PI / h));
for (int j = 0; j < len; j += h)
{
Complex w(1, 0);
for (int k = j; k < j + h / 2; k++)
{
Complex u = y[k];
Complex t = w * y[k + h / 2];
y[k] = u + t;
y[k + h / 2] = u - t;
w = w * wn;
}
}
}
if (on == -1)
for (int i = 0; i < len; i++) y[i].x /= len;
}
const int maxn = 1e5 + 10;
Complex x1[maxn << 2];
int a[maxn];
ll num[maxn << 2];
ll sum[maxn << 2];
int main()
{
#ifndef ONLINE_JUDGE
freopen("1.in", "r", stdin);
freopen("1.out", "w", stdout);
#endif
int T;
scanf("%d", &T);
while (T--)
{
int n;
scanf("%d", &n);
memset(num, 0, sizeof(num));
for (int i = 0; i < n; i++)
{
scanf("%d", &a[i]);
num[a[i]]++;
}
sort(a, a + n);
int len1 = a[n - 1] + 1;
int len = 1;
while (len < 2 * len1) len <<= 1;
for (int i = 0; i < len1; i++) x1[i] = Complex(num[i], 0);
for (int i = len1; i < len; i++) x1[i] = Complex(0, 0);
fft(x1, len, 1);
for (int i = 0; i < len; i++) x1[i] = x1[i] * x1[i];
fft(x1, len, -1);
for (int i = 0; i < len; i++) num[i] = (ll)(x1[i].x + 0.5);
len = 2 * a[n - 1];
for (int i = 0; i < n; i++) num[a[i] + a[i]]--; // ๅป้
for (int i = 1; i <= len; i++) num[i] /= 2; // ๅปๅบ
sum[0] = 0;
for (int i = 1; i <= len; i++) sum[i] = sum[i - 1] + num[i];
ll cnt = 0;
for (int i = 0; i < n; i++)
{
cnt += sum[len] - sum[a[i]]; // ไธไธชๅๅคง๏ผไธไธชๅๅฐ
cnt -= (ll)(n - 1 - i) * i; // ไธไธชๅๆฌ่บซ
cnt -= (n - 1); // ไธคไธชๅๅคง
cnt -= (ll)(n - 1 - i) * (n - i - 2) / 2;
}
ll tot = (ll)n * (n - 1) * (n - 2) / 6;
printf("%.7lf\n", (double)cnt / tot);
}
return 0;
}
| [
"zbszx040504@126.com"
] | zbszx040504@126.com |
54e20f5dccf97504c5910f27fe7a0bc8a601afa5 | a88f090640408fb5d2416c41e207b40520ce4d89 | /CorruptedVirtues/Library/Il2cppBuildCache/WebGL/il2cppOutput/Il2CppCCFieldValuesTable.cpp | 7fc35ed5fb8db9abfa9750d92da8de5307dc870f | [] | no_license | rachelschlote/TheCorruptedVirtues | 1327bc29a47683e8ffda3942ce491ef9650170a7 | c97f5d566d7952e6b6747f3b083110ed9865eb7d | refs/heads/main | 2023-08-25T16:25:36.244939 | 2021-10-07T02:59:32 | 2021-10-07T02:59:32 | 415,715,125 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 114,642 | cpp | ๏ปฟ#include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable4[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable5[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable6[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable7[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable8[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable9[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable11[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable13[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable14[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable15[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable16[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable18[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable19[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable20[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable21[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable22[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable25[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable26[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable27[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable28[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable29[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable30[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable31[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable32[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable33[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable34[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable35[19];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable36[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable37[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable38[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable39[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable40[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable41[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable42[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable43[22];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable46[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable47[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable48[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable49[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable50[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable51[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable53[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable55[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable56[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable64[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable65[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable66[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable67[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable68[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable72[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable73[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable74[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable75[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable76[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable77[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable78[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable79[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable80[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable81[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable82[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable83[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable98[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable100[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable105[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable106[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable107[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable108[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable109[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable111[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable113[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable114[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable115[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable117[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable118[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable119[145];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable120[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable121[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable122[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable125[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable126[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable127[45];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable128[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable129[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable130[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable131[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable132[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable133[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable137[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable138[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable140[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable141[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable142[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable145[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable146[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable151[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable152[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable154[22];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable155[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable156[40];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable157[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable158[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable159[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable160[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable161[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable162[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable163[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable164[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable165[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable166[33];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable167[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable168[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable169[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable170[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable171[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable183[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable184[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable185[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable190[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable194[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable195[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable201[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable203[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable204[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable205[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable209[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable211[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable213[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable214[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable215[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable216[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable217[19];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable219[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable221[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable223[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable224[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable225[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable226[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable227[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable231[29];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable232[47];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable233[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable234[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable235[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable236[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable237[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable238[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable239[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable240[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable241[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable243[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable244[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable245[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable246[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable247[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable248[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable249[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable251[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable253[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable254[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable255[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable256[23];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable258[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable259[48];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable260[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable261[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable263[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable265[23];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable266[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable267[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable270[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable272[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable273[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable274[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable275[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable276[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable277[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable278[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable279[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable280[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable281[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable282[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable283[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable284[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable285[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable286[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable288[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable290[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable291[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable292[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable293[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable294[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable296[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable297[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable299[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable300[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable301[26];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable303[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable304[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable305[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable307[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable308[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable309[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable310[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable311[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable312[44];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable313[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable314[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable315[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable316[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable317[35];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable318[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable319[396];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable320[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable321[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable322[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable323[19];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable328[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable331[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable332[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable333[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable334[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable335[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable337[20];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable338[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable340[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable341[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable342[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable343[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable344[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable345[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable346[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable348[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable349[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable351[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable352[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable353[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable356[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable357[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable358[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable359[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable360[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable361[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable362[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable363[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable364[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable367[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable368[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable369[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable370[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable371[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable372[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable373[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable374[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable375[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable376[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable377[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable379[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable380[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable381[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable382[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable383[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable384[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable385[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable386[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable387[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable388[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable390[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable391[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable392[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable393[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable394[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable395[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable396[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable397[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable398[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable399[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable400[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable403[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable404[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable406[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable407[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable408[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable409[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable410[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable411[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable412[22];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable413[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable414[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable415[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable418[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable419[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable420[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable421[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable422[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable423[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable424[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable425[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable426[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable427[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable428[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable429[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable430[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable431[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable432[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable434[21];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable435[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable436[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable437[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable438[20];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable439[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable442[23];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable445[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable446[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable447[25];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable449[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable450[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable452[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable453[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable454[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable455[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable456[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable457[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable461[33];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable465[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable466[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable467[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable468[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable469[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable471[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable472[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable474[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable475[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable477[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable478[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable479[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable482[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable484[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable487[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable488[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable490[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable492[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable497[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable498[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable503[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable504[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable506[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable515[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable521[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable524[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable525[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable526[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable531[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable532[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable534[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable535[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable537[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable538[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable540[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable541[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable542[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable544[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable545[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable547[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable548[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable549[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable550[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable552[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable553[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable554[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable556[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable557[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable558[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable560[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable561[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable562[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable563[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable565[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable567[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable568[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable569[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable570[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable571[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable574[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable575[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable576[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable577[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable578[27];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable579[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable580[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable581[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable582[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable583[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable585[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable586[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable588[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable589[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable590[21];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable591[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable592[25];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable593[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable594[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable595[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable596[84];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable597[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable598[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable599[25];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable600[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable601[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable602[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable603[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable604[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable605[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable606[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable607[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable608[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable609[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable610[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable611[20];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable612[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable613[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable614[36];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable615[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable617[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable618[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable619[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable620[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable621[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable622[31];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable623[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable624[21];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable625[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable626[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable627[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable628[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable629[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable630[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable631[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable632[38];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable633[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable634[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable636[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable637[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable638[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable639[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable640[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable641[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable642[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable643[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable644[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable646[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable647[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable648[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable649[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable651[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable652[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable653[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable655[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable658[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable661[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable662[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable663[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable664[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable665[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable675[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable676[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable677[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable679[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable680[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable681[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable687[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable688[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable689[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable690[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable691[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable692[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable694[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable697[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable699[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable704[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable705[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable706[39];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable708[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable709[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable712[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable713[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable714[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable715[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable717[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable718[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable720[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable721[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable722[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable723[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable725[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable726[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable727[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable728[22];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable729[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable731[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable732[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable733[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable734[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable737[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable738[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable740[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable741[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable742[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable743[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable744[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable745[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable746[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable747[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable748[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable749[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable751[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable752[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable754[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable755[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable756[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable757[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable760[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable761[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable765[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable769[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable770[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable771[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable772[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable776[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable777[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable785[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable786[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable787[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable788[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable789[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable790[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable791[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable792[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable793[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable794[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable795[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable797[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable798[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable804[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable805[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable806[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable807[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable808[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable809[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable810[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable811[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable812[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable813[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable814[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable815[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable816[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable817[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable820[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable821[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable822[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable823[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable824[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable825[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable826[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable827[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable828[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable829[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable830[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable831[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable832[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable833[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable834[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable835[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable836[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable838[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable839[20];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable840[47];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable841[24];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable842[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable843[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable844[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable845[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable846[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable847[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable848[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable849[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable850[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable851[20];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable852[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable853[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable854[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable855[21];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable856[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable857[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable858[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable859[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable860[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable861[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable862[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable863[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable864[24];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable865[21];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable866[25];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable867[41];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable868[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable869[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable870[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable871[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable872[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable873[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable874[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable875[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable876[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable877[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable878[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable879[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable883[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable884[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable885[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable886[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable887[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable888[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable889[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable890[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable893[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable894[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable895[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable896[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable899[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable900[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable901[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable902[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable903[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable904[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable905[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable906[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable908[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable910[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable911[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable912[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable916[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable917[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable918[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable919[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable920[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable921[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable922[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable923[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable925[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable937[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable938[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable939[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable940[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable941[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable943[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable951[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable952[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable953[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable955[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable960[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable961[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable962[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable964[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable966[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable967[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable968[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable969[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable970[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable971[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable972[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable973[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable974[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable975[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable976[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable977[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable978[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable979[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable980[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable981[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable982[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable983[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable985[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable986[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable996[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable997[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable998[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable999[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1000[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1001[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1002[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1003[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1007[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1008[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1010[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1011[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1012[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1015[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1017[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1018[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1019[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1020[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1021[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1022[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1023[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1024[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1025[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1026[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1031[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1032[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1033[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1034[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1035[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1036[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1037[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1038[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1039[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1040[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1041[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1042[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1045[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1046[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1048[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1049[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1052[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1056[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1058[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1060[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1061[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1062[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1063[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1064[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1065[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1066[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1067[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1068[45];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1069[39];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1071[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1076[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1077[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1078[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1079[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1080[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1081[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1082[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1084[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1088[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1089[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1090[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1091[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1092[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1093[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1109[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1110[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1111[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1113[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1114[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1115[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1116[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1117[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1120[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1121[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1122[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1123[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1125[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1126[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1138[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1139[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1140[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1141[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1143[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1144[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1146[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1147[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1149[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1150[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1151[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1152[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1153[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1154[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1155[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1156[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1160[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1163[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1164[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1165[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1166[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1167[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1168[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1169[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1170[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1171[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1176[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1177[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1182[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1203[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1204[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1208[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1209[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1210[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1211[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1212[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1213[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1214[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1215[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1216[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1217[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1219[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1261[101];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1271[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1278[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1283[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1288[56];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1289[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1290[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1291[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1292[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1293[29];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1295[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1296[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1297[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1298[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1299[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1300[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1301[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1302[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1304[26];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1309[30];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1310[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1312[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1313[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1315[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1317[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1321[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1322[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1323[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1331[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1332[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1333[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1335[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1336[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1337[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1338[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1340[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1341[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1342[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1343[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1345[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1346[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1347[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1348[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1349[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1350[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1351[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1352[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1355[17];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1356[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1357[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1358[32];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1359[48];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1361[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1385[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1386[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1387[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1388[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1389[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1392[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1393[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1394[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1396[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1397[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1398[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1399[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1400[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1403[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1407[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1410[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1411[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1412[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1413[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1414[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1415[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1416[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1418[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1419[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1422[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1423[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1424[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1425[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1428[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1432[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1433[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1434[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1436[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1438[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1439[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1440[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1441[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1442[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1443[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1450[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1451[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1452[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1453[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1469[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1470[40];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1471[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1472[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1473[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1474[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1475[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1478[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1479[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1480[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1481[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1482[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1483[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1485[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1486[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1488[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1489[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1490[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1492[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1494[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1495[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1496[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1497[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1498[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1499[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1500[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1501[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1503[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1504[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1507[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1513[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1514[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1516[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1517[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1518[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1519[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1520[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1521[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1522[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1523[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1524[71];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1525[29];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1526[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1527[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1528[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1529[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1530[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1532[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1534[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1542[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1543[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1545[327];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1548[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1549[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1550[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1551[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1552[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1553[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1554[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1555[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1556[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1557[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1558[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1562[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1563[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1564[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1565[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1567[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1569[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1570[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1572[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1573[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1574[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1579[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1585[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1592[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1596[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1597[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1598[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1600[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1603[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1605[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1607[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1608[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1610[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1611[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1612[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1613[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1616[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1617[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1626[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1629[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1630[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1631[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1632[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1633[26];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1635[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1637[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1638[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1641[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1645[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1646[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1648[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1649[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1650[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1651[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1653[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1655[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1656[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1657[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1658[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1659[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1660[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1661[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1662[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1663[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1664[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1665[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1667[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1669[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1671[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1673[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1675[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1676[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1678[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1679[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1680[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1682[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1683[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1684[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1685[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1686[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1687[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1689[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1820[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1821[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1822[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1823[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1824[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1827[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1828[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1829[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1830[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1831[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1832[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1834[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1835[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1836[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1837[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1838[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1839[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1840[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1841[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1842[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1844[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1845[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1846[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1848[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1849[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1850[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1851[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1852[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1853[25];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1854[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1855[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1856[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1858[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1859[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1860[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1861[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1865[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1869[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1870[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1871[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1872[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1873[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1874[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1875[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1877[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1878[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1879[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1880[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1881[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1882[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1883[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1884[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1885[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1886[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1887[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1888[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1891[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1892[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1893[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1894[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1895[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1896[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1899[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1900[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1901[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1902[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1903[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1904[138];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1909[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1910[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1911[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1912[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1915[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1916[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1918[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1919[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1920[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1921[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1922[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1923[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1930[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1931[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1932[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1933[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1934[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1935[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1936[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1937[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1938[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1939[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1941[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1945[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1947[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1948[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1949[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1950[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1953[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1954[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1955[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1956[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1959[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1960[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1961[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1962[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1963[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1964[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1965[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1966[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1967[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1968[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1969[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1970[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1972[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1973[39];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1974[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1976[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1977[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1979[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1980[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1981[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1982[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1983[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1985[30];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1986[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1987[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1988[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1989[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1991[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1992[21];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1993[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1996[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1997[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable1999[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2010[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2011[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2012[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2014[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2015[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2019[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2022[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2026[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2027[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2028[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2029[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2031[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2033[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2034[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2035[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2037[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2038[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2039[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2043[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2045[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2046[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2047[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2048[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2049[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2050[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2052[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2053[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2054[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2055[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2056[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2057[22];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2058[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2059[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2060[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2061[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2065[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2066[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2067[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2068[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2069[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2070[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2071[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2072[21];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2073[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2074[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2075[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2076[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2080[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2081[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2082[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2083[51];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2084[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2085[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2086[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2087[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2088[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2089[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2090[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2091[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2092[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2093[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2094[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2095[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2097[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2103[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2104[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2105[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2106[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2107[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2108[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2111[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2114[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2118[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2119[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2120[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2121[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2122[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2123[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2125[37];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2126[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2128[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2129[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2130[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2131[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2132[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2133[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2135[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2137[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2138[16];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2139[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2140[10];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2141[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2142[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2143[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2145[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2146[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2147[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2148[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2149[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2156[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2157[12];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2159[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2164[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2165[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2167[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2169[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2171[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2172[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2173[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2174[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2175[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2176[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2177[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2178[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2179[22];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2180[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2199[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2201[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2202[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2203[18];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2205[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2206[19];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2208[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2209[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2210[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2211[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2212[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2213[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2214[14];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2215[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2216[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2217[11];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2218[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2219[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2220[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2221[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2222[6];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2225[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2232[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2233[13];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2234[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2235[20];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2236[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2237[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2238[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2239[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2240[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2245[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2246[3];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2247[15];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2248[4];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2249[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2250[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2251[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2252[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2254[9];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2255[8];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2256[7];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2257[2];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2259[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2260[5];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2261[1];
IL2CPP_EXTERN_C_CONST int32_t g_FieldOffsetTable2263[7];
IL2CPP_EXTERN_C_CONST int32_t* g_FieldOffsetTable[2267] =
{
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable4,
g_FieldOffsetTable5,
g_FieldOffsetTable6,
g_FieldOffsetTable7,
g_FieldOffsetTable8,
g_FieldOffsetTable9,
NULL,
g_FieldOffsetTable11,
NULL,
g_FieldOffsetTable13,
g_FieldOffsetTable14,
g_FieldOffsetTable15,
g_FieldOffsetTable16,
NULL,
g_FieldOffsetTable18,
g_FieldOffsetTable19,
g_FieldOffsetTable20,
g_FieldOffsetTable21,
g_FieldOffsetTable22,
NULL,
NULL,
g_FieldOffsetTable25,
g_FieldOffsetTable26,
g_FieldOffsetTable27,
g_FieldOffsetTable28,
g_FieldOffsetTable29,
g_FieldOffsetTable30,
g_FieldOffsetTable31,
g_FieldOffsetTable32,
g_FieldOffsetTable33,
g_FieldOffsetTable34,
g_FieldOffsetTable35,
g_FieldOffsetTable36,
g_FieldOffsetTable37,
g_FieldOffsetTable38,
g_FieldOffsetTable39,
g_FieldOffsetTable40,
g_FieldOffsetTable41,
g_FieldOffsetTable42,
g_FieldOffsetTable43,
NULL,
NULL,
g_FieldOffsetTable46,
g_FieldOffsetTable47,
g_FieldOffsetTable48,
g_FieldOffsetTable49,
g_FieldOffsetTable50,
g_FieldOffsetTable51,
NULL,
g_FieldOffsetTable53,
NULL,
g_FieldOffsetTable55,
g_FieldOffsetTable56,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable64,
g_FieldOffsetTable65,
g_FieldOffsetTable66,
g_FieldOffsetTable67,
g_FieldOffsetTable68,
NULL,
NULL,
NULL,
g_FieldOffsetTable72,
g_FieldOffsetTable73,
g_FieldOffsetTable74,
g_FieldOffsetTable75,
g_FieldOffsetTable76,
g_FieldOffsetTable77,
g_FieldOffsetTable78,
g_FieldOffsetTable79,
g_FieldOffsetTable80,
g_FieldOffsetTable81,
g_FieldOffsetTable82,
g_FieldOffsetTable83,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable98,
NULL,
g_FieldOffsetTable100,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable105,
g_FieldOffsetTable106,
g_FieldOffsetTable107,
g_FieldOffsetTable108,
g_FieldOffsetTable109,
NULL,
g_FieldOffsetTable111,
NULL,
g_FieldOffsetTable113,
g_FieldOffsetTable114,
g_FieldOffsetTable115,
NULL,
g_FieldOffsetTable117,
g_FieldOffsetTable118,
g_FieldOffsetTable119,
g_FieldOffsetTable120,
g_FieldOffsetTable121,
g_FieldOffsetTable122,
NULL,
NULL,
g_FieldOffsetTable125,
g_FieldOffsetTable126,
g_FieldOffsetTable127,
g_FieldOffsetTable128,
g_FieldOffsetTable129,
g_FieldOffsetTable130,
g_FieldOffsetTable131,
g_FieldOffsetTable132,
g_FieldOffsetTable133,
NULL,
NULL,
NULL,
g_FieldOffsetTable137,
g_FieldOffsetTable138,
NULL,
g_FieldOffsetTable140,
g_FieldOffsetTable141,
g_FieldOffsetTable142,
NULL,
NULL,
g_FieldOffsetTable145,
g_FieldOffsetTable146,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable151,
g_FieldOffsetTable152,
NULL,
g_FieldOffsetTable154,
g_FieldOffsetTable155,
g_FieldOffsetTable156,
g_FieldOffsetTable157,
g_FieldOffsetTable158,
g_FieldOffsetTable159,
g_FieldOffsetTable160,
g_FieldOffsetTable161,
g_FieldOffsetTable162,
g_FieldOffsetTable163,
g_FieldOffsetTable164,
g_FieldOffsetTable165,
g_FieldOffsetTable166,
g_FieldOffsetTable167,
g_FieldOffsetTable168,
g_FieldOffsetTable169,
g_FieldOffsetTable170,
g_FieldOffsetTable171,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable183,
g_FieldOffsetTable184,
g_FieldOffsetTable185,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable190,
NULL,
NULL,
NULL,
g_FieldOffsetTable194,
g_FieldOffsetTable195,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable201,
NULL,
g_FieldOffsetTable203,
g_FieldOffsetTable204,
g_FieldOffsetTable205,
NULL,
NULL,
NULL,
g_FieldOffsetTable209,
NULL,
g_FieldOffsetTable211,
NULL,
g_FieldOffsetTable213,
g_FieldOffsetTable214,
g_FieldOffsetTable215,
g_FieldOffsetTable216,
g_FieldOffsetTable217,
NULL,
g_FieldOffsetTable219,
NULL,
g_FieldOffsetTable221,
NULL,
g_FieldOffsetTable223,
g_FieldOffsetTable224,
g_FieldOffsetTable225,
g_FieldOffsetTable226,
g_FieldOffsetTable227,
NULL,
NULL,
NULL,
g_FieldOffsetTable231,
g_FieldOffsetTable232,
g_FieldOffsetTable233,
g_FieldOffsetTable234,
g_FieldOffsetTable235,
g_FieldOffsetTable236,
g_FieldOffsetTable237,
g_FieldOffsetTable238,
g_FieldOffsetTable239,
g_FieldOffsetTable240,
g_FieldOffsetTable241,
NULL,
g_FieldOffsetTable243,
g_FieldOffsetTable244,
g_FieldOffsetTable245,
g_FieldOffsetTable246,
g_FieldOffsetTable247,
g_FieldOffsetTable248,
g_FieldOffsetTable249,
NULL,
g_FieldOffsetTable251,
NULL,
g_FieldOffsetTable253,
g_FieldOffsetTable254,
g_FieldOffsetTable255,
g_FieldOffsetTable256,
NULL,
g_FieldOffsetTable258,
g_FieldOffsetTable259,
g_FieldOffsetTable260,
g_FieldOffsetTable261,
NULL,
g_FieldOffsetTable263,
NULL,
g_FieldOffsetTable265,
g_FieldOffsetTable266,
g_FieldOffsetTable267,
NULL,
NULL,
g_FieldOffsetTable270,
NULL,
g_FieldOffsetTable272,
g_FieldOffsetTable273,
g_FieldOffsetTable274,
g_FieldOffsetTable275,
g_FieldOffsetTable276,
g_FieldOffsetTable277,
g_FieldOffsetTable278,
g_FieldOffsetTable279,
g_FieldOffsetTable280,
g_FieldOffsetTable281,
g_FieldOffsetTable282,
g_FieldOffsetTable283,
g_FieldOffsetTable284,
g_FieldOffsetTable285,
g_FieldOffsetTable286,
NULL,
g_FieldOffsetTable288,
NULL,
g_FieldOffsetTable290,
g_FieldOffsetTable291,
g_FieldOffsetTable292,
g_FieldOffsetTable293,
g_FieldOffsetTable294,
NULL,
g_FieldOffsetTable296,
g_FieldOffsetTable297,
NULL,
g_FieldOffsetTable299,
g_FieldOffsetTable300,
g_FieldOffsetTable301,
NULL,
g_FieldOffsetTable303,
g_FieldOffsetTable304,
g_FieldOffsetTable305,
NULL,
g_FieldOffsetTable307,
g_FieldOffsetTable308,
g_FieldOffsetTable309,
g_FieldOffsetTable310,
g_FieldOffsetTable311,
g_FieldOffsetTable312,
g_FieldOffsetTable313,
g_FieldOffsetTable314,
g_FieldOffsetTable315,
g_FieldOffsetTable316,
g_FieldOffsetTable317,
g_FieldOffsetTable318,
g_FieldOffsetTable319,
g_FieldOffsetTable320,
g_FieldOffsetTable321,
g_FieldOffsetTable322,
g_FieldOffsetTable323,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable328,
NULL,
NULL,
g_FieldOffsetTable331,
g_FieldOffsetTable332,
g_FieldOffsetTable333,
g_FieldOffsetTable334,
g_FieldOffsetTable335,
NULL,
g_FieldOffsetTable337,
g_FieldOffsetTable338,
NULL,
g_FieldOffsetTable340,
g_FieldOffsetTable341,
g_FieldOffsetTable342,
g_FieldOffsetTable343,
g_FieldOffsetTable344,
g_FieldOffsetTable345,
g_FieldOffsetTable346,
NULL,
g_FieldOffsetTable348,
g_FieldOffsetTable349,
NULL,
g_FieldOffsetTable351,
g_FieldOffsetTable352,
g_FieldOffsetTable353,
NULL,
NULL,
g_FieldOffsetTable356,
g_FieldOffsetTable357,
g_FieldOffsetTable358,
g_FieldOffsetTable359,
g_FieldOffsetTable360,
g_FieldOffsetTable361,
g_FieldOffsetTable362,
g_FieldOffsetTable363,
g_FieldOffsetTable364,
NULL,
NULL,
g_FieldOffsetTable367,
g_FieldOffsetTable368,
g_FieldOffsetTable369,
g_FieldOffsetTable370,
g_FieldOffsetTable371,
g_FieldOffsetTable372,
g_FieldOffsetTable373,
g_FieldOffsetTable374,
g_FieldOffsetTable375,
g_FieldOffsetTable376,
g_FieldOffsetTable377,
NULL,
g_FieldOffsetTable379,
g_FieldOffsetTable380,
g_FieldOffsetTable381,
g_FieldOffsetTable382,
g_FieldOffsetTable383,
g_FieldOffsetTable384,
g_FieldOffsetTable385,
g_FieldOffsetTable386,
g_FieldOffsetTable387,
g_FieldOffsetTable388,
NULL,
g_FieldOffsetTable390,
g_FieldOffsetTable391,
g_FieldOffsetTable392,
g_FieldOffsetTable393,
g_FieldOffsetTable394,
g_FieldOffsetTable395,
g_FieldOffsetTable396,
g_FieldOffsetTable397,
g_FieldOffsetTable398,
g_FieldOffsetTable399,
g_FieldOffsetTable400,
NULL,
NULL,
g_FieldOffsetTable403,
g_FieldOffsetTable404,
NULL,
g_FieldOffsetTable406,
g_FieldOffsetTable407,
g_FieldOffsetTable408,
g_FieldOffsetTable409,
g_FieldOffsetTable410,
g_FieldOffsetTable411,
g_FieldOffsetTable412,
g_FieldOffsetTable413,
g_FieldOffsetTable414,
g_FieldOffsetTable415,
NULL,
NULL,
g_FieldOffsetTable418,
g_FieldOffsetTable419,
g_FieldOffsetTable420,
g_FieldOffsetTable421,
g_FieldOffsetTable422,
g_FieldOffsetTable423,
g_FieldOffsetTable424,
g_FieldOffsetTable425,
g_FieldOffsetTable426,
g_FieldOffsetTable427,
g_FieldOffsetTable428,
g_FieldOffsetTable429,
g_FieldOffsetTable430,
g_FieldOffsetTable431,
g_FieldOffsetTable432,
NULL,
g_FieldOffsetTable434,
g_FieldOffsetTable435,
g_FieldOffsetTable436,
g_FieldOffsetTable437,
g_FieldOffsetTable438,
g_FieldOffsetTable439,
NULL,
NULL,
g_FieldOffsetTable442,
NULL,
NULL,
g_FieldOffsetTable445,
g_FieldOffsetTable446,
g_FieldOffsetTable447,
NULL,
g_FieldOffsetTable449,
g_FieldOffsetTable450,
NULL,
g_FieldOffsetTable452,
g_FieldOffsetTable453,
g_FieldOffsetTable454,
g_FieldOffsetTable455,
g_FieldOffsetTable456,
g_FieldOffsetTable457,
NULL,
NULL,
NULL,
g_FieldOffsetTable461,
NULL,
NULL,
NULL,
g_FieldOffsetTable465,
g_FieldOffsetTable466,
g_FieldOffsetTable467,
g_FieldOffsetTable468,
g_FieldOffsetTable469,
NULL,
g_FieldOffsetTable471,
g_FieldOffsetTable472,
NULL,
g_FieldOffsetTable474,
g_FieldOffsetTable475,
NULL,
g_FieldOffsetTable477,
g_FieldOffsetTable478,
g_FieldOffsetTable479,
NULL,
NULL,
g_FieldOffsetTable482,
NULL,
g_FieldOffsetTable484,
NULL,
NULL,
g_FieldOffsetTable487,
g_FieldOffsetTable488,
NULL,
g_FieldOffsetTable490,
NULL,
g_FieldOffsetTable492,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable497,
g_FieldOffsetTable498,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable503,
g_FieldOffsetTable504,
NULL,
g_FieldOffsetTable506,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable515,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable521,
NULL,
NULL,
g_FieldOffsetTable524,
g_FieldOffsetTable525,
g_FieldOffsetTable526,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable531,
g_FieldOffsetTable532,
NULL,
g_FieldOffsetTable534,
g_FieldOffsetTable535,
NULL,
g_FieldOffsetTable537,
g_FieldOffsetTable538,
NULL,
g_FieldOffsetTable540,
g_FieldOffsetTable541,
g_FieldOffsetTable542,
NULL,
g_FieldOffsetTable544,
g_FieldOffsetTable545,
NULL,
g_FieldOffsetTable547,
g_FieldOffsetTable548,
g_FieldOffsetTable549,
g_FieldOffsetTable550,
NULL,
g_FieldOffsetTable552,
g_FieldOffsetTable553,
g_FieldOffsetTable554,
NULL,
g_FieldOffsetTable556,
g_FieldOffsetTable557,
g_FieldOffsetTable558,
NULL,
g_FieldOffsetTable560,
g_FieldOffsetTable561,
g_FieldOffsetTable562,
g_FieldOffsetTable563,
NULL,
g_FieldOffsetTable565,
NULL,
g_FieldOffsetTable567,
g_FieldOffsetTable568,
g_FieldOffsetTable569,
g_FieldOffsetTable570,
g_FieldOffsetTable571,
NULL,
NULL,
g_FieldOffsetTable574,
g_FieldOffsetTable575,
g_FieldOffsetTable576,
g_FieldOffsetTable577,
g_FieldOffsetTable578,
g_FieldOffsetTable579,
g_FieldOffsetTable580,
g_FieldOffsetTable581,
g_FieldOffsetTable582,
g_FieldOffsetTable583,
NULL,
g_FieldOffsetTable585,
g_FieldOffsetTable586,
NULL,
g_FieldOffsetTable588,
g_FieldOffsetTable589,
g_FieldOffsetTable590,
g_FieldOffsetTable591,
g_FieldOffsetTable592,
g_FieldOffsetTable593,
g_FieldOffsetTable594,
g_FieldOffsetTable595,
g_FieldOffsetTable596,
g_FieldOffsetTable597,
g_FieldOffsetTable598,
g_FieldOffsetTable599,
g_FieldOffsetTable600,
g_FieldOffsetTable601,
g_FieldOffsetTable602,
g_FieldOffsetTable603,
g_FieldOffsetTable604,
g_FieldOffsetTable605,
g_FieldOffsetTable606,
g_FieldOffsetTable607,
g_FieldOffsetTable608,
g_FieldOffsetTable609,
g_FieldOffsetTable610,
g_FieldOffsetTable611,
g_FieldOffsetTable612,
g_FieldOffsetTable613,
g_FieldOffsetTable614,
g_FieldOffsetTable615,
NULL,
g_FieldOffsetTable617,
g_FieldOffsetTable618,
g_FieldOffsetTable619,
g_FieldOffsetTable620,
g_FieldOffsetTable621,
g_FieldOffsetTable622,
g_FieldOffsetTable623,
g_FieldOffsetTable624,
g_FieldOffsetTable625,
g_FieldOffsetTable626,
g_FieldOffsetTable627,
g_FieldOffsetTable628,
g_FieldOffsetTable629,
g_FieldOffsetTable630,
g_FieldOffsetTable631,
g_FieldOffsetTable632,
g_FieldOffsetTable633,
g_FieldOffsetTable634,
NULL,
g_FieldOffsetTable636,
g_FieldOffsetTable637,
g_FieldOffsetTable638,
g_FieldOffsetTable639,
g_FieldOffsetTable640,
g_FieldOffsetTable641,
g_FieldOffsetTable642,
g_FieldOffsetTable643,
g_FieldOffsetTable644,
NULL,
g_FieldOffsetTable646,
g_FieldOffsetTable647,
g_FieldOffsetTable648,
g_FieldOffsetTable649,
NULL,
g_FieldOffsetTable651,
g_FieldOffsetTable652,
g_FieldOffsetTable653,
NULL,
g_FieldOffsetTable655,
NULL,
NULL,
g_FieldOffsetTable658,
NULL,
NULL,
g_FieldOffsetTable661,
g_FieldOffsetTable662,
g_FieldOffsetTable663,
g_FieldOffsetTable664,
g_FieldOffsetTable665,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable675,
g_FieldOffsetTable676,
g_FieldOffsetTable677,
NULL,
g_FieldOffsetTable679,
g_FieldOffsetTable680,
g_FieldOffsetTable681,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable687,
g_FieldOffsetTable688,
g_FieldOffsetTable689,
g_FieldOffsetTable690,
g_FieldOffsetTable691,
g_FieldOffsetTable692,
NULL,
g_FieldOffsetTable694,
NULL,
NULL,
g_FieldOffsetTable697,
NULL,
g_FieldOffsetTable699,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable704,
g_FieldOffsetTable705,
g_FieldOffsetTable706,
NULL,
g_FieldOffsetTable708,
g_FieldOffsetTable709,
NULL,
NULL,
g_FieldOffsetTable712,
g_FieldOffsetTable713,
g_FieldOffsetTable714,
g_FieldOffsetTable715,
NULL,
g_FieldOffsetTable717,
g_FieldOffsetTable718,
NULL,
g_FieldOffsetTable720,
g_FieldOffsetTable721,
g_FieldOffsetTable722,
g_FieldOffsetTable723,
NULL,
g_FieldOffsetTable725,
g_FieldOffsetTable726,
g_FieldOffsetTable727,
g_FieldOffsetTable728,
g_FieldOffsetTable729,
NULL,
g_FieldOffsetTable731,
g_FieldOffsetTable732,
g_FieldOffsetTable733,
g_FieldOffsetTable734,
NULL,
NULL,
g_FieldOffsetTable737,
g_FieldOffsetTable738,
NULL,
g_FieldOffsetTable740,
g_FieldOffsetTable741,
g_FieldOffsetTable742,
g_FieldOffsetTable743,
g_FieldOffsetTable744,
g_FieldOffsetTable745,
g_FieldOffsetTable746,
g_FieldOffsetTable747,
g_FieldOffsetTable748,
g_FieldOffsetTable749,
NULL,
g_FieldOffsetTable751,
g_FieldOffsetTable752,
NULL,
g_FieldOffsetTable754,
g_FieldOffsetTable755,
g_FieldOffsetTable756,
g_FieldOffsetTable757,
NULL,
NULL,
g_FieldOffsetTable760,
g_FieldOffsetTable761,
NULL,
NULL,
NULL,
g_FieldOffsetTable765,
NULL,
NULL,
NULL,
g_FieldOffsetTable769,
g_FieldOffsetTable770,
g_FieldOffsetTable771,
g_FieldOffsetTable772,
NULL,
NULL,
NULL,
g_FieldOffsetTable776,
g_FieldOffsetTable777,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable785,
g_FieldOffsetTable786,
g_FieldOffsetTable787,
g_FieldOffsetTable788,
g_FieldOffsetTable789,
g_FieldOffsetTable790,
g_FieldOffsetTable791,
g_FieldOffsetTable792,
g_FieldOffsetTable793,
g_FieldOffsetTable794,
g_FieldOffsetTable795,
NULL,
g_FieldOffsetTable797,
g_FieldOffsetTable798,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable804,
g_FieldOffsetTable805,
g_FieldOffsetTable806,
g_FieldOffsetTable807,
g_FieldOffsetTable808,
g_FieldOffsetTable809,
g_FieldOffsetTable810,
g_FieldOffsetTable811,
g_FieldOffsetTable812,
g_FieldOffsetTable813,
g_FieldOffsetTable814,
g_FieldOffsetTable815,
g_FieldOffsetTable816,
g_FieldOffsetTable817,
NULL,
NULL,
g_FieldOffsetTable820,
g_FieldOffsetTable821,
g_FieldOffsetTable822,
g_FieldOffsetTable823,
g_FieldOffsetTable824,
g_FieldOffsetTable825,
g_FieldOffsetTable826,
g_FieldOffsetTable827,
g_FieldOffsetTable828,
g_FieldOffsetTable829,
g_FieldOffsetTable830,
g_FieldOffsetTable831,
g_FieldOffsetTable832,
g_FieldOffsetTable833,
g_FieldOffsetTable834,
g_FieldOffsetTable835,
g_FieldOffsetTable836,
NULL,
g_FieldOffsetTable838,
g_FieldOffsetTable839,
g_FieldOffsetTable840,
g_FieldOffsetTable841,
g_FieldOffsetTable842,
g_FieldOffsetTable843,
g_FieldOffsetTable844,
g_FieldOffsetTable845,
g_FieldOffsetTable846,
g_FieldOffsetTable847,
g_FieldOffsetTable848,
g_FieldOffsetTable849,
g_FieldOffsetTable850,
g_FieldOffsetTable851,
g_FieldOffsetTable852,
g_FieldOffsetTable853,
g_FieldOffsetTable854,
g_FieldOffsetTable855,
g_FieldOffsetTable856,
g_FieldOffsetTable857,
g_FieldOffsetTable858,
g_FieldOffsetTable859,
g_FieldOffsetTable860,
g_FieldOffsetTable861,
g_FieldOffsetTable862,
g_FieldOffsetTable863,
g_FieldOffsetTable864,
g_FieldOffsetTable865,
g_FieldOffsetTable866,
g_FieldOffsetTable867,
g_FieldOffsetTable868,
g_FieldOffsetTable869,
g_FieldOffsetTable870,
g_FieldOffsetTable871,
g_FieldOffsetTable872,
g_FieldOffsetTable873,
g_FieldOffsetTable874,
g_FieldOffsetTable875,
g_FieldOffsetTable876,
g_FieldOffsetTable877,
g_FieldOffsetTable878,
g_FieldOffsetTable879,
NULL,
NULL,
NULL,
g_FieldOffsetTable883,
g_FieldOffsetTable884,
g_FieldOffsetTable885,
g_FieldOffsetTable886,
g_FieldOffsetTable887,
g_FieldOffsetTable888,
g_FieldOffsetTable889,
g_FieldOffsetTable890,
NULL,
NULL,
g_FieldOffsetTable893,
g_FieldOffsetTable894,
g_FieldOffsetTable895,
g_FieldOffsetTable896,
NULL,
NULL,
g_FieldOffsetTable899,
g_FieldOffsetTable900,
g_FieldOffsetTable901,
g_FieldOffsetTable902,
g_FieldOffsetTable903,
g_FieldOffsetTable904,
g_FieldOffsetTable905,
g_FieldOffsetTable906,
NULL,
g_FieldOffsetTable908,
NULL,
g_FieldOffsetTable910,
g_FieldOffsetTable911,
g_FieldOffsetTable912,
NULL,
NULL,
NULL,
g_FieldOffsetTable916,
g_FieldOffsetTable917,
g_FieldOffsetTable918,
g_FieldOffsetTable919,
g_FieldOffsetTable920,
g_FieldOffsetTable921,
g_FieldOffsetTable922,
g_FieldOffsetTable923,
NULL,
g_FieldOffsetTable925,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable937,
g_FieldOffsetTable938,
g_FieldOffsetTable939,
g_FieldOffsetTable940,
g_FieldOffsetTable941,
NULL,
g_FieldOffsetTable943,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable951,
g_FieldOffsetTable952,
g_FieldOffsetTable953,
NULL,
g_FieldOffsetTable955,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable960,
g_FieldOffsetTable961,
g_FieldOffsetTable962,
NULL,
g_FieldOffsetTable964,
NULL,
g_FieldOffsetTable966,
g_FieldOffsetTable967,
g_FieldOffsetTable968,
g_FieldOffsetTable969,
g_FieldOffsetTable970,
g_FieldOffsetTable971,
g_FieldOffsetTable972,
g_FieldOffsetTable973,
g_FieldOffsetTable974,
g_FieldOffsetTable975,
g_FieldOffsetTable976,
g_FieldOffsetTable977,
g_FieldOffsetTable978,
g_FieldOffsetTable979,
g_FieldOffsetTable980,
g_FieldOffsetTable981,
g_FieldOffsetTable982,
g_FieldOffsetTable983,
NULL,
g_FieldOffsetTable985,
g_FieldOffsetTable986,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable996,
g_FieldOffsetTable997,
g_FieldOffsetTable998,
g_FieldOffsetTable999,
g_FieldOffsetTable1000,
g_FieldOffsetTable1001,
g_FieldOffsetTable1002,
g_FieldOffsetTable1003,
NULL,
NULL,
NULL,
g_FieldOffsetTable1007,
g_FieldOffsetTable1008,
NULL,
g_FieldOffsetTable1010,
g_FieldOffsetTable1011,
g_FieldOffsetTable1012,
NULL,
NULL,
g_FieldOffsetTable1015,
NULL,
g_FieldOffsetTable1017,
g_FieldOffsetTable1018,
g_FieldOffsetTable1019,
g_FieldOffsetTable1020,
g_FieldOffsetTable1021,
g_FieldOffsetTable1022,
g_FieldOffsetTable1023,
g_FieldOffsetTable1024,
g_FieldOffsetTable1025,
g_FieldOffsetTable1026,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1031,
g_FieldOffsetTable1032,
g_FieldOffsetTable1033,
g_FieldOffsetTable1034,
g_FieldOffsetTable1035,
g_FieldOffsetTable1036,
g_FieldOffsetTable1037,
g_FieldOffsetTable1038,
g_FieldOffsetTable1039,
g_FieldOffsetTable1040,
g_FieldOffsetTable1041,
g_FieldOffsetTable1042,
NULL,
NULL,
g_FieldOffsetTable1045,
g_FieldOffsetTable1046,
NULL,
g_FieldOffsetTable1048,
g_FieldOffsetTable1049,
NULL,
NULL,
g_FieldOffsetTable1052,
NULL,
NULL,
NULL,
g_FieldOffsetTable1056,
NULL,
g_FieldOffsetTable1058,
NULL,
g_FieldOffsetTable1060,
g_FieldOffsetTable1061,
g_FieldOffsetTable1062,
g_FieldOffsetTable1063,
g_FieldOffsetTable1064,
g_FieldOffsetTable1065,
g_FieldOffsetTable1066,
g_FieldOffsetTable1067,
g_FieldOffsetTable1068,
g_FieldOffsetTable1069,
NULL,
g_FieldOffsetTable1071,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1076,
g_FieldOffsetTable1077,
g_FieldOffsetTable1078,
g_FieldOffsetTable1079,
g_FieldOffsetTable1080,
g_FieldOffsetTable1081,
g_FieldOffsetTable1082,
NULL,
g_FieldOffsetTable1084,
NULL,
NULL,
NULL,
g_FieldOffsetTable1088,
g_FieldOffsetTable1089,
g_FieldOffsetTable1090,
g_FieldOffsetTable1091,
g_FieldOffsetTable1092,
g_FieldOffsetTable1093,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1109,
g_FieldOffsetTable1110,
g_FieldOffsetTable1111,
NULL,
g_FieldOffsetTable1113,
g_FieldOffsetTable1114,
g_FieldOffsetTable1115,
g_FieldOffsetTable1116,
g_FieldOffsetTable1117,
NULL,
NULL,
g_FieldOffsetTable1120,
g_FieldOffsetTable1121,
g_FieldOffsetTable1122,
g_FieldOffsetTable1123,
NULL,
g_FieldOffsetTable1125,
g_FieldOffsetTable1126,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1138,
g_FieldOffsetTable1139,
g_FieldOffsetTable1140,
g_FieldOffsetTable1141,
NULL,
g_FieldOffsetTable1143,
g_FieldOffsetTable1144,
NULL,
g_FieldOffsetTable1146,
g_FieldOffsetTable1147,
NULL,
g_FieldOffsetTable1149,
g_FieldOffsetTable1150,
g_FieldOffsetTable1151,
g_FieldOffsetTable1152,
g_FieldOffsetTable1153,
g_FieldOffsetTable1154,
g_FieldOffsetTable1155,
g_FieldOffsetTable1156,
NULL,
NULL,
NULL,
g_FieldOffsetTable1160,
NULL,
NULL,
g_FieldOffsetTable1163,
g_FieldOffsetTable1164,
g_FieldOffsetTable1165,
g_FieldOffsetTable1166,
g_FieldOffsetTable1167,
g_FieldOffsetTable1168,
g_FieldOffsetTable1169,
g_FieldOffsetTable1170,
g_FieldOffsetTable1171,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1176,
g_FieldOffsetTable1177,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1182,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1203,
g_FieldOffsetTable1204,
NULL,
NULL,
NULL,
g_FieldOffsetTable1208,
g_FieldOffsetTable1209,
g_FieldOffsetTable1210,
g_FieldOffsetTable1211,
g_FieldOffsetTable1212,
g_FieldOffsetTable1213,
g_FieldOffsetTable1214,
g_FieldOffsetTable1215,
g_FieldOffsetTable1216,
g_FieldOffsetTable1217,
NULL,
g_FieldOffsetTable1219,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1261,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1271,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1278,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1283,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1288,
g_FieldOffsetTable1289,
g_FieldOffsetTable1290,
g_FieldOffsetTable1291,
g_FieldOffsetTable1292,
g_FieldOffsetTable1293,
NULL,
g_FieldOffsetTable1295,
g_FieldOffsetTable1296,
g_FieldOffsetTable1297,
g_FieldOffsetTable1298,
g_FieldOffsetTable1299,
g_FieldOffsetTable1300,
g_FieldOffsetTable1301,
g_FieldOffsetTable1302,
NULL,
g_FieldOffsetTable1304,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1309,
g_FieldOffsetTable1310,
NULL,
g_FieldOffsetTable1312,
g_FieldOffsetTable1313,
NULL,
g_FieldOffsetTable1315,
NULL,
g_FieldOffsetTable1317,
NULL,
NULL,
NULL,
g_FieldOffsetTable1321,
g_FieldOffsetTable1322,
g_FieldOffsetTable1323,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1331,
g_FieldOffsetTable1332,
g_FieldOffsetTable1333,
NULL,
g_FieldOffsetTable1335,
g_FieldOffsetTable1336,
g_FieldOffsetTable1337,
g_FieldOffsetTable1338,
NULL,
g_FieldOffsetTable1340,
g_FieldOffsetTable1341,
g_FieldOffsetTable1342,
g_FieldOffsetTable1343,
NULL,
g_FieldOffsetTable1345,
g_FieldOffsetTable1346,
g_FieldOffsetTable1347,
g_FieldOffsetTable1348,
g_FieldOffsetTable1349,
g_FieldOffsetTable1350,
g_FieldOffsetTable1351,
g_FieldOffsetTable1352,
NULL,
NULL,
g_FieldOffsetTable1355,
g_FieldOffsetTable1356,
g_FieldOffsetTable1357,
g_FieldOffsetTable1358,
g_FieldOffsetTable1359,
NULL,
g_FieldOffsetTable1361,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1385,
g_FieldOffsetTable1386,
g_FieldOffsetTable1387,
g_FieldOffsetTable1388,
g_FieldOffsetTable1389,
NULL,
NULL,
g_FieldOffsetTable1392,
g_FieldOffsetTable1393,
g_FieldOffsetTable1394,
NULL,
g_FieldOffsetTable1396,
g_FieldOffsetTable1397,
g_FieldOffsetTable1398,
g_FieldOffsetTable1399,
g_FieldOffsetTable1400,
NULL,
NULL,
g_FieldOffsetTable1403,
NULL,
NULL,
NULL,
g_FieldOffsetTable1407,
NULL,
NULL,
g_FieldOffsetTable1410,
g_FieldOffsetTable1411,
g_FieldOffsetTable1412,
g_FieldOffsetTable1413,
g_FieldOffsetTable1414,
g_FieldOffsetTable1415,
g_FieldOffsetTable1416,
NULL,
g_FieldOffsetTable1418,
g_FieldOffsetTable1419,
NULL,
NULL,
g_FieldOffsetTable1422,
g_FieldOffsetTable1423,
g_FieldOffsetTable1424,
g_FieldOffsetTable1425,
NULL,
NULL,
g_FieldOffsetTable1428,
NULL,
NULL,
NULL,
g_FieldOffsetTable1432,
g_FieldOffsetTable1433,
g_FieldOffsetTable1434,
NULL,
g_FieldOffsetTable1436,
NULL,
g_FieldOffsetTable1438,
g_FieldOffsetTable1439,
g_FieldOffsetTable1440,
g_FieldOffsetTable1441,
g_FieldOffsetTable1442,
g_FieldOffsetTable1443,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1450,
g_FieldOffsetTable1451,
g_FieldOffsetTable1452,
g_FieldOffsetTable1453,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1469,
g_FieldOffsetTable1470,
g_FieldOffsetTable1471,
g_FieldOffsetTable1472,
g_FieldOffsetTable1473,
g_FieldOffsetTable1474,
g_FieldOffsetTable1475,
NULL,
NULL,
g_FieldOffsetTable1478,
g_FieldOffsetTable1479,
g_FieldOffsetTable1480,
g_FieldOffsetTable1481,
g_FieldOffsetTable1482,
g_FieldOffsetTable1483,
NULL,
g_FieldOffsetTable1485,
g_FieldOffsetTable1486,
NULL,
g_FieldOffsetTable1488,
g_FieldOffsetTable1489,
g_FieldOffsetTable1490,
NULL,
g_FieldOffsetTable1492,
NULL,
g_FieldOffsetTable1494,
g_FieldOffsetTable1495,
g_FieldOffsetTable1496,
g_FieldOffsetTable1497,
g_FieldOffsetTable1498,
g_FieldOffsetTable1499,
g_FieldOffsetTable1500,
g_FieldOffsetTable1501,
NULL,
g_FieldOffsetTable1503,
g_FieldOffsetTable1504,
NULL,
NULL,
g_FieldOffsetTable1507,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1513,
g_FieldOffsetTable1514,
NULL,
g_FieldOffsetTable1516,
g_FieldOffsetTable1517,
g_FieldOffsetTable1518,
g_FieldOffsetTable1519,
g_FieldOffsetTable1520,
g_FieldOffsetTable1521,
g_FieldOffsetTable1522,
g_FieldOffsetTable1523,
g_FieldOffsetTable1524,
g_FieldOffsetTable1525,
g_FieldOffsetTable1526,
g_FieldOffsetTable1527,
g_FieldOffsetTable1528,
g_FieldOffsetTable1529,
g_FieldOffsetTable1530,
NULL,
g_FieldOffsetTable1532,
NULL,
g_FieldOffsetTable1534,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1542,
g_FieldOffsetTable1543,
NULL,
g_FieldOffsetTable1545,
NULL,
NULL,
g_FieldOffsetTable1548,
g_FieldOffsetTable1549,
g_FieldOffsetTable1550,
g_FieldOffsetTable1551,
g_FieldOffsetTable1552,
g_FieldOffsetTable1553,
g_FieldOffsetTable1554,
g_FieldOffsetTable1555,
g_FieldOffsetTable1556,
g_FieldOffsetTable1557,
g_FieldOffsetTable1558,
NULL,
NULL,
NULL,
g_FieldOffsetTable1562,
g_FieldOffsetTable1563,
g_FieldOffsetTable1564,
g_FieldOffsetTable1565,
NULL,
g_FieldOffsetTable1567,
NULL,
g_FieldOffsetTable1569,
g_FieldOffsetTable1570,
NULL,
g_FieldOffsetTable1572,
g_FieldOffsetTable1573,
g_FieldOffsetTable1574,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1579,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1585,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1592,
NULL,
NULL,
NULL,
g_FieldOffsetTable1596,
g_FieldOffsetTable1597,
g_FieldOffsetTable1598,
NULL,
g_FieldOffsetTable1600,
NULL,
NULL,
g_FieldOffsetTable1603,
NULL,
g_FieldOffsetTable1605,
NULL,
g_FieldOffsetTable1607,
g_FieldOffsetTable1608,
NULL,
g_FieldOffsetTable1610,
g_FieldOffsetTable1611,
g_FieldOffsetTable1612,
g_FieldOffsetTable1613,
NULL,
NULL,
g_FieldOffsetTable1616,
g_FieldOffsetTable1617,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1626,
NULL,
NULL,
g_FieldOffsetTable1629,
g_FieldOffsetTable1630,
g_FieldOffsetTable1631,
g_FieldOffsetTable1632,
g_FieldOffsetTable1633,
NULL,
g_FieldOffsetTable1635,
NULL,
g_FieldOffsetTable1637,
g_FieldOffsetTable1638,
NULL,
NULL,
g_FieldOffsetTable1641,
NULL,
NULL,
NULL,
g_FieldOffsetTable1645,
g_FieldOffsetTable1646,
NULL,
g_FieldOffsetTable1648,
g_FieldOffsetTable1649,
g_FieldOffsetTable1650,
g_FieldOffsetTable1651,
NULL,
g_FieldOffsetTable1653,
NULL,
g_FieldOffsetTable1655,
g_FieldOffsetTable1656,
g_FieldOffsetTable1657,
g_FieldOffsetTable1658,
g_FieldOffsetTable1659,
g_FieldOffsetTable1660,
g_FieldOffsetTable1661,
g_FieldOffsetTable1662,
g_FieldOffsetTable1663,
g_FieldOffsetTable1664,
g_FieldOffsetTable1665,
NULL,
g_FieldOffsetTable1667,
NULL,
g_FieldOffsetTable1669,
NULL,
g_FieldOffsetTable1671,
NULL,
g_FieldOffsetTable1673,
NULL,
g_FieldOffsetTable1675,
g_FieldOffsetTable1676,
NULL,
g_FieldOffsetTable1678,
g_FieldOffsetTable1679,
g_FieldOffsetTable1680,
NULL,
g_FieldOffsetTable1682,
g_FieldOffsetTable1683,
g_FieldOffsetTable1684,
g_FieldOffsetTable1685,
g_FieldOffsetTable1686,
g_FieldOffsetTable1687,
NULL,
g_FieldOffsetTable1689,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1820,
g_FieldOffsetTable1821,
g_FieldOffsetTable1822,
g_FieldOffsetTable1823,
g_FieldOffsetTable1824,
NULL,
NULL,
g_FieldOffsetTable1827,
g_FieldOffsetTable1828,
g_FieldOffsetTable1829,
g_FieldOffsetTable1830,
g_FieldOffsetTable1831,
g_FieldOffsetTable1832,
NULL,
g_FieldOffsetTable1834,
g_FieldOffsetTable1835,
g_FieldOffsetTable1836,
g_FieldOffsetTable1837,
g_FieldOffsetTable1838,
g_FieldOffsetTable1839,
g_FieldOffsetTable1840,
g_FieldOffsetTable1841,
g_FieldOffsetTable1842,
NULL,
g_FieldOffsetTable1844,
g_FieldOffsetTable1845,
g_FieldOffsetTable1846,
NULL,
g_FieldOffsetTable1848,
g_FieldOffsetTable1849,
g_FieldOffsetTable1850,
g_FieldOffsetTable1851,
g_FieldOffsetTable1852,
g_FieldOffsetTable1853,
g_FieldOffsetTable1854,
g_FieldOffsetTable1855,
g_FieldOffsetTable1856,
NULL,
g_FieldOffsetTable1858,
g_FieldOffsetTable1859,
g_FieldOffsetTable1860,
g_FieldOffsetTable1861,
NULL,
NULL,
NULL,
g_FieldOffsetTable1865,
NULL,
NULL,
NULL,
g_FieldOffsetTable1869,
g_FieldOffsetTable1870,
g_FieldOffsetTable1871,
g_FieldOffsetTable1872,
g_FieldOffsetTable1873,
g_FieldOffsetTable1874,
g_FieldOffsetTable1875,
NULL,
g_FieldOffsetTable1877,
g_FieldOffsetTable1878,
g_FieldOffsetTable1879,
g_FieldOffsetTable1880,
g_FieldOffsetTable1881,
g_FieldOffsetTable1882,
g_FieldOffsetTable1883,
g_FieldOffsetTable1884,
g_FieldOffsetTable1885,
g_FieldOffsetTable1886,
g_FieldOffsetTable1887,
g_FieldOffsetTable1888,
NULL,
NULL,
g_FieldOffsetTable1891,
g_FieldOffsetTable1892,
g_FieldOffsetTable1893,
g_FieldOffsetTable1894,
g_FieldOffsetTable1895,
g_FieldOffsetTable1896,
NULL,
NULL,
g_FieldOffsetTable1899,
g_FieldOffsetTable1900,
g_FieldOffsetTable1901,
g_FieldOffsetTable1902,
g_FieldOffsetTable1903,
g_FieldOffsetTable1904,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1909,
g_FieldOffsetTable1910,
g_FieldOffsetTable1911,
g_FieldOffsetTable1912,
NULL,
NULL,
g_FieldOffsetTable1915,
g_FieldOffsetTable1916,
NULL,
g_FieldOffsetTable1918,
g_FieldOffsetTable1919,
g_FieldOffsetTable1920,
g_FieldOffsetTable1921,
g_FieldOffsetTable1922,
g_FieldOffsetTable1923,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable1930,
g_FieldOffsetTable1931,
g_FieldOffsetTable1932,
g_FieldOffsetTable1933,
g_FieldOffsetTable1934,
g_FieldOffsetTable1935,
g_FieldOffsetTable1936,
g_FieldOffsetTable1937,
g_FieldOffsetTable1938,
g_FieldOffsetTable1939,
NULL,
g_FieldOffsetTable1941,
NULL,
NULL,
NULL,
g_FieldOffsetTable1945,
NULL,
g_FieldOffsetTable1947,
g_FieldOffsetTable1948,
g_FieldOffsetTable1949,
g_FieldOffsetTable1950,
NULL,
NULL,
g_FieldOffsetTable1953,
g_FieldOffsetTable1954,
g_FieldOffsetTable1955,
g_FieldOffsetTable1956,
NULL,
NULL,
g_FieldOffsetTable1959,
g_FieldOffsetTable1960,
g_FieldOffsetTable1961,
g_FieldOffsetTable1962,
g_FieldOffsetTable1963,
g_FieldOffsetTable1964,
g_FieldOffsetTable1965,
g_FieldOffsetTable1966,
g_FieldOffsetTable1967,
g_FieldOffsetTable1968,
g_FieldOffsetTable1969,
g_FieldOffsetTable1970,
NULL,
g_FieldOffsetTable1972,
g_FieldOffsetTable1973,
g_FieldOffsetTable1974,
NULL,
g_FieldOffsetTable1976,
g_FieldOffsetTable1977,
NULL,
g_FieldOffsetTable1979,
g_FieldOffsetTable1980,
g_FieldOffsetTable1981,
g_FieldOffsetTable1982,
g_FieldOffsetTable1983,
NULL,
g_FieldOffsetTable1985,
g_FieldOffsetTable1986,
g_FieldOffsetTable1987,
g_FieldOffsetTable1988,
g_FieldOffsetTable1989,
NULL,
g_FieldOffsetTable1991,
g_FieldOffsetTable1992,
g_FieldOffsetTable1993,
NULL,
NULL,
g_FieldOffsetTable1996,
g_FieldOffsetTable1997,
NULL,
g_FieldOffsetTable1999,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable2010,
g_FieldOffsetTable2011,
g_FieldOffsetTable2012,
NULL,
g_FieldOffsetTable2014,
g_FieldOffsetTable2015,
NULL,
NULL,
NULL,
g_FieldOffsetTable2019,
NULL,
NULL,
g_FieldOffsetTable2022,
NULL,
NULL,
NULL,
g_FieldOffsetTable2026,
g_FieldOffsetTable2027,
g_FieldOffsetTable2028,
g_FieldOffsetTable2029,
NULL,
g_FieldOffsetTable2031,
NULL,
g_FieldOffsetTable2033,
g_FieldOffsetTable2034,
g_FieldOffsetTable2035,
NULL,
g_FieldOffsetTable2037,
g_FieldOffsetTable2038,
g_FieldOffsetTable2039,
NULL,
NULL,
NULL,
g_FieldOffsetTable2043,
NULL,
g_FieldOffsetTable2045,
g_FieldOffsetTable2046,
g_FieldOffsetTable2047,
g_FieldOffsetTable2048,
g_FieldOffsetTable2049,
g_FieldOffsetTable2050,
NULL,
g_FieldOffsetTable2052,
g_FieldOffsetTable2053,
g_FieldOffsetTable2054,
g_FieldOffsetTable2055,
g_FieldOffsetTable2056,
g_FieldOffsetTable2057,
g_FieldOffsetTable2058,
g_FieldOffsetTable2059,
g_FieldOffsetTable2060,
g_FieldOffsetTable2061,
NULL,
NULL,
NULL,
g_FieldOffsetTable2065,
g_FieldOffsetTable2066,
g_FieldOffsetTable2067,
g_FieldOffsetTable2068,
g_FieldOffsetTable2069,
g_FieldOffsetTable2070,
g_FieldOffsetTable2071,
g_FieldOffsetTable2072,
g_FieldOffsetTable2073,
g_FieldOffsetTable2074,
g_FieldOffsetTable2075,
g_FieldOffsetTable2076,
NULL,
NULL,
NULL,
g_FieldOffsetTable2080,
g_FieldOffsetTable2081,
g_FieldOffsetTable2082,
g_FieldOffsetTable2083,
g_FieldOffsetTable2084,
g_FieldOffsetTable2085,
g_FieldOffsetTable2086,
g_FieldOffsetTable2087,
g_FieldOffsetTable2088,
g_FieldOffsetTable2089,
g_FieldOffsetTable2090,
g_FieldOffsetTable2091,
g_FieldOffsetTable2092,
g_FieldOffsetTable2093,
g_FieldOffsetTable2094,
g_FieldOffsetTable2095,
NULL,
g_FieldOffsetTable2097,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable2103,
g_FieldOffsetTable2104,
g_FieldOffsetTable2105,
g_FieldOffsetTable2106,
g_FieldOffsetTable2107,
g_FieldOffsetTable2108,
NULL,
NULL,
g_FieldOffsetTable2111,
NULL,
NULL,
g_FieldOffsetTable2114,
NULL,
NULL,
NULL,
g_FieldOffsetTable2118,
g_FieldOffsetTable2119,
g_FieldOffsetTable2120,
g_FieldOffsetTable2121,
g_FieldOffsetTable2122,
g_FieldOffsetTable2123,
NULL,
g_FieldOffsetTable2125,
g_FieldOffsetTable2126,
NULL,
g_FieldOffsetTable2128,
g_FieldOffsetTable2129,
g_FieldOffsetTable2130,
g_FieldOffsetTable2131,
g_FieldOffsetTable2132,
g_FieldOffsetTable2133,
NULL,
g_FieldOffsetTable2135,
NULL,
g_FieldOffsetTable2137,
g_FieldOffsetTable2138,
g_FieldOffsetTable2139,
g_FieldOffsetTable2140,
g_FieldOffsetTable2141,
g_FieldOffsetTable2142,
g_FieldOffsetTable2143,
NULL,
g_FieldOffsetTable2145,
g_FieldOffsetTable2146,
g_FieldOffsetTable2147,
g_FieldOffsetTable2148,
g_FieldOffsetTable2149,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable2156,
g_FieldOffsetTable2157,
NULL,
g_FieldOffsetTable2159,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable2164,
g_FieldOffsetTable2165,
NULL,
g_FieldOffsetTable2167,
NULL,
g_FieldOffsetTable2169,
NULL,
g_FieldOffsetTable2171,
g_FieldOffsetTable2172,
g_FieldOffsetTable2173,
g_FieldOffsetTable2174,
g_FieldOffsetTable2175,
g_FieldOffsetTable2176,
g_FieldOffsetTable2177,
g_FieldOffsetTable2178,
g_FieldOffsetTable2179,
g_FieldOffsetTable2180,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable2199,
NULL,
g_FieldOffsetTable2201,
g_FieldOffsetTable2202,
g_FieldOffsetTable2203,
NULL,
g_FieldOffsetTable2205,
g_FieldOffsetTable2206,
NULL,
g_FieldOffsetTable2208,
g_FieldOffsetTable2209,
g_FieldOffsetTable2210,
g_FieldOffsetTable2211,
g_FieldOffsetTable2212,
g_FieldOffsetTable2213,
g_FieldOffsetTable2214,
g_FieldOffsetTable2215,
g_FieldOffsetTable2216,
g_FieldOffsetTable2217,
g_FieldOffsetTable2218,
g_FieldOffsetTable2219,
g_FieldOffsetTable2220,
g_FieldOffsetTable2221,
g_FieldOffsetTable2222,
NULL,
NULL,
g_FieldOffsetTable2225,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable2232,
g_FieldOffsetTable2233,
g_FieldOffsetTable2234,
g_FieldOffsetTable2235,
g_FieldOffsetTable2236,
g_FieldOffsetTable2237,
g_FieldOffsetTable2238,
g_FieldOffsetTable2239,
g_FieldOffsetTable2240,
NULL,
NULL,
NULL,
NULL,
g_FieldOffsetTable2245,
g_FieldOffsetTable2246,
g_FieldOffsetTable2247,
g_FieldOffsetTable2248,
g_FieldOffsetTable2249,
g_FieldOffsetTable2250,
g_FieldOffsetTable2251,
g_FieldOffsetTable2252,
NULL,
g_FieldOffsetTable2254,
g_FieldOffsetTable2255,
g_FieldOffsetTable2256,
g_FieldOffsetTable2257,
NULL,
g_FieldOffsetTable2259,
g_FieldOffsetTable2260,
g_FieldOffsetTable2261,
NULL,
g_FieldOffsetTable2263,
NULL,
NULL,
NULL,
};
| [
"TheSchlote@gmail.com"
] | TheSchlote@gmail.com |
c780c67a1f398d34f8a5465768653adc5d5b1992 | 48e3e1c0aaaf1fa1b2cc1df95af0f25cc386a733 | /src/flare/gl/transformfeedbackbuffermanager.cpp | 6510fde03074cf54bd4479337e33eaf7cfa7261b | [] | no_license | velocic/OpenGL-Superbible-Workthrough | 6fc9410cecef7de0468945097e28d417718f83c6 | 6727d021d2824fccca1f7d81d41b2f2e5bf8d009 | refs/heads/master | 2021-08-29T07:21:40.030276 | 2021-08-20T20:54:51 | 2021-08-20T20:54:51 | 142,960,051 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,014 | cpp | #include <flare/gl/transformfeedbackbuffermanager.h>
#include <flare/gl/shaderprogram.h>
#include <flare/rendersystem/factory.h>
namespace Flare
{
namespace GL
{
TransformFeedbackBufferManager::~TransformFeedbackBufferManager()
{
clear();
}
TransformFeedbackBufferManager::TransformFeedbackBufferManager(TransformFeedbackBufferManager &&other)
:
transformFeedbackBufferMap(std::move(other.transformFeedbackBufferMap)),
buffersCreated(std::exchange(other.buffersCreated, 0)),
isCurrentlyEnabled(std::exchange(other.isCurrentlyEnabled, false))
{
}
TransformFeedbackBufferManager &TransformFeedbackBufferManager::operator=(TransformFeedbackBufferManager &&other)
{
transformFeedbackBufferMap = std::move(other.transformFeedbackBufferMap);
buffersCreated = std::exchange(other.buffersCreated, 0);
isCurrentlyEnabled = std::exchange(other.isCurrentlyEnabled, false);
return *this;
}
const RenderSystem::Buffer *TransformFeedbackBufferManager::create(RenderSystem::ShaderData shaderData, const RenderSystem::VertexDataLayout &bufferLayout, RenderSystem::RSsizei bufferSizeInBytes, RenderSystem::RSbitfield bufferUsageFlags, const std::vector<std::string> &varyings, void *initialData)
{
auto buffers = DoubleBuffer{};
buffers.readBuffer = RenderSystem::createBuffer(
createdReadBufferBaseName + std::to_string(buffersCreated),
bufferLayout,
RenderSystem::BufferType::TRANSFORMFEEDBACK
);
buffers.readBuffer->allocateBufferStorage(bufferSizeInBytes, initialData, bufferUsageFlags);
buffers.writeBuffer = RenderSystem::createBuffer(
createdWriteBufferBaseName + std::to_string(buffersCreated++),
bufferLayout,
RenderSystem::BufferType::TRANSFORMFEEDBACK
);
buffers.writeBuffer->allocateBufferStorage(bufferSizeInBytes, nullptr, bufferUsageFlags);
buffers.writeBuffer->copyRange(*buffers.readBuffer, 0, 0, bufferSizeInBytes);
auto CStringVaryings = std::vector<const char *>{};
CStringVaryings.reserve(varyings.size());
std::transform(
varyings.begin(),
varyings.end(),
CStringVaryings.begin(),
[](const auto &inputString){
return inputString.c_str();
}
);
glTransformFeedbackVaryings(
shaderData.shader->getProgramId(),
varyings.size(),
CStringVaryings.data(),
GL_INTERLEAVED_ATTRIBS
);
auto result = buffers.readBuffer.get();
transformFeedbackBufferMap.insert_or_assign(
shaderData.hashedAlias,
ShaderToDoubleBuffer{
std::move(buffers),
shaderData.shader
}
);
static_cast<GL::ShaderProgram *>(shaderData.shader)->reLink();
return result;
}
void TransformFeedbackBufferManager::destroy(size_t hashedAlias)
{
auto target = transformFeedbackBufferMap.find(hashedAlias);
if (target != transformFeedbackBufferMap.end()) {
glTransformFeedbackVaryings(
target->second.linkedShader->getProgramId(),
0,
nullptr,
GL_INTERLEAVED_ATTRIBS
);
static_cast<GL::ShaderProgram *>(target->second.linkedShader)->reLink();
transformFeedbackBufferMap.erase(target);
}
}
void TransformFeedbackBufferManager::destroy(const std::string &alias)
{
destroy(stringHasher(alias));
}
void TransformFeedbackBufferManager::destroy(RenderSystem::ShaderData shaderData)
{
destroy(shaderData.hashedAlias);
}
const RenderSystem::Buffer *TransformFeedbackBufferManager::get(const std::string &alias) const
{
auto result = transformFeedbackBufferMap.find(stringHasher(alias));
if (result != transformFeedbackBufferMap.end()) {
return result->second.transformFeedbackBuffers.readBuffer.get();
}
return nullptr;
}
const RenderSystem::Buffer *TransformFeedbackBufferManager::get(RenderSystem::ShaderData shaderData) const
{
auto result = transformFeedbackBufferMap.find(shaderData.hashedAlias);
if (result != transformFeedbackBufferMap.end()) {
return result->second.transformFeedbackBuffers.readBuffer.get();
}
return nullptr;
}
void TransformFeedbackBufferManager::clear()
{
for (const auto &it : transformFeedbackBufferMap) {
glTransformFeedbackVaryings(
it.second.linkedShader->getProgramId(),
0,
nullptr,
GL_INTERLEAVED_ATTRIBS
);
static_cast<GL::ShaderProgram *>(it.second.linkedShader)->reLink();
}
transformFeedbackBufferMap.clear();
}
void TransformFeedbackBufferManager::beginTransformFeedback(RenderSystem::RSenum primitiveMode)
{
isCurrentlyEnabled = true;
auto bufferNames = std::vector<GLuint>{};
for (const auto &[key, value] : transformFeedbackBufferMap) {
bufferNames.push_back(value.transformFeedbackBuffers.writeBuffer->getId());
}
glBindBuffersBase(
GL_TRANSFORM_FEEDBACK_BUFFER,
0,
transformFeedbackBufferMap.size(),
bufferNames.data()
);
glBeginTransformFeedback(primitiveMode);
}
void TransformFeedbackBufferManager::endTransformFeedback()
{
glEndTransformFeedback();
for (auto &[key, value] : transformFeedbackBufferMap) {
auto &buffers = value.transformFeedbackBuffers;
buffers.readBuffer.swap(buffers.writeBuffer);
}
isCurrentlyEnabled = false;
}
void TransformFeedbackBufferManager::pauseTransformFeedback()
{
glPauseTransformFeedback();
}
void TransformFeedbackBufferManager::resumeTransformFeedback()
{
glResumeTransformFeedback();
}
void TransformFeedbackBufferManager::disableRasterization()
{
glEnable(GL_RASTERIZER_DISCARD);
}
void TransformFeedbackBufferManager::enableRasterization()
{
glDisable(GL_RASTERIZER_DISCARD);
}
}
}
| [
"velocicdev@gmail.com"
] | velocicdev@gmail.com |
1e354b08a9884d02d949503fa4b458d7d83a50e8 | eef9cdafb7476427d194374cc11a54a068c30325 | /detailedAnimalDialog.cpp | c606c7cf6f26830524faecc459deb65b84a2f1d0 | [] | no_license | geetika016/FindMeAPet | 3988ecbb87fa0c92c2424f8b628d741cf99810b6 | 43a7dcceb1c01a170d3101c30017a541df89b02b | refs/heads/master | 2020-06-20T09:43:33.569960 | 2019-07-15T22:44:58 | 2019-07-15T22:44:58 | 197,078,766 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,670 | cpp | #include "detailedAnimalDialog.h"
#include <QDebug>
DetailedAnimalDialog::DetailedAnimalDialog(int num, QString* attr, QWidget *parent, int edit) :
QDialog(parent),
attributesNum(num),
attributes(attr),
canEdit(edit)
{
QWidget *details = new QWidget;
QScrollArea *scrollArea = new QScrollArea;
scrollArea->setWidgetResizable(true);
scrollArea->setWidget(details);
QGridLayout *mainLayout = new QGridLayout;
details->setLayout(mainLayout);
for(int i=0; i<attributesNum-1; i++)
{
QFrame *labelPair = new QFrame;
labelPair->setLineWidth(1);
labelPair->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
QLabel *attName = new QLabel;
if(attributes[i*2].contains("afc"))
{
attributes[i*2] = attributes[i*2].remove("afc");
attributes[i*2] = attributes[i*2]+" score by animal for client";
}
if(attributes[i*2].contains("cfa"))
{
attributes[i*2] = attributes[i*2].remove("cfa");
attributes[i*2] = attributes[i*2]+" score by client for animal";
}
attName->setText(attributes[i*2]+":");
QLineEdit *attVal = new QLineEdit;
attVal->setText(attributes[i*2+1]);
if(canEdit == 1)
attVal->setReadOnly(true);
QHBoxLayout *labelPairLayout = new QHBoxLayout;//set up a pair of attribute name and value
labelPairLayout->addWidget(attName);
labelPairLayout->addWidget(attVal);
labelPair->setLayout(labelPairLayout);
mainLayout->addWidget(labelPair, i/3, i%3);//display 6 attributes per line
}
setLayout(mainLayout);
}
| [
"geetika.shrma16@gmail.com"
] | geetika.shrma16@gmail.com |
e1a3be6c2b3fedb3c2e9aad8585f90a036c8b382 | 889cf800ba7316fc1b3f4e6ed2abe9b8f1943ace | /mLib/include/core-graphics/camera.h | a9945563b61a77459ed49ec1fa571804891be75e | [] | no_license | zhsuiy/actsynth | a531ecbf6e66e8c46edba8fbc295f49480b5477b | c1783688dee3db1b04b0d15401d64937d17d5db5 | refs/heads/master | 2021-01-22T15:04:06.673016 | 2015-09-06T00:16:25 | 2015-09-06T00:16:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,883 | h |
#ifndef CORE_GRAPHICS_CAMERA_H_
#define CORE_GRAPHICS_CAMERA_H_
namespace ml {
template <class FloatType>
class Camera : public BinaryDataSerialize< Camera<FloatType> > {
public:
Camera() {}
Camera(const std::string &s);
//
// TODO: this camera constructor is bad but is retained for legacy. There is no way to cast a standard look-at matrix in this form -- it cannot capture pitch and will always be looking straight.
//
Camera(const vec3<FloatType>& eye, const vec3<FloatType>& worldUp, const vec3<FloatType>& right, FloatType fieldOfView, FloatType aspect, FloatType zNear, FloatType zFar);
//
// this is one possible better camera constructor.
//
Camera(const vec3<FloatType>& eye, const vec3<FloatType>& worldUp, const vec3<FloatType>& lookAt, FloatType fieldOfView, FloatType aspect, FloatType zNear, FloatType zFar, bool unused);
//! Construct camera from extrinsics matrix m (columns are x, y, z vectors and origin of camera in that order).
//! If flipRight is set, flip the x coordinate
Camera(const Matrix4x4<FloatType>& m, const FloatType fieldOfView, const FloatType aspect, const FloatType zNear, const FloatType zFar, const bool flipRight = false);
virtual void updateAspectRatio(FloatType newAspect);
void lookRight(FloatType theta);
void lookUp(FloatType theta);
void roll(FloatType theta);
void strafe(FloatType delta);
void jump(FloatType delta);
void move(FloatType delta);
void translate(const vec3<FloatType> &v);
Ray<FloatType> getScreenRay(FloatType screenX, FloatType screenY) const;
vec3<FloatType> getScreenRayDirection(FloatType screenX, FloatType screenY) const;
Matrix4x4<FloatType> getCamera() const {
return m_camera;
}
void setCamera(Matrix4x4<FloatType>& c){
m_camera = c;
}
Matrix4x4<FloatType> getPerspective() const {
return m_perspective;
}
Matrix4x4<FloatType> getCameraPerspective() const {
return m_cameraPerspective;
}
vec3<FloatType> getEye() const {
return m_eye;
}
vec3<FloatType> getLook() const {
return m_look;
}
vec3<FloatType> getRight() const {
return m_right;
}
vec3<FloatType> getUp() const {
return m_up;
}
FloatType getFoV() const {
return m_fieldOfView;
}
FloatType getAspect() const {
return m_aspect;
}
std::string toString() const;
void applyTransform(const Matrix4x4<FloatType>& transform);
static Matrix4x4<FloatType> visionToGraphicsProj(unsigned int width, unsigned int height, FloatType fx, FloatType fy, FloatType zNear, FloatType zFar)
{
//not entirely sure whether there is a '-1' for width/height somewhere
FloatType fov = (FloatType)2.0 * atan((FloatType)width / ((FloatType)2 * fx));
FloatType aspect = (FloatType)width / (FloatType)height;
return perspectiveFov(math::radiansToDegrees(fov), aspect, zNear, zFar);
}
//! note: this assumes the DX11/OGl structure of m (see NDC space)
static Matrix4x4<FloatType> graphicsToVisionProj(const Matrix4x4<FloatType>& m, unsigned int width, unsigned int height)
{
FloatType fov = (FloatType)2.0 * atan((FloatType)1 / m(0,0));
FloatType aspect = (FloatType)width / height;
FloatType t = tan((FloatType)0.5 * fov);
FloatType focalLengthX = (FloatType)0.5 * (FloatType)width / t;
FloatType focalLengthY = (FloatType)0.5 * (FloatType)height / t * aspect;
focalLengthY = -focalLengthY;
return Matrix4x4<FloatType>(
focalLengthX, 0.0f, (FloatType)(width-1) / 2.0f, 0.0f,
0.0f, focalLengthY, (FloatType)(height-1) / 2.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
}
float getNearPlane() const {
return m_zNear;
}
float getFarPlane() const {
return m_zFar;
}
private:
void update();
//! field of view is in degrees
static Matrix4x4<FloatType> perspectiveFov(FloatType fieldOfView, FloatType aspectRatio, FloatType zNear, FloatType zFar);
static Matrix4x4<FloatType> viewMatrix(const vec3<FloatType>& eye, const vec3<FloatType>& look, const vec3<FloatType>& up, const vec3<FloatType>& right);
vec3<FloatType> m_eye, m_right, m_look, m_up;
vec3<FloatType> m_worldUp;
Matrix4x4<FloatType> m_camera;
Matrix4x4<FloatType> m_perspective;
Matrix4x4<FloatType> m_cameraPerspective;
FloatType m_fieldOfView, m_aspect, m_zNear, m_zFar;
};
typedef Camera<float> Cameraf;
typedef Camera<double> Camerad;
} // namespace ml
#include "camera.cpp"
#endif // CORE_GRAPHICS_CAMERA_H_
| [
"techmatt@gmail.com"
] | techmatt@gmail.com |
f7ed9d9fc654153f4e6d1cac423c1fc7efb519f4 | 8947812c9c0be1f0bb6c30d1bb225d4d6aafb488 | /03_Tutorial/T02_XMCocos2D-CookBook/Source/Recipes/Ch1_1DEasingActions.cpp | 006dbd147f4bf98e20943e0d2194fb6174e2c8aa | [
"MIT"
] | permissive | alissastanderwick/OpenKODE-Framework | cbb298974e7464d736a21b760c22721281b9c7ec | d4382d781da7f488a0e7667362a89e8e389468dd | refs/heads/master | 2021-10-25T01:33:37.821493 | 2016-07-12T01:29:35 | 2016-07-12T01:29:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,957 | cpp | /* --------------------------------------------------------------------------
*
* File Ch1_1DEasingActions.cpp
* Ported By Young-Hwan Mun
* Contact xmsoft77@gmail.com
*
* Created By Nate Burba
* Contact Cocos2dCookbook@gmail.com
*
* --------------------------------------------------------------------------
*
* Copyright (c) 2010-2013 XMSoft.
* Copyright (c) 2011 COCOS2D COOKBOOK. All rights reserved.
*
* --------------------------------------------------------------------------
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library in the file COPYING.LIB;
* if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* -------------------------------------------------------------------------- */
#include "Precompiled.h"
#include "Ch1_1DEasingActions.h"
enum
{
TAG_SPRITE_TO_MOVE = 0,
TAG_PREV_ACTION = 1,
TAG_RELOAD_ACTION = 2,
TAG_NEXT_ACTION = 3,
TAG_ACTION_NAME = 4,
TAG_BREADCRUMBS = 5,
};
static const KDchar* l_aActionMethods [ ] =
{
"EaseIn" ,
"EaseOut" ,
"EaseInOut" ,
"EaseExponentialIn" ,
"EaseExponentialOut" ,
"EaseExponentialInOut" ,
"EaseSineIn" ,
"EaseSineOut" ,
"EaseSineInOut" ,
"EaseElasticIn" ,
"EaseElasticOut" ,
"EaseElasticInOut" ,
"EaseBounceIn" ,
"EaseBounceOut" ,
"EaseBounceInOut" ,
"EaseBackIn" ,
"EaseBackOut" ,
"EaseBackInOut" ,
};
KDbool Ch1_1DEasingActions::init ( KDvoid )
{
if ( !Recipe::init ( ) )
{
return KD_FALSE;
}
m_pActionToEase = CCMoveBy::create ( 2, ccp ( 200, 200 ) );
m_pActionToEase->retain ( );
CCSprite* pSprite = CCSprite::create ( "colorable_sprite.png" );
pSprite->setPosition ( ccp ( 150, 50 ) );
pSprite->setScale ( 0.5f );
this->addChild ( pSprite, 1, TAG_SPRITE_TO_MOVE );
// A dd Breadcrumbs
CCSprite* pBreadcrumbs = CCSprite::create ( "blank.png" );
pBreadcrumbs->setPosition ( ccp ( 0, 0 ) );
this->addChild ( pBreadcrumbs, 0, TAG_BREADCRUMBS );
CCSprite* pStart = CCSprite::create ( "blank.png" );
pStart->setPosition ( ccp ( 150, 50 ) );
pStart->setTextureRect ( CCRect ( 0, 0, 8, 8 ) );
pStart->setColor ( ccc3 ( 0, 255, 0 ) );
this->addChild ( pStart, 0 );
CCSprite* pEnd = CCSprite::create ( "blank.png" );
pEnd->setPosition ( ccp ( 350, 250 ) );
pEnd->setTextureRect ( CCRect ( 0, 0, 8, 8 ) );
pEnd->setColor ( ccc3 ( 255, 0, 0 ) );
this->addChild ( pEnd, 0 );
this->schedule ( schedule_selector ( Ch1_1DEasingActions::step ) );
this->initSubMenus ( sizeof ( l_aActionMethods ) / sizeof ( l_aActionMethods [ 0 ] ) );
return KD_TRUE;
}
KDvoid Ch1_1DEasingActions::onExit ( KDvoid )
{
m_pActionToEase->release ( );
Recipe::onExit ( );
}
const KDchar* Ch1_1DEasingActions::runSubAction ( KDint nIndex )
{
// Clean and re-add breadcrumbs
CCNode* pBreadcrumbs = this->getChildByTag ( TAG_BREADCRUMBS );
this->removeChild ( pBreadcrumbs );
pBreadcrumbs = CCSprite::create ( "blank.png" );
pBreadcrumbs->setPosition ( ccp ( 0, 0 ) );
this->addChild ( pBreadcrumbs, 0, TAG_BREADCRUMBS );
CCNode* pNode = this->getChildByTag ( TAG_SPRITE_TO_MOVE );
pNode->stopAllActions ( );
pNode->setPosition ( ccp ( 150, 50 ) );
CCActionInterval* pEaseAction = KD_NULL;
switch ( nIndex )
{
case 0 : pEaseAction = CCEaseIn ::create ( m_pActionToEase, 2 ); break;
case 1 : pEaseAction = CCEaseOut ::create ( m_pActionToEase, 2 ); break;
case 2 : pEaseAction = CCEaseInOut ::create ( m_pActionToEase, 2 ); break;
case 3 : pEaseAction = CCEaseExponentialIn ::create ( m_pActionToEase ); break;
case 4 : pEaseAction = CCEaseExponentialOut ::create ( m_pActionToEase ); break;
case 5 : pEaseAction = CCEaseExponentialInOut ::create ( m_pActionToEase ); break;
case 6 : pEaseAction = CCEaseSineIn ::create ( m_pActionToEase ); break;
case 7 : pEaseAction = CCEaseSineOut ::create ( m_pActionToEase ); break;
case 8 : pEaseAction = CCEaseSineInOut ::create ( m_pActionToEase ); break;
case 9 : pEaseAction = CCEaseElasticIn ::create ( m_pActionToEase, 0.3f ); break;
case 10 : pEaseAction = CCEaseElasticOut ::create ( m_pActionToEase, 0.3f ); break;
case 11 : pEaseAction = CCEaseElasticInOut ::create ( m_pActionToEase, 0.3f ); break;
case 12 : pEaseAction = CCEaseBounceIn ::create ( m_pActionToEase ); break;
case 13 : pEaseAction = CCEaseBounceOut ::create ( m_pActionToEase ); break;
case 14 : pEaseAction = CCEaseBounceInOut ::create ( m_pActionToEase ); break;
case 15 : pEaseAction = CCEaseBackIn ::create ( m_pActionToEase ); break;
case 16 : pEaseAction = CCEaseBackOut ::create ( m_pActionToEase ); break;
case 17 : pEaseAction = CCEaseBackInOut ::create ( m_pActionToEase ); break;
}
pNode->runAction ( pEaseAction );
return l_aActionMethods [ nIndex ];
}
KDvoid Ch1_1DEasingActions::step ( KDfloat fDelta )
{
CCNode* pBreadcrumbs = this->getChildByTag ( TAG_BREADCRUMBS );
CCNode* pNode = this->getChildByTag ( TAG_SPRITE_TO_MOVE );
CCSprite* pCrumb = CCSprite::create ( "blank.png" );
pCrumb->setTextureRect ( CCRect ( 0, 0, 2, 2 ) );
pCrumb->setColor ( ccc3 ( 255, 255, 0 ) );
pCrumb->setPosition ( pNode->getPosition ( ) );
pBreadcrumbs->addChild ( pCrumb );
} | [
"mcodegeeks@gmail.com"
] | mcodegeeks@gmail.com |
b549722d65ff7823b3c3ba9acb2e65f12311e325 | b42d57701a4033702583721023befee6e1b4eeea | /include/reduction_library/thinning/helpers/Energy_counting.hpp | 0a7885794a4a16461776fcf05a8e3827585bcf7c | [] | no_license | KseniaBastrakova/Reduction_library | 7b5c548a1d877ca05a8e39b5c49f674e4a748254 | 7116bd29f5ff3a28759fbb4e888cd40b8b065cd0 | refs/heads/master | 2023-03-03T11:11:18.275988 | 2021-02-17T12:46:45 | 2021-02-17T12:46:45 | 274,914,074 | 0 | 0 | null | 2020-11-20T11:10:40 | 2020-06-25T12:45:50 | C++ | UTF-8 | C++ | false | false | 1,824 | hpp | /* Copyright 2020 Kseniia Bastrakova, Sergei Bastrakov
*
* This file is part of reduction library.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#pragma once
#include <math.h>
#include "reduction_library/Particle_getters.hpp"
namespace reduction_library{
namespace thinning{
/** @file
*
* Getting energy of particle, by particle momentum and mass
* we use base formula of energy momentum eqation
* https://en.wikipedia.org/wiki/Energy%E2%80%93momentum_relation
* E = sqrt ((p * c)^2 + (m * c^2)^2)
*
*/
/** Getting energy for particle, that in particle concept
*
* returns energy of particle
*
* for being successful, particle should based on particle species
* that based on momentum Record and mass record, at least
* \tparam T_Particle type of input particle
*/
template<typename T_Particle>
class Getting_particle_energy{
static constexpr double speed_light = 299792458.;
public:
double operator()(const T_Particle& particle)
{
auto momentum_x = particle_access::get_momentum_x(particle);
auto momentum_y = particle_access::get_momentum_y(particle);
auto momentum_z = particle_access::get_momentum_z(particle);
auto mass = particle_access::get_mass(particle);
double total_energy = sqrt((momentum_x * momentum_x +
momentum_y * momentum_y + momentum_z * momentum_z) * speed_light * speed_light +
(mass * speed_light * speed_light) * (mass * speed_light * speed_light));
return total_energy;
}
};
} // namespace thinning
} // reduction_library
| [
"Bastrakova.Kseinia@gmail.com"
] | Bastrakova.Kseinia@gmail.com |
e8a37f7aaf92356c57c41635b496d0f128351aff | bff5767cbf440642fe20b4d3f670a8762108e401 | /copter_model/src/copter_plugin.cpp | f6e569911d272f742e1866d0a97eea660e4a470a | [] | no_license | VladislavBakaev/copter_sim | e87edc5bf0b908100fee4b7992f49f5fd305334c | a1f3827b63a8f7f4cf3553bec071516b38b0808e | refs/heads/main | 2023-08-03T01:00:51.028926 | 2021-09-08T12:46:40 | 2021-09-08T12:46:40 | 396,828,632 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,086 | cpp | #include "rclcpp/rclcpp.hpp"
#include <geometry_msgs/msg/twist.hpp>
#include <geometry_msgs/msg/point.hpp>
#include "sensor_msgs/msg/imu.hpp"
#include <tf2_geometry_msgs/tf2_geometry_msgs.h>
#include <tf2_ros/transform_broadcaster.h>
#include <tf2_ros/transform_listener.h>
#include <tf2_ros/buffer.h>
#include <math.h>
#include <iostream>
#include <random>
using namespace std;
using std::placeholders::_1;
class CopterPlugin : public rclcpp::Node
{
public:
CopterPlugin() : Node("copter_plugin_node")
{
timer_velocity = this->create_wall_timer(
std::chrono::milliseconds(100),
std::bind(&CopterPlugin::velocityTimer, this));
timer_position = this->create_wall_timer(
std::chrono::milliseconds(100),
std::bind(&CopterPlugin::positionControlTimer, this));
tf_broadcaster_ = std::make_unique<tf2_ros::TransformBroadcaster>(this);
subscription_vel_ = this->create_subscription<geometry_msgs::msg::Twist>(
"/cmd_vel", 10, std::bind(&CopterPlugin::cmdVelocityCallback, this, _1));
// publisher_ = this->create_publisher<sensor_msgs::msg::Imu>("/lin_acc", 10);
odom_tf.transform.translation.x = 0.0;
odom_tf.transform.translation.y = 0.0;
odom_tf.transform.translation.z = 0.0;
}
private:
rclcpp::Subscription<geometry_msgs::msg::Twist>::SharedPtr subscription_vel_;
rclcpp::TimerBase::SharedPtr timer_position;
rclcpp::TimerBase::SharedPtr timer_velocity;
std::shared_ptr<tf2_ros::TransformBroadcaster> tf_broadcaster_;
geometry_msgs::msg::TransformStamped odom_tf;
// rclcpp::Publisher<sensor_msgs::msg::Imu>::SharedPtr publisher_;
double lin_vel_x = 0;
double lin_vel_y = 0;
double lin_vel_z = 0;
double ang_vel_r = 0;
double ang_vel_p = 0;
double ang_vel_y = 0;
double cur_lin_vel_x = 0;
double cur_lin_vel_y = 0;
double cur_lin_vel_z = 0;
double fly_angle_r_max = 0.5;
double fly_angle_p_max = 0.5;
double fly_angle_r_koef = 0.3;
double fly_angle_p_koef = 0.3;
double const_time = 0.2;
double last_iter = this->now().seconds();
std::random_device rd{};
std::mt19937 gen{rd()};
std::normal_distribution<double> d{0.0,0.005};
void positionControlTimer()
{
rclcpp::Time cur_time = this->now();
double delta = cur_time.seconds()-last_iter;
last_iter = cur_time.seconds();
tf2::Quaternion quat(odom_tf.transform.rotation.x, odom_tf.transform.rotation.y, odom_tf.transform.rotation.z, odom_tf.transform.rotation.w);
tf2::Vector3 rpy = convertQuaternion2RPY(quat);
if (cur_lin_vel_y*fly_angle_r_koef > fly_angle_r_max){
rpy[0] = -fly_angle_r_max;
}
else{
rpy[0] = -cur_lin_vel_y*fly_angle_r_koef;
}
if (cur_lin_vel_x*fly_angle_p_koef > fly_angle_p_max){
rpy[1] = fly_angle_p_max;
}
else{
rpy[1] = cur_lin_vel_x*fly_angle_p_koef;
}
rpy[2] += ang_vel_y*delta;
quat = convertRPY2Quaternion(rpy);
// RCLCPP_INFO(this->get_logger(), "quaternion: '%f' '%f' '%f' '%f'", quat[0], quat[1], quat[2], quat[3]);
odom_tf.transform.translation.x += cur_lin_vel_x*delta;
odom_tf.transform.translation.y += cur_lin_vel_y*delta;
odom_tf.transform.translation.z += cur_lin_vel_z*delta;
odom_tf.transform.rotation.x = quat[0];
odom_tf.transform.rotation.y = quat[1];
odom_tf.transform.rotation.z = quat[2];
odom_tf.transform.rotation.w = quat[3];
odom_tf.header.frame_id = "world";
odom_tf.child_frame_id = "copter_desired";
odom_tf.header.stamp = cur_time;
tf_broadcaster_->sendTransform(odom_tf);
}
void cmdVelocityCallback(const geometry_msgs::msg::Twist::SharedPtr msg){
lin_vel_x = msg->linear.x;
lin_vel_y = msg->linear.y;
lin_vel_z = msg->linear.z;
ang_vel_y = msg->angular.z;
// ang_vel_r = msg->angular.x;
// ang_vel_p = msg->angular.y;
}
void velocityTimer(){
if (std::abs(lin_vel_x - cur_lin_vel_x)>0.1){
double delta = (lin_vel_x - cur_lin_vel_x)*const_time + d(gen);
cur_lin_vel_x += delta;
}
else{
cur_lin_vel_x = lin_vel_x;
}
if (std::abs(lin_vel_y - cur_lin_vel_y)>0.1){
double delta = (lin_vel_y - cur_lin_vel_y)*const_time + d(gen);
cur_lin_vel_y += delta;
}
else{
cur_lin_vel_y = lin_vel_y;
}
if (std::abs(lin_vel_z - cur_lin_vel_z)>0.1){
double delta = (lin_vel_z - cur_lin_vel_z)*const_time;
cur_lin_vel_z += delta;
}
else{
cur_lin_vel_z = lin_vel_z;
}
// RCLCPP_INFO(this->get_logger(), "x: '%f', y: '%f', z: '%f'", lin_x_acc, lin_y_acc, lin_z_acc);
}
tf2::Vector3 convertQuaternion2RPY(const tf2::Quaternion quaternion){
tf2::Matrix3x3 matrix(quaternion);
double roll, pitch, yaw;
matrix.getRPY(roll, pitch, yaw);
tf2::Vector3 rpy(roll, pitch, yaw);
return rpy;
}
tf2::Quaternion convertRPY2Quaternion(const tf2::Vector3 rpy){
tf2::Quaternion quat;
quat.setRPY(rpy[0], rpy[1], rpy[2]);
return quat;
}
};
int main(int argc, char **argv)
{
rclcpp::init(argc, argv);
auto node = std::make_shared<CopterPlugin>();
rclcpp::spin(node);
rclcpp::shutdown();
return 0;
} | [
"bakaev.98@bk.ru"
] | bakaev.98@bk.ru |
a94251cd2365e92308a819f2096c9d28694e4645 | 8580b9be68509f936bc29bf29ced2338b19b0fce | /OOP_Proj_200913/AccountArray.h | 8db2bbda97c27b33f85375396a23f10978e5fa79 | [] | no_license | paprika-kr/OOP_Project1 | fdcb2e48e35f301da7b617e5d9d642a37c129ec0 | 6e8e13910946a6843426b2781c950db98f656933 | refs/heads/master | 2022-12-17T04:03:47.844873 | 2020-09-13T07:45:16 | 2020-09-13T07:45:16 | 279,390,598 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 978 | h | #pragma once
#ifndef __ACCOUNT_ARRAY_H__
#define __ACCOUNT_ARRAY_H__
#include "Client.h"
template <typename T>
class BoundCheckAccountArray
{
private:
T* arr;
int arrlen;
BoundCheckAccountArray(const BoundCheckAccountArray& arr){ }
BoundCheckAccountArray& operator=(const BoundCheckAccountArray& arr) { }
public:
BoundCheckAccountArray(int len = 100)
{
arrlen = len;
arr = new T [arrlen];
}
T& operator[](int idx);
T operator[](int idx) const;
inline int GetArrLen() const
{
return arrlen;
}
~BoundCheckAccountArray()
{
delete[] arr;
}
};
template <typename T>
T& BoundCheckAccountArray<T>::operator[](int idx)
{
if (idx < 0 || idx >= arrlen)
{
cout << "Array index out of bound exception" << endl;
exit(1);
}
return arr[idx];
}
template <typename T>
T BoundCheckAccountArray<T>::operator[](int idx) const
{
if (idx < 0 || idx >= arrlen)
{
cout << "Array index out of bound exception" << endl;
exit(1);
}
return arr[idx];
}
#endif | [
"feira@naver.com"
] | feira@naver.com |
ad6281cfd820e7962f9fb71937129a755d7262d7 | 38b9daafe39f937b39eefc30501939fd47f7e668 | /tutorials/2WayCouplingOceanWave3D/basicTutorialwtProbesResultsWtPhiCoupled/12/uniform/time | 7a3fea4a147f0e5c08bcfe408962aa5b059c08e8 | [] | no_license | rubynuaa/2-way-coupling | 3a292840d9f56255f38c5e31c6b30fcb52d9e1cf | a820b57dd2cac1170b937f8411bc861392d8fbaa | refs/heads/master | 2020-04-08T18:49:53.047796 | 2018-08-29T14:22:18 | 2018-08-29T14:22:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 984 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 3.0.1 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "12/uniform";
object time;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
value 12;
name "12";
index 1241;
deltaT 0.00833333;
deltaT0 0.00833333;
// ************************************************************************* //
| [
"abenaz15@etudiant.mines-nantes.fr"
] | abenaz15@etudiant.mines-nantes.fr | |
4d55c5296832850007bb1fe7cee2f5fcf6c8949a | d80854e2d181558d46af721d9d1d31ff9af6359a | /src/contour.cpp | ff2bf0c1f5dd25d2f61d04582d48a93b800b7cab | [] | no_license | ejbosia/drawbot-cpp | 9a7b5c9691b1685ec19d24c81d85a3d8307637f8 | a924f58a6d19dedf01ca3d9487f056876920509c | refs/heads/main | 2023-07-27T16:14:36.974897 | 2021-09-08T22:11:45 | 2021-09-08T22:11:45 | 403,058,785 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,556 | cpp | #include "contour.h"
Contour::Contour(std::vector<Point>& vertexRef):vertexList(vertexRef){
}
/*
Get the vertex at the input index - loop around the vertex
*/
Point Contour::get(int index){
return vertexList[index % vertexList.size()];
}
/*
Get the number of vertices in the contour
*/
int Contour::size(){
return vertexList.size();
}
/*
Rotate all of the points in the contour about pt 0,0
*/
void Contour::rotate(Angle& angle){
for(int i = 0; i < vertexList.size(); i++){
vertexList[i].rotate(angle);
}
}
/*
Find the index of the point before the input point - return -1 if not found
*/
int Contour::getStartingIndex(Point& p){
int endIndex;
for(int i = 0; i < vertexList.size(); i++){
if(i+1 >= vertexList.size()){
endIndex = 0;
}
else{
endIndex = i+1;
}
// bring the next point to 0 ( to compare )
Point next = vertexList[endIndex] - vertexList[i];
// bring the test point to 0
Point current = p - vertexList[i];
DEBUG_MSG_C((current.y/current.x) << " == " << (next.y/next.x));
// compare the ratio of y/x
if((current.y/current.x) == (next.y/next.x)){
return i;
}
}
return -1;
}
/*
Find a point a distance around the perimeter of the contour
*/
Point* Contour::traverse(Point& start, double distance, bool clockwise){
double length;
int index = getStartingIndex(start);
// set the direction
int direction;
if(clockwise){
direction = 1;
index += 1;
}else{
direction = -1;
}
double edgeDistance;
while(distance > 0){
edgeDistance = start.distance(vertexList[index]);
// if the distance remaining is longer than the edge distance, move to the next edge
if(distance > edgeDistance){
// remove the edge distance from the distance remaining
distance -= edgeDistance;
// move the start point to the end of the current edge
start = vertexList[index];
// move to the next edge
index = (index + direction) % vertexList.size();
}
// move the distance away from the current start point
else{
Angle a = start.angle(vertexList[index]);
// translate the point in the direction of the end point the remaining distance
Point* temp = new Point(start.x, start.y);
(*temp).translate(distance, a);
// return the point
return temp;
}
}
return NULL;
}
// get the maximum point in the contour in the direction of the angle
Point Contour::getMaximumPoint(Angle& angle){
Point maxPoint = vertexList.front();
double maxValue = maxPoint.xRotation(angle);
double tempValue;
for(int i = 0; i < vertexList.size(); i++){
tempValue = vertexList[i].xRotation(angle);
DEBUG_MSG_C("TEMP: " << tempValue << "\t" << vertexList[i]);
if(tempValue > maxValue){
maxValue = tempValue;
maxPoint = vertexList[i];
}
}
DEBUG_MSG_C("ANGLE: " << angle.degrees() << "\tCOS: " << angle.cosine() << "\tSIN: " << angle.sine());
return maxPoint;
}
std::ostream& operator<<(std::ostream &strm, const Contour &c){
strm << "\nCONTOUR" << std::endl;
for(int i = 0; i < c.vertexList.size(); i++){
strm << "\t" << c.vertexList[i] << std::endl;
}
return strm;
} | [
"ejbosia@gmail.com"
] | ejbosia@gmail.com |
c79d3afe20de4faf4611a196413651fd90a3abd3 | 31f5cddb9885fc03b5c05fba5f9727b2f775cf47 | /thirdparty/mlpack/core/dists/discrete_distribution.hpp | af979f02f714ecf8297d765243312a3393134bb4 | [
"MIT"
] | permissive | timi-liuliang/echo | 2935a34b80b598eeb2c2039d686a15d42907d6f7 | d6e40d83c86431a819c6ef4ebb0f930c1b4d0f24 | refs/heads/master | 2023-08-17T05:35:08.104918 | 2023-08-11T18:10:35 | 2023-08-11T18:10:35 | 124,620,874 | 822 | 102 | MIT | 2021-06-11T14:29:03 | 2018-03-10T04:07:35 | C++ | UTF-8 | C++ | false | false | 7,797 | hpp | /**
* @file discrete_distribution.hpp
* @author Ryan Curtin
*
* Implementation of the discrete distribution, where each discrete observation
* has a given probability.
*
* mlpack is free software; you may redistribute it and/or modify it under the
* terms of the 3-clause BSD license. You should have received a copy of the
* 3-clause BSD license along with mlpack. If not, see
* http://www.opensource.org/licenses/BSD-3-Clause for more information.
*/
#ifndef MLPACK_CORE_DISTRIBUTIONS_DISCRETE_DISTRIBUTION_HPP
#define MLPACK_CORE_DISTRIBUTIONS_DISCRETE_DISTRIBUTION_HPP
#include <mlpack/prereqs.hpp>
#include <mlpack/core/util/log.hpp>
#include <mlpack/core/math/random.hpp>
namespace mlpack {
namespace distribution /** Probability distributions. */ {
/**
* A discrete distribution where the only observations are discrete
* observations. This is useful (for example) with discrete Hidden Markov
* Models, where observations are non-negative integers representing specific
* emissions.
*
* No bounds checking is performed for observations, so if an invalid
* observation is passed (i.e. observation > numObservations), a crash will
* probably occur.
*
* This distribution only supports one-dimensional observations, so when passing
* an arma::vec as an observation, it should only have one dimension
* (vec.n_rows == 1). Any additional dimensions will simply be ignored.
*
* @note
* This class, like every other class in mlpack, uses arma::vec to represent
* observations. While a discrete distribution only has positive integers
* (size_t) as observations, these can be converted to doubles (which is what
* arma::vec holds). This distribution internally converts those doubles back
* into size_t before comparisons.
* @endnote
*/
class DiscreteDistribution
{
public:
/**
* Default constructor, which creates a distribution that has no observations.
*/
DiscreteDistribution() :
probabilities(std::vector<arma::vec>(1)){ /* Nothing to do. */ }
/**
* Define the discrete distribution as having numObservations possible
* observations. The probability in each state will be set to (1 /
* numObservations).
*
* @param numObservations Number of possible observations this distribution
* can have.
*/
DiscreteDistribution(const size_t numObservations) :
probabilities(std::vector<arma::vec>(1,
arma::ones<arma::vec>(numObservations) / numObservations))
{ /* Nothing to do. */ }
/**
* Define the multidimensional discrete distribution as having numObservations possible
* observations. The probability in each state will be set to (1 /
* numObservations of each dimension).
*
* @param numObservations Number of possible observations this distribution
* can have.
*/
DiscreteDistribution(const arma::Col<size_t>& numObservations)
{
for (size_t i = 0; i < numObservations.n_elem; i++)
{
const size_t numObs = size_t(numObservations[i]);
if (numObs <= 0)
{
std::ostringstream oss;
oss << "number of observations for dimension " << i << " is 0, but "
<< "must be greater than 0";
throw std::invalid_argument(oss.str());
}
probabilities.push_back(arma::ones<arma::vec>(numObs) / numObs);
}
}
/**
* Define the multidimensional discrete distribution as having the given probabilities for each
* observation.
*
* @param probabilities Probabilities of each possible observation.
*/
DiscreteDistribution(const std::vector<arma::vec>& probabilities)
{
for (size_t i = 0; i < probabilities.size(); i++)
{
arma::vec temp = probabilities[i];
double sum = accu(temp);
if (sum > 0)
this->probabilities.push_back(temp / sum);
else
{
this->probabilities.push_back(arma::ones<arma::vec>(temp.n_elem)
/ temp.n_elem);
}
}
}
/**
* Get the dimensionality of the distribution.
*/
size_t Dimensionality() const { return probabilities.size(); }
/**
* Return the probability of the given observation. If the observation is
* greater than the number of possible observations, then a crash will
* probably occur -- bounds checking is not performed.
*
* @param observation Observation to return the probability of.
* @return Probability of the given observation.
*/
double Probability(const arma::vec& observation) const
{
double probability = 1.0;
// Ensure the observation has the same dimension with the probabilities
if (observation.n_elem != probabilities.size())
{
Log::Fatal << "DiscreteDistribution::Probability(): observation has "
<< "incorrect dimension " << observation.n_elem << " but should have "
<< "dimension " << probabilities.size() << "!" << std::endl;
}
for (size_t dimension = 0; dimension < observation.n_elem; dimension++)
{
// Adding 0.5 helps ensure that we cast the floating point to a size_t
// correctly.
const size_t obs = size_t(observation(dimension) + 0.5);
// Ensure that the observation is within the bounds.
if (obs >= probabilities[dimension].n_elem)
{
Log::Fatal << "DiscreteDistribution::Probability(): received "
<< "observation " << obs << "; observation must be in [0, "
<< probabilities[dimension].n_elem << "] for this distribution."
<< std::endl;
}
probability *= probabilities[dimension][obs];
}
return probability;
}
/**
* Return the log probability of the given observation. If the observation is
* greater than the number of possible observations, then a crash will
* probably occur -- bounds checking is not performed.
*
* @param observation Observation to return the log probability of.
* @return Log probability of the given observation.
*/
double LogProbability(const arma::vec& observation) const
{
// TODO: consider storing log probabilities instead?
return log(Probability(observation));
}
/**
* Return a randomly generated observation (one-dimensional vector; one
* observation) according to the probability distribution defined by this
* object.
*
* @return Random observation.
*/
arma::vec Random() const;
/**
* Estimate the probability distribution directly from the given observations.
* If any of the observations is greater than numObservations, a crash is
* likely to occur.
*
* @param observations List of observations.
*/
void Train(const arma::mat& observations);
/**
* Estimate the probability distribution from the given observations, taking
* into account the probability of each observation actually being from this
* distribution.
*
* @param observations List of observations.
* @param probabilities List of probabilities that each observation is
* actually from this distribution.
*/
void Train(const arma::mat& observations,
const arma::vec& probabilities);
//! Return the vector of probabilities for the given dimension.
arma::vec& Probabilities(const size_t dim = 0) { return probabilities[dim]; }
//! Modify the vector of probabilities for the given dimension.
const arma::vec& Probabilities(const size_t dim = 0) const
{ return probabilities[dim]; }
/**
* Serialize the distribution.
*/
template<typename Archive>
void serialize(Archive& ar, const unsigned int /* version */)
{
ar & BOOST_SERIALIZATION_NVP(probabilities);
}
private:
//! The probabilities for each dimension; each arma::vec represents the
//! probabilities for the observations in each dimension.
std::vector<arma::vec> probabilities;
};
} // namespace distribution
} // namespace mlpack
#endif
| [
"qq79402005@gmail.com"
] | qq79402005@gmail.com |
432735ab031ab1ce45c6a6a7ff748740881c8024 | 8b3e6319a91aaea381ff6dac26ddbe6018b75dd2 | /src/univalue/lib/univalue_write.cpp | c13c7ddfc9b94044003e8abd6139c92fb16c61f9 | [
"MIT"
] | permissive | JihanSilbert/Titan | 9ddd7d57a6fa59501ac748c853ef5ff3a12ba51e | 4dfd180ca8518c3ba7160c6cf113eb4e1237c42d | refs/heads/master | 2020-08-15T16:07:37.998031 | 2019-10-19T10:45:49 | 2019-10-19T10:45:49 | 215,368,860 | 0 | 0 | MIT | 2019-10-15T18:27:27 | 2019-10-15T18:27:27 | null | UTF-8 | C++ | false | false | 2,817 | cpp | // Copyright (c) 2015-2017 The Bitcoin Core developers
// Copyright (c) 2017 The Raven Core developers
// Copyright (c) 2018 The Titancoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <iomanip>
#include <sstream>
#include <stdio.h>
#include "univalue.h"
#include "univalue_escapes.h"
using namespace std;
static string json_escape(const string& inS)
{
string outS;
outS.reserve(inS.size() * 2);
for (unsigned int i = 0; i < inS.size(); i++) {
unsigned char ch = inS[i];
const char *escStr = escapes[ch];
if (escStr)
outS += escStr;
else
outS += ch;
}
return outS;
}
string UniValue::write(unsigned int prettyIndent,
unsigned int indentLevel) const
{
string s;
s.reserve(1024);
unsigned int modIndent = indentLevel;
if (modIndent == 0)
modIndent = 1;
switch (typ) {
case VNULL:
s += "null";
break;
case VOBJ:
writeObject(prettyIndent, modIndent, s);
break;
case VARR:
writeArray(prettyIndent, modIndent, s);
break;
case VSTR:
s += "\"" + json_escape(val) + "\"";
break;
case VNUM:
s += val;
break;
case VBOOL:
s += (val == "1" ? "true" : "false");
break;
}
return s;
}
static void indentStr(unsigned int prettyIndent, unsigned int indentLevel, string& s)
{
s.append(prettyIndent * indentLevel, ' ');
}
void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, string& s) const
{
s += "[";
if (prettyIndent)
s += "\n";
for (unsigned int i = 0; i < values.size(); i++) {
if (prettyIndent)
indentStr(prettyIndent, indentLevel, s);
s += values[i].write(prettyIndent, indentLevel + 1);
if (i != (values.size() - 1)) {
s += ",";
}
if (prettyIndent)
s += "\n";
}
if (prettyIndent)
indentStr(prettyIndent, indentLevel - 1, s);
s += "]";
}
void UniValue::writeObject(unsigned int prettyIndent, unsigned int indentLevel, string& s) const
{
s += "{";
if (prettyIndent)
s += "\n";
for (unsigned int i = 0; i < keys.size(); i++) {
if (prettyIndent)
indentStr(prettyIndent, indentLevel, s);
s += "\"" + json_escape(keys[i]) + "\":";
if (prettyIndent)
s += " ";
s += values.at(i).write(prettyIndent, indentLevel + 1);
if (i != (values.size() - 1))
s += ",";
if (prettyIndent)
s += "\n";
}
if (prettyIndent)
indentStr(prettyIndent, indentLevel - 1, s);
s += "}";
}
| [
"info@jccoin.co"
] | info@jccoin.co |
45527ec5188b4b27aa13c4eb7e5ee69322db4937 | da9f803fbee92988023cb8d202425bc6284b96f6 | /seleccion.h | 37e7b88f35cb2bcba733618fa0eccf6f0da0ea2b | [
"MIT"
] | permissive | SamuelFlo/Examen2_SamuelFlores | 6c126c3f61a001e36c3d226647d2f3166852e6a5 | a935e55312638ddeba739f8b652c50a9906302de | refs/heads/master | 2020-03-21T23:25:49.069168 | 2018-06-30T02:47:54 | 2018-06-30T02:47:54 | 139,186,895 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 763 | h | #ifndef SELECCION_H
#define SELECCION_H
#include <string>
#include <fstream>
using namespace std;
class Seleccion{
private:
string nombreseleccion,maximogoleador;
int partidosganados,perdidos,empatados,golesanotados;
public:
Seleccion();
Seleccion(string,int,int,int,int,string);
//getters
string getNombreSeleccion();
int getPartidosGanados();
int getPerdidos();
int getEmpatados();
int getGolesAnotados();
string getMaximoGoleador();
//setters
void setNombreSeleccion(string);
void setPartidosGanados(int);
void setPerdidos(int);
void setEmpatados(int);
void setGolesAnotados(int);
void setMaximoGoleador(string);
//Guardar
void write();
void leer(ifstream&);
};
#endif
| [
"samuelflores100@hotmail.com"
] | samuelflores100@hotmail.com |
c31281c4e994964146662285d237be89d6915d98 | 6c05df7978ad82e760bdc991b4b297ca12a765a3 | /core/controller.cpp | a68c90a15a1ba91268b64c9d34cd2b36d654453c | [] | no_license | f4gkr/PicTalk | 358bce9ce0c6f27fc0d9a98ec83295b7cb324016 | d67fe67ee8757c4ed485833f8ab87cabc4f71bc1 | refs/heads/master | 2023-05-12T00:33:32.806943 | 2023-04-29T13:28:10 | 2023-04-29T13:28:10 | 117,544,861 | 15 | 2 | null | 2022-06-24T16:47:17 | 2018-01-15T12:50:46 | C++ | UTF-8 | C++ | false | false | 12,785 | cpp | //==========================================================================================
// + + + This Software is released under the "Simplified BSD License" + + +
// Copyright F4GKR Sylvain AZARIAN . All rights reserved.
//
//Redistribution and use in source and binary forms, with or without modification, are
//permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
//
//THIS SOFTWARE IS PROVIDED BY Sylvain AZARIAN F4GKR ``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 Sylvain AZARIAN 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.
//
//The views and conclusions contained in the software and documentation are those of the
//authors and should not be interpreted as representing official policies, either expressed
//or implied, of Sylvain AZARIAN F4GKR.
//==========================================================================================
#include "controller.h"
#include "common/samplefifo.h"
#include "common/constants.h"
#include <QApplication>
#define STEP_SIZE 16384
#define FFT_SPECTRUM_LEN 4096
#define FFT_SPECTRUM_LEN_WIDE 16384
Controller::Controller() : QThread(NULL)
{
radio = NULL ;
m_stop = false ;
m_state = Controller::csInit ;
channelizer = NULL ;
processor = new FrameProcessor();
mFFT_SIZE = FFT_SPECTRUM_LEN ;
fftin = NULL ;
plan = NULL ;
spectrum = NULL ;
hamming_coeffs = NULL ;
connect( processor, SIGNAL(powerLevel(float)), this, SLOT(SLOT_powerLevelChanged(float)));
connect( processor, SIGNAL(newState(QString)), this, SLOT(SLOT_frameDetectorStateChanged(QString)));
connect( processor, SIGNAL(newSNRThreshold(float)), this, SLOT(SLOT_FPSetsNewThreshold(float)));
sempos = new QSemaphore(1);
GlobalConfig& gc = GlobalConfig::getInstance() ;
tp = new TuningPolicy();
gc.getTuneParameters( gc.cRX_FREQUENCY , tp);
rx_tune_request = gc.getReceivedFrequency(tp);
spectrum_interleave = 1 ;
spectrum_interleave_value = 1 ;
if( gc.fft_rate > 0 ) {
spectrum_interleave = gc.fft_rate ;
}
reestimate_noise = 0 ;
webs = NULL ;
}
Controller::~Controller() {
fftwf_free(fftin);
fftin = NULL ;
fftwf_destroy_plan(plan);
plan = NULL ;
free(spectrum);
free(hamming_coeffs);
delete semspectrum ;
}
void Controller::setWebservice(WebService *ws) {
this->webs = ws ;
if( webs != NULL ) {
connect( webs, SIGNAL(mtuneTo(qint64)),
this, SLOT(setRxCenterFrequency(qint64)), Qt::QueuedConnection );
connect( webs, SIGNAL(mturnOn()),
this, SLOT(startAcquisition()), Qt::QueuedConnection);
connect( webs, SIGNAL(mturnOff()),
this, SLOT(stopAcquisition()), Qt::QueuedConnection );
}
}
void Controller::hamming_window(double *win, int win_size)
{
int i;
if( win == NULL ) return ;
for (i = 0; i < win_size; i++)
{
win[i] = (0.3635819 - 0.4891775 * cos((K_2PI * i) / (win_size - 1))
+ 0.1365995 * cos((2.0 * K_2PI * i) / (win_size - 1))
- 0.0106411 * cos((3.0 * K_2PI * i) / (win_size - 1)));
}
}
void Controller::setRadio(RxDevice *radio) {
int radio_rate = radio->getRxSampleRate() ;
this->radio = radio ;
channelizer = new OverlapSave( radio_rate, DEMODULATOR_SAMPLERATE );
mFFT_SIZE = FFT_SPECTRUM_LEN ;
if( radio_rate > 5e6 ) {
channelizer->configure( 128*1024, 65536 );
mFFT_SIZE = FFT_SPECTRUM_LEN_WIDE ;
} else if( radio_rate > 1e6 ) {
channelizer->configure( 128*1024, 16384 );
} else {
channelizer->configure( 32*1024, 16384 );
}
fftin = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * mFFT_SIZE );
plan = fftwf_plan_dft_1d(mFFT_SIZE, fftin, fftin, FFTW_FORWARD, FFTW_ESTIMATE );
spectrum = (double *)malloc( mFFT_SIZE * sizeof(double));
hamming_coeffs = (double *)malloc( mFFT_SIZE * sizeof( double ));
memset( spectrum, 0, mFFT_SIZE );
semspectrum = new QSemaphore(1);
hamming_window( hamming_coeffs, mFFT_SIZE ) ;
connect( this, SIGNAL(radioStart()), radio, SLOT(SLOT_start()), Qt::QueuedConnection );
connect( this, SIGNAL(radioStop()), radio, SLOT(SLOT_stop()), Qt::QueuedConnection );
}
void Controller::setRxCenterFrequency(qint64 frequency) {
this->rx_tune_request = frequency ;
}
void Controller::startAcquisition() {
qDebug() << "Controller::startAcquisition() " ;
if( !this->isRunning() )
return ;
if( m_state == Controller::csIdle ) {
next_state = Controller::csStart ;
qDebug() << "Controller::startAcquisition() change state " ;
}
return ;
}
void Controller::stopAcquisition() {
if( !this->isRunning() )
return ;
if( m_state == Controller::csRun ) {
next_state = Controller::csStop ;
}
return ;
}
bool Controller::isAcquiring() {
return( m_state ==Controller::csRun ) ;
}
void Controller::close() {
m_stop = true ;
radio->stopAcquisition() ;
while( m_state != Controller::csEnded ) {
QThread::msleep(10);
}
radio->close();
}
float Controller::setDetectionThreshold(float level) {
return( processor->setDetectionThreshold(level) );
}
void Controller::SLOT_FPSetsNewThreshold( float value ) {
emit newSNRThreshold(value);
}
void Controller::setSpectrumInterleaveValue( int interleave ) {
spectrum_interleave = qMax( FFTRATE_MAX - interleave , 1);
}
void Controller::doNoiseEstimation() {
reestimate_noise++ ;
}
void Controller::run() {
int i ;
next_state = m_state ;
SampleFifo *fifo = NULL ;
TYPECPX* samples ;
int sample_count ;
GlobalConfig& gc = GlobalConfig::getInstance() ;
qDebug() << "Controller::run() " ;
//processor->moveToThread(this);
while( !m_stop ) {
if( next_state != m_state ) {
qDebug() << "transition from " << m_state << " to " << next_state ;
m_state = next_state ;
}
switch( m_state ) {
case Controller::csInit:
if( radio == NULL) {
break ;
}
fifo = radio->getFIFO() ;
next_state = Controller::csIdle ;
break ;
case Controller::csIdle:
QThread::msleep(100);
break ;
case Controller::csStart:
for( i=0 ; i < mFFT_SIZE ; i++ ) {
spectrum[i] = -100 ;
}
if( radio != NULL )
radio->setRxCenterFreq( tp );
processor->raz();
channelizer->reset();
channelizer->setCenterOfWindow( tp->channelizer_offset );
emit radioStart();
if( webs != NULL ) {
webs->reportStatus( true, tp->rx_hardware_frequency + tp->channelizer_offset );
}
next_state = Controller::csRun ;
break ;
case Controller::csRun:
if( fifo == NULL ) {
next_state = Controller::csInit ;
break ;
}
samples = (TYPECPX *)fifo->DequeueData( &sample_count, 0, NULL, true );
if( (samples == NULL ) || (sample_count==0)) {
QApplication::processEvents();
msleep(1);
continue ;
}
//qDebug() << " fifo " << fifo->getSize() ;
process( samples, sample_count );
if( rx_tune_request > 0 ) {
gc.getTuneParameters( rx_tune_request, tp );
rx_tune_request = 0 ;
if( radio != NULL ) {
radio->setRxCenterFreq( tp );
}
processor->raz();
}
break ;
case Controller::csStop:
emit radioStop();
next_state = Controller::csIdle ;
if( webs != NULL ) {
webs->reportStatus( false, tp->rx_hardware_frequency + tp->channelizer_offset );
}
break ;
}
}
m_state = csEnded ;
qDebug() << "Controller::run() ends" ;
}
void Controller::process( TYPECPX*samples, int L ) {
TYPECPX* pt = samples ;
TYPECPX out[STEP_SIZE] ;
int rc,pushback_samples ;
int left = L ;
//qDebug() << "Controller::process() L=" << L ;
//printf("L=%d\n", L );
if( (L >= mFFT_SIZE ) && (spectrum_interleave>0)){
spectrum_interleave_value-- ;
if( spectrum_interleave_value <= 0 ) {
generateSpectrum(samples);
emit newSpectrumAvailable(mFFT_SIZE, tp );
spectrum_interleave_value = spectrum_interleave ;
}
}
while( left > 0 ) {
int qty = qMin(left, (int)STEP_SIZE) ;
rc = channelizer->put(pt, qty) ;
if( rc < 0 ) {
break ;
}
left -= qty ;
pt += qty ;
if( rc == GET_DATA_OUT ) {
rc = channelizer->get( out, STEP_SIZE, PREAMBLE_LENGTH ) ;
while( rc > 0 ) {
pushback_samples = processor->newData( out, rc, channelizer->getOLASOutSampleRate() );
if( pushback_samples ) {
// rc is number of samples to pushback
TYPECPX *tmp = &out[0] ;
tmp += rc - 1 - pushback_samples ; // shift pointer
channelizer->pushback( tmp, pushback_samples );
}
rc = channelizer->get( out, STEP_SIZE , PREAMBLE_LENGTH) ;
}
}
}
//
if( reestimate_noise > 0 ) {
processor->updateNoiseLevel();
reestimate_noise = 0 ;
}
free(samples);
return ;
}
void Controller::generateSpectrum( TYPECPX *samples ) {
int i,j ;
double cpow = 2.0/mFFT_SIZE ;
smin = 0 ;
smax = -200 ;
// apply window
for (i = 0; i < mFFT_SIZE;i++)
{
fftin[i][0] = samples[i].re * hamming_coeffs[i];
fftin[i][1] = samples[i].im * hamming_coeffs[i];
}
//compute FFT
fftwf_execute( plan );
//extract ft and compute power
semspectrum->acquire(1);
// neg portion of spectrum
j = 0 ;
for( i=mFFT_SIZE/2 ; i < mFFT_SIZE ; i++ ) {
float a = fftin[i][0];
float b = fftin[i][1];
float modulus = sqrtf( a*a + b*b );
double dbFs = 20*log10( cpow * modulus + 1e-10 );
spectrum[j] = .9*spectrum[j] + .1*dbFs ;
if( spectrum[j] > smax ) smax = spectrum[j] ;
if( spectrum[j] < smin ) smin = spectrum[j] ;
j++ ;
}
// pos spectrum
for( i=0 ; i < mFFT_SIZE/2 ; i++ ) {
float a = fftin[i][0];
float b = fftin[i][1];
float modulus = sqrtf( a*a + b*b );
double dbFs = 20*log10( cpow * modulus + 1e-10);
spectrum[j] = .9*spectrum[j] + .1*dbFs ;
if( spectrum[j] > smax ) smax = spectrum[j] ;
if( spectrum[j] < smin ) smin = spectrum[j] ;
j++ ;
}
semspectrum->release(1);
}
void Controller::getSpectrum( double* values ) {
if( values == NULL )
return ;
semspectrum->acquire(1);
memcpy( values, spectrum, mFFT_SIZE*sizeof(double));
semspectrum->release(1);
}
void Controller::SLOT_frameDetectorStateChanged( QString stateName ) {
emit newState( stateName );
//qDebug() << "Controller::SLOT_frameDetectorStateChanged" << stateName ;
}
void Controller::SLOT_powerLevelChanged( float level ) {
emit powerLevel(level);
}
| [
"sylvain.azarian@gmail.com"
] | sylvain.azarian@gmail.com |
dc89d65e430a9fb01fe14c8d6e8f63d220614d07 | ddb7bc13edaeb094880092c227b9967b5ef1d964 | /logdevice/admin/settings/AdminServerSettings.h | a4308cb4aa614170a63832002f8df6b5e4756dcf | [
"BSD-3-Clause"
] | permissive | dmitris/LogDevice | 7c52e9acc36b8d14578f949b46b3e5054174603f | 18336bb95262c51d9b1e8f2f9ae9ad0874b023cd | refs/heads/master | 2020-11-25T06:02:54.353997 | 2019-12-17T04:10:28 | 2019-12-17T04:13:06 | 228,531,081 | 0 | 0 | NOASSERTION | 2019-12-17T04:15:44 | 2019-12-17T04:15:44 | null | UTF-8 | C++ | false | false | 2,430 | h | /**
* Copyright (c) 2017-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include "logdevice/common/settings/UpdateableSettings.h"
#include "logdevice/common/util.h"
namespace boost { namespace program_options {
class options_description;
}} // namespace boost::program_options
namespace facebook { namespace logdevice {
struct AdminServerSettings : public SettingsBundle {
const char* getName() const override {
return "AdminServerSettings";
}
void defineSettings(SettingEasyInit& init) override;
// See cpp file for a documentation about these settings.
// If admin_unix_socket is set, we ignore the admin_port. This needs to be
// empty in order to use the IPv4/6 interface.
std::string admin_unix_socket;
int admin_port;
int safety_max_logs_in_flight;
size_t safety_check_failure_sample_size;
size_t safety_check_max_batch_size;
int max_unavailable_storage_capacity_pct;
int max_unavailable_sequencing_capacity_pct;
bool enable_cluster_maintenance_state_machine;
// Allow the maintenance log to be snapshotted onto a snapshot log
bool maintenance_log_snapshotting;
std::chrono::milliseconds maintenance_log_snapshotting_period;
// How many delta records to keep in the maintenance log before we snapshot
// it.
size_t maintenance_log_max_delta_records;
// How many bytes of delta records to keep in the event log before we snapshot
// it
size_t maintenance_log_max_delta_bytes;
// Disable trimming of the maintenance log
bool disable_maintenance_log_trimming;
bool read_metadata_from_sequencers;
bool enable_safety_check_periodic_metadata_update;
std::chrono::milliseconds safety_check_metadata_update_period;
// If true, start maintenance manager
bool enable_maintenance_manager;
// Timeout after which a reevaluation is scheduled to run in
// MaintenanceManager
std::chrono::milliseconds maintenance_manager_reevaluation_timeout;
// How often to check if Metadata Nodeset needs to be updated
std::chrono::milliseconds maintenance_manager_metadata_nodeset_update_period;
;
private:
// Only UpdateableSettings can create this bundle.
AdminServerSettings() {}
friend class UpdateableSettingsRaw<AdminServerSettings>;
};
}} // namespace facebook::logdevice
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
b5526ec0b5d3b17fd4f410370d61be7d6e40a137 | 249226a48cbebae0009a655ddd88fc7676c79730 | /server/environment.h | 708612a90dc98c171f05d9d87a68c12b7bacb4d9 | [] | no_license | ivm3rz/tiny_fcgi_server | 336ef534a8179e8e1cf31a9bee9cf91dc976f7e1 | ee7108586a0e07806181f15254153bb676d4c42a | refs/heads/master | 2023-09-04T16:40:56.775826 | 2021-11-24T10:22:03 | 2021-11-24T10:22:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,151 | h | /// @file
/// @brief
/// @copyright Copyright (c) InfoTeCS. All Rights Reserved.
#pragma once
#include <unordered_map>
#include <error/exception.h>
struct FCGX_Request;
namespace alexen {
namespace server {
namespace fcgi {
class Environment
{
public:
struct Error : error::Exception
{
Error( const std::string& what ) : Exception{ what } {}
};
struct KeyNotFound : Error
{
KeyNotFound( std::string_view key )
: Error{ "'" + std::string{ key } + "' not found" } {}
};
using KeyValue = std::unordered_map< std::string_view, std::string_view >;
explicit Environment( const FCGX_Request& request );
explicit Environment( const char* const env[] );
KeyValue::const_iterator begin() const noexcept;
KeyValue::const_iterator end() const noexcept;
std::string_view get( std::string_view key ) const;
bool has( std::string_view key ) const noexcept;
private:
void parse( const char* const envp[] );
KeyValue env_;
};
} // namespace fcgi
} // namespace server
} // namespace alexen
| [
"Aleksey.Enakaev@infotecs.ru"
] | Aleksey.Enakaev@infotecs.ru |
dcb9c0f833d62ba246545c5efac19fe4314d6225 | 21da8e3490769f0062fad806abc119ed0334b7cc | /CodeForces/878/A.cpp | 7b0bb7536f26edff6a49dc10743b2b5a1e03880f | [] | no_license | nikhilhassija/CompetitiveProgramming | d2e0606c1badd3209452d670a99234a3ef0d5d6c | 794deb2ef26d03471e78c6fb77f3a72d810d19f1 | refs/heads/master | 2020-04-05T23:06:20.363385 | 2017-12-22T21:19:16 | 2017-12-22T21:19:16 | 42,791,366 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 322 | cpp | #include <bits/stdc++.h>
#define lli long long int
#define pb push_back
#define pii pair <int, int>
#define pll pair <lli, lli>
#define _F first
#define _S second
#define mset(x) memset(x, 0, sizeof(x))
#define fastio() ios_base::sync_with_stdio(0); cin.tie(NULL)
using namespace std;
int main()
{
return (0-0);
} | [
"nikhil.hassija@gmail.com"
] | nikhil.hassija@gmail.com |
d373997e1eda80191200be552c65b47e8987ed28 | e0ec926e9c23d9064aad152c14d2070a468d2b0f | /src/algorithms/data_structures/sll/palindrome_sll.hpp | 9b108dbd96fd508844371a8a2555ebb7143f4e10 | [
"MIT"
] | permissive | xGreat/CppNotes | 6aae7497dda51d909097731c03593d9dbb302161 | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | refs/heads/master | 2023-02-22T00:10:46.391669 | 2021-01-21T09:24:25 | 2021-01-21T09:24:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,330 | hpp | #ifndef PALINDROME_SLL_HPP
#define PALINDROME_SLL_HPP
// https://leetcode.com/problems/palindrome-linked-list/description/
// Given a singly linked list, determine if it is a palindrome.
// Follow up:
// Could you do it in O(n) time and O(1) space?
#include "types/ds/singly_linked_list_nodes.hpp"
namespace Algo::DS::SLL {
class PalindromeDetection {
public:
template<typename T>
static bool IsPalindrome(NodeSLL<T>* head) {
NodeSLL<T>* pre = nullptr;
NodeSLL<T>* fast = head;
NodeSLL<T>* slow = head;
//reverse list
while(fast != nullptr && fast->next != nullptr) {
fast = fast->next->next;
NodeSLL<T>* tmp = slow;
slow = slow->next;
tmp->next = pre;
pre = tmp;
}
if(fast != nullptr) {
slow = slow->next;
}
return IsSameList(pre, slow);
}
private:
template<typename T>
static bool IsSameList(NodeSLL<T>* firstSLL, NodeSLL<T>* secondSLL) {
while(firstSLL != nullptr && secondSLL != nullptr) {
if (firstSLL->value != secondSLL->value) {
return false;
}
firstSLL = firstSLL->next;
secondSLL = secondSLL->next;
}
return true;
}
};
}
#endif // PALINDROME_SLL_HPP
| [
"antony.cherepanov@gmail.com"
] | antony.cherepanov@gmail.com |
4bddd1c1ca4a1b4ef2221224e1ddb25b3c3074b4 | 7ed641452ef59f901984af16832e3be69972e37f | /include/hermes/DependencyExtractor/GraphQLDependencyExtractor.h | 912d3e5685e2844eb45ed4c569683de3f8b6563b | [
"MIT"
] | permissive | mrousavy/hermes | 6e8e80b7f8fff30caf408c6b3b0a03251fd34d35 | 6e5868763b08eb80f4164a926abb92fa5c71117f | refs/heads/master | 2023-08-07T20:35:27.370384 | 2021-09-02T20:09:21 | 2021-09-02T20:10:36 | 355,471,392 | 2 | 0 | MIT | 2021-04-07T08:54:03 | 2021-04-07T08:36:20 | null | UTF-8 | C++ | false | false | 2,009 | h | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#ifndef HERMES_DEPENDENCYEXTRACTOR_GRAPHQLDEPENDENCYEXTRACTOR_H
#define HERMES_DEPENDENCYEXTRACTOR_GRAPHQLDEPENDENCYEXTRACTOR_H
#include "hermes/Regex/Executor.h"
#include "hermes/Regex/Regex.h"
#include "hermes/Regex/RegexTraits.h"
namespace hermes {
namespace graphql {
/// Returns regex bytecode for detecting and extracting graphql dependencies
inline std::vector<uint8_t> getCompiledGraphQLRegex() {
/// Bytecode for the regex that detects dependencies in GraphQL template
/// literals.
regex::Regex<regex::UTF16RegexTraits> graphqlQueryRegex{
u"(?:^\\s*?(?:query|fragment|mutation|subscription) +(\\w+))", u"m"};
return graphqlQueryRegex.compile();
}
/// Extracts graphql dependencies from graphQL template literals.
/// \param templateString graphql string with possible dependencies.
/// \param graphqlQueryRegexBytecode regex for matching and extracting
/// dependencies.
/// \param callback called with StringRef regex captures found by
/// the graphqlQueryRegexBytecode expression. Returns void.
template <typename ElementCB>
void getGraphQLDependencies(
llvh::StringRef templateString,
std::vector<uint8_t> &graphqlQueryRegexBytecode,
ElementCB callback) {
std::vector<regex::CapturedRange> captures{};
uint32_t searchStart = 0;
for (;;) {
captures.clear();
regex::MatchRuntimeResult matchResult = regex::searchWithBytecode(
graphqlQueryRegexBytecode,
templateString.data(),
searchStart,
templateString.size(),
&captures,
regex::constants::MatchFlagType::matchDefault);
if (matchResult != regex::MatchRuntimeResult::Match) {
return;
}
callback(templateString.slice(captures[1].start, captures[1].end));
searchStart = captures[0].end;
}
}
} // namespace graphql
} // namespace hermes
#endif
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
c7609932d372ea891f14e3c2534ac183a7432881 | 3a103ad1fc799ce85943c78bcaf092e34208c0e2 | /Source/BoundingVolume.cpp | 5c016fbad0f909fb4fa8e84b9f8e78c2416bf0a6 | [] | no_license | whirlp00l/rendering | 2e93d5c6835e054e85f9710efac27de938cae445 | 770c2ad19b62fd8dce86ff0ebf2c7ffc829893ca | refs/heads/master | 2020-05-16T23:19:16.307640 | 2010-10-20T22:36:47 | 2010-10-20T22:36:47 | 37,064,816 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,241 | cpp | #include "BoundingVolume.h"
#include "DebugMem.h"
BoundingVolume::BoundingVolume( Objects * objects, bool isLeaf ) :
m_bIsLeaf( isLeaf )
{
// now add each bounded object to this bounding volume
for( size_t i = 0; i < objects->size(); i++ )
{
m_children.push_back( (*objects)[i] );
}
}
BoundingVolume::~BoundingVolume()
{
for( unsigned int i = 0; i < m_children.size(); i++ )
{
if( m_children[i] )
{
delete m_children[i];
m_children[i] = NULL;
}
}
m_children.clear();
}
void
BoundingVolume::addChild( Object * child )
{
m_children.push_back( child );
}
void
BoundingVolume::calcNumNodesAndLeaves( int * numNodesPtr, int * numLeavesPtr )
{
// this is a node, increment the node count
(*numNodesPtr)++;
// if it's a leaf, don't loop through (primitive) children
if( m_bIsLeaf )
{
// increment number of leaves
(*numLeavesPtr)++;
}
// not a leaf, so loop through all children as well
else
{
for( size_t i = 0; i < m_children.size(); i++ )
{
// since this isn't a leaf, each child is a bounding volume
BoundingVolume * childBV = ( BoundingVolume * )m_children[i];
childBV->calcNumNodesAndLeaves( numNodesPtr, numLeavesPtr );
}
}
} | [
"DaStar2B@82a46b14-ece5-f9c8-6756-62631a89e06b"
] | DaStar2B@82a46b14-ece5-f9c8-6756-62631a89e06b |
f5a47b9aa95734179d116079aabcefd137bc86a9 | 69b9cb379b4da73fa9f62ab4b51613c11c29bb6b | /submissions/abc122_c/main.cpp | a6bbe186c1f5dc2a29b780b37d19978f53a42d82 | [] | no_license | tatt61880/atcoder | 459163aa3dbbe7cea7352d84cbc5b1b4d9853360 | 923ec4d5d4ae5454bc6da2ac877946672ff807e7 | refs/heads/main | 2023-07-16T16:19:22.404571 | 2021-08-15T20:54:24 | 2021-08-15T20:54:24 | 118,358,608 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 882 | cpp | //{{{
#include <bits/stdc++.h>
using namespace std;
#define repX(a,b,c,x,...) x
#define repN(a) repX a
#define rep(...) repN((__VA_ARGS__,rep3,rep2,loop))(__VA_ARGS__)
#define rrep(...) repN((__VA_ARGS__,rrep3,rrep2))(__VA_ARGS__)
#define loop(n) rep2(i_,n)
#define rep2(i,n) rep3(i,0,n)
#define rep3(i,begin,end) for(int i=(int)(begin),i##_end=(int)(end);i<i##_end;++i)
#define rrep2(i,n) rrep3(i,n,0)
#define rrep3(i,begin,end) for(int i=(int)(begin-1),i##_end=(int)(end);i>=i##_end;--i)
#define foreach(x,a) for(auto&x:a)
using ll=long long;
const ll mod=(ll)1e9+7;
//}}}
int ac_num[100001];
int main(){
int N, Q;
cin >> N >> Q;
string S;
cin >> S;
rep(i, 1, N){
ac_num[i + 1] = ac_num[i] + (S[i] == 'C' && S[i - 1] == 'A' ? 1 : 0);
}
rep(i, Q){
int l, r;
cin >> l >> r;
int ans = ac_num[r] - ac_num[l];
cout << ans << endl;
}
return 0;
}
| [
"tatt61880@gmail.com"
] | tatt61880@gmail.com |
970e525756aa2db3a2765f78ac94b9f5b0deb95b | e5fea2b1aa08032158ed843ea99207f5f17db5f3 | /HandMaker.cpp | 6b0cc2022ffc0670d9096ef60039f4975d534579 | [] | no_license | PulseKim/Grsp_Testing | 0aa846537168b32160410ead05d2f8ccec273c42 | f11a6353044f89ee684578cb37c1f1fba6854ef1 | refs/heads/master | 2020-07-09T05:50:52.033937 | 2019-09-18T06:22:37 | 2019-09-18T06:22:37 | 203,899,661 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,656 | cpp | #include "HandMaker.h"
HandMaker::HandMaker(const SkeletonPtr& inHand, std::string dir) : mHand(inHand)
{
if(dir == "left") currentDirection = 0;
else if(dir == "right") currentDirection = 1;
else currentDirection = -1;
}
void HandMaker::makeHand()
{
this->makeArm();
this->makePalm();
this->makeFingers();
int indicator = currentDirection == 0 ? 1 : -1;
int index_thumb = mHand->getIndexOf(mHand->getBodyNode("thumb metacarpal")->getParentJoint()->getDof(0));
mHand->setPosition(index_thumb, 80*M_PI/180);
mHand->setPosition(index_thumb+1, indicator* -60*M_PI/180);
mHand->setPosition(index_thumb+3, indicator* 20*M_PI/180);
}
void HandMaker::makeArm()
{
BodyNode* bn;
Eigen::Vector3d boxsize(0.01, 0.01, 0.01);
double rad = 0.02, height = 0.25;
Eigen::Vector3d color = dart::Color::Green();
double mass = 0.1;
bn = skel.weldBox(mHand, nullptr, "weld", boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(-0.1,0.2,-0.2), 0.001, dart::Color::White());
bn = skel.ballCylinder(mHand, bn, "arm", rad, height, Eigen::Vector3d(0,0,-height/2), Eigen::Vector3d(0,0,boxsize[2]/2), mass, dart::Color::Fuchsia());
currentParent = bn;
}
void HandMaker::makePalm()
{
BodyNode* bn;
Eigen::Vector3d boxsize(0.1, 0.02, 0.09);
palmSize = boxsize;
Eigen::Vector3d color = dart::Color::Green();
double mass = 0.1;
bn = skel.ballBox(mHand, currentParent, "palm", boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(0,0,0.25/2), mass, color);
currentParent = bn;
}
void HandMaker::makeFingers()
{
this->makeThumb();
for(int i = 0; i < 4; ++i)
this->makeSingleFinger(i);
}
void HandMaker::makeSingleFinger(int idx)
{
BodyNode* bn;
Eigen::Vector3d color = dart::Color::Green();
double gap = 0.001;
double fing_x = palmSize[0] / 4 - gap;
double fing_len = 0.07;
double mass_long = 0.04;
double mass_short = 0.02;
double epsilon = 1E-10;
Eigen::Vector3d patch(0.001, epsilon, 0.001);
double offset;
if(currentDirection == 0)
offset = -palmSize[0]/2 + gap*idx + fing_x/2 + fing_x * idx;
else if(currentDirection == 1)
offset = palmSize[0]/2 -(gap*idx + fing_x/2 + fing_x * idx);
bn = skel.univCylinder(mHand, currentParent, "metacarpal" + std::to_string(idx), Eigen::Vector3d::UnitX(), Eigen::Vector3d::UnitY(), fing_x/2, fing_len, Eigen::Vector3d(0,0,-fing_len/2), Eigen::Vector3d(offset, 0, palmSize[2]/2), mass_long, color);
bn = skel.revolCylinder(mHand, bn, "proxphalanx" + std::to_string(idx), Eigen::Vector3d::UnitX(), fing_x/2, 0.05, Eigen::Vector3d(0,0,-0.05/2), Eigen::Vector3d(0,0,fing_len/2), mass_short, color);
fing_len = 0.05;
bn = skel.revolCylinder(mHand, bn, "distphalanx" + std::to_string(idx), Eigen::Vector3d::UnitX(), fing_x/2, 0.03-fing_x/2, Eigen::Vector3d(0,0,-(0.03-fing_x/2)/2), Eigen::Vector3d(0,0,fing_len/2), mass_short/3, color);
fing_len = 0.03-fing_x/2;
skel.weldBox(mHand, bn, "patch" + std::to_string(idx), patch, Eigen::Vector3d(0,0,0), Eigen::Vector3d(0,-fing_x/2,fing_len/2), epsilon, dart::Color::Orange());
skel.weldSphere(mHand, bn, "dummy" + std::to_string(idx), fing_x/2, Eigen::Vector3d(0,0,0), Eigen::Vector3d(0,0,(0.03-fing_x/2)/2), mass_short, color);
// Eigen::Vector3d boxsize(fing_x, palmSize[1], fing_len);
// bn = skel.univBox(mHand, currentParent, "metacarpal"+std::to_string(idx), Eigen::Vector3d::UnitX(), Eigen::Vector3d::UnitY(), boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(offset, 0, palmSize[2]/2), mass_long , color);
// boxsize[2] = 0.05;
// bn = skel.revolBox(mHand, bn, "proxphalanx"+std::to_string(idx), Eigen::Vector3d::UnitX(), boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(0,0,fing_len/2), mass_short, color);
// fing_len = 0.05;
// boxsize[2] = 0.03;
// bn = skel.revolBox(mHand, bn, "distphalanx"+std::to_string(idx), Eigen::Vector3d::UnitX(), boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(0,0,fing_len/2), mass_short, color);
}
void HandMaker::makeThumb()
{
BodyNode* bn;
Eigen::Vector3d color = dart::Color::Green();
double fing_x = palmSize[0] / 3;
double fing_len = 0.06;
double theta = 30 * M_PI / 180;
double mass_long = 0.04;
double mass_short = 0.02;
double epsilon = 1E-10;
Eigen::Vector3d patch(epsilon, 0.001, 0.001);
Eigen::Vector3d offset;
if(currentDirection == 0)
offset = Eigen::Vector3d(-palmSize[0]/2, 0, -palmSize[2]/2);
else if(currentDirection == 1)
offset = Eigen::Vector3d(palmSize[0]/2, 0, -palmSize[2]/2);
Eigen::Vector3d boxsize(palmSize[1], fing_x, fing_len);
bn = skel.univCylinder(mHand, currentParent, "thumb metacarpal", Eigen::Vector3d::UnitX(), Eigen::Vector3d::UnitY(), fing_x/2, fing_len, Eigen::Vector3d(0,0,-boxsize[2]/2), offset,mass_long ,color);
boxsize[2] = 0.05;
bn = skel.univCylinder(mHand, bn, "thumb proxphalanx", Eigen::Vector3d::UnitX(), Eigen::Vector3d::UnitY(), fing_x/2, boxsize[2], Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(0,0,fing_len/2),mass_short ,color);
fing_len = 0.05;
boxsize[2] = 0.03 - fing_x/2;
bn = skel.revolCylinder(mHand, bn, "thumb distphalanx", Eigen::Vector3d::UnitY(), fing_x/2, boxsize[2], Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(0,0,fing_len/2), mass_short, color);
skel.weldSphere(mHand, bn, "thumb dummy", fing_x/2, Eigen::Vector3d(0,0,0), Eigen::Vector3d(0,0,boxsize[2]/2), mass_short, color);
if(currentDirection == 0)
skel.weldBox(mHand, bn, "thumbpatch", patch, Eigen::Vector3d(0,0,0), Eigen::Vector3d(fing_x/2,0, boxsize[2]/2), epsilon, dart::Color::Orange());
else
skel.weldBox(mHand, bn, "thumbpatch", patch, Eigen::Vector3d(0,0,0), Eigen::Vector3d(-fing_x/2,0, boxsize[2]/2), epsilon, dart::Color::Orange());
// bn = skel.univBox(mHand, currentParent, "thumb metacarpal", Eigen::Vector3d::UnitX(), Eigen::Vector3d::UnitY(), boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), offset,mass_long ,color);
// boxsize[2] = 0.05;
// bn = skel.univBox(mHand, bn, "thumb proxphalanx", Eigen::Vector3d::UnitX(), Eigen::Vector3d::UnitY(), boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(0,0,fing_len/2),mass_short ,color);
// fing_len = 0.05;
// boxsize[2] = 0.03;
// bn = skel.revolBox(mHand, bn, "thumb distphalanx", Eigen::Vector3d::UnitY(), boxsize, Eigen::Vector3d(0,0,-boxsize[2]/2), Eigen::Vector3d(0,0,fing_len/2), mass_short, color);
// if(currentDirection == 0)
// bn = skel.weldBox(mHand, bn, "thumbpatch", patch, Eigen::Vector3d(0,0,0), Eigen::Vector3d(boxsize[0]/2,0, boxsize[2]/2-patch[2]/2), epsilon, dart::Color::Orange());
// else
// bn = skel.weldBox(mHand, bn, "thumbpatch", patch, Eigen::Vector3d(0,0,0), Eigen::Vector3d(-boxsize[0]/2,0, boxsize[2]/2-patch[2]/2), epsilon, dart::Color::Orange());
} | [
"pulsekim@postech.ac.kr"
] | pulsekim@postech.ac.kr |
78e98c6ef6f0fea662ad7f6c248535f73be57402 | c90e36e1c590ba866139c8b38f54010f48f0149d | /public/source/moviepicwidget.cpp | 10f811eb55983214dc19579d5c521f6931d142f7 | [
"MIT"
] | permissive | AmuUncle/IcoTools | 57490df0981b3e7c2f6a51e8f129a980feabd329 | ed9e95d649b65e9e512a0c0183426cac66e4ff07 | refs/heads/master | 2023-08-29T17:56:36.100456 | 2021-09-14T09:09:01 | 2021-09-14T09:09:01 | 417,385,466 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,016 | cpp | ๏ปฟ#include "moviepicwidget.h"
#include <QPainter>
MoviePicWidget::MoviePicWidget(QWidget *parent) : QWidget(parent)
{
m_nPicIndex = 0;
}
void MoviePicWidget::SetPicList(QList<QPixmap> picList)
{
m_picList = picList;
}
void MoviePicWidget::Start(int interval)
{
if (m_picList.size() <= 0)
return;
m_nPicIndex = 0;
m_nTimerId = startTimer(50);
}
void MoviePicWidget::Stop()
{
killTimer(m_nTimerId);
}
void MoviePicWidget::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this); // ๅๅปบ็ปๅฎถๅฏน่ฑก
QRect rcClient = rect();
painter.drawPixmap(rcClient, m_curPic);
}
void MoviePicWidget::timerEvent(QTimerEvent *event)
{
if (m_nPicIndex < 0 || m_nPicIndex >= m_picList.size())
m_nPicIndex = 0;
if (m_picList.size() <= 0)
{
killTimer(m_nTimerId);
return;
}
m_curPic = m_picList[m_nPicIndex].scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
m_nPicIndex++;
update();
}
| [
"hudejie2018#163.com"
] | hudejie2018#163.com |
ca0da1520c849751b348769c8db050ca40f74686 | 7d6c3c50f13e92bae1822f706932b53456396dcc | /src/netbase.h | c3f4a2e883dc1d753c30761b6fe9f2f7701f84c5 | [
"MIT"
] | permissive | KillSwitch001/OPL-Coin | 6c61fe2aa295e9d534aaf36e81e6ce74943af8b7 | f223afd495ecd63779280fd6b01b83a95ddf0f93 | refs/heads/master | 2020-03-28T03:36:31.502706 | 2018-05-10T01:15:45 | 2018-05-10T01:15:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,609 | h | // Copyright (c) 2009-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.
#ifndef BITCOIN_NETBASE_H
#define BITCOIN_NETBASE_H
#if defined(HAVE_CONFIG_H)
#include "config/opl-config.h"
#endif
#include "compat.h"
#include "netaddress.h"
#include "serialize.h"
#include <stdint.h>
#include <string>
#include <vector>
extern int nConnectTimeout;
extern bool fNameLookup;
//! -timeout default
static const int DEFAULT_CONNECT_TIMEOUT = 5000;
//! -dns default
static const int DEFAULT_NAME_LOOKUP = true;
class proxyType
{
public:
proxyType(): randomize_credentials(false) {}
proxyType(const CService &proxy, bool randomize_credentials=false): proxy(proxy), randomize_credentials(randomize_credentials) {}
bool IsValid() const { return proxy.IsValid(); }
CService proxy;
bool randomize_credentials;
};
enum Network ParseNetwork(std::string net);
std::string GetNetworkName(enum Network net);
void SplitHostPort(std::string in, int &portOut, std::string &hostOut);
bool SetProxy(enum Network net, const proxyType &addrProxy);
bool GetProxy(enum Network net, proxyType &proxyInfoOut);
bool IsProxy(const CNetAddr &addr);
bool SetNameProxy(const proxyType &addrProxy);
bool HaveNameProxy();
bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup);
bool LookupHost(const char *pszName, CNetAddr& addr, bool fAllowLookup);
bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup);
bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions);
CService LookupNumeric(const char *pszName, int portDefault = 0);
bool LookupSubNet(const char *pszName, CSubNet& subnet);
bool ConnectSocket(const CService &addr, SOCKET& hSocketRet, int nTimeout, bool *outProxyConnectionFailed = 0);
bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault, int nTimeout, bool *outProxyConnectionFailed = 0);
/** Return readable error string for a network error code */
std::string NetworkErrorString(int err);
/** Close socket and set hSocket to INVALID_SOCKET */
bool CloseSocket(SOCKET& hSocket);
/** Disable or enable blocking-mode for a socket */
bool SetSocketNonBlocking(SOCKET& hSocket, bool fNonBlocking);
/**
* Convert milliseconds to a struct timeval for e.g. select.
*/
struct timeval MillisToTimeval(int64_t nTimeout);
void InterruptSocks5(bool interrupt);
#endif // BITCOIN_NETBASE_H
| [
"tstcoinproject@gmail.com"
] | tstcoinproject@gmail.com |
a4d4a886482d6f3c6d36d9282d39b786eaa79ad7 | 627d4d432c86ad98f669214d9966ae2db1600b31 | /unprocessed/tools/designer/src/lib/sdk/abstractpromotioninterface.h | a257d46a53d9e294a34f59954f76acd4cae1b956 | [] | no_license | fluxer/copperspice | 6dbab905f71843b8a3f52c844b841cef17f71f3f | 07e7d1315d212a4568589b0ab1bd6c29c06d70a1 | refs/heads/cs-1.1 | 2021-01-17T21:21:54.176319 | 2015-08-26T15:25:29 | 2015-08-26T15:25:29 | 39,802,091 | 6 | 0 | null | 2015-07-27T23:04:01 | 2015-07-27T23:04:00 | null | UTF-8 | C++ | false | false | 2,497 | h | /***********************************************************************
*
* Copyright (c) 2012-2015 Barbara Geller
* Copyright (c) 2012-2015 Ansel Sermersheim
* Copyright (c) 2012-2014 Digia Plc and/or its subsidiary(-ies).
* Copyright (c) 2008-2012 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* This file is part of CopperSpice.
*
* CopperSpice is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* version 2.1 as published by the Free Software Foundation.
*
* CopperSpice is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with CopperSpice. If not, see
* <http://www.gnu.org/licenses/>.
*
***********************************************************************/
#ifndef ABSTRACTPROMOTIONINTERFACE_H
#define ABSTRACTPROMOTIONINTERFACE_H
#include <QtDesigner/sdk_global.h>
#include <QtCore/QPair>
#include <QtCore/QList>
#include <QtCore/QSet>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QDesignerWidgetDataBaseItemInterface;
class QDESIGNER_SDK_EXPORT QDesignerPromotionInterface
{
public:
virtual ~QDesignerPromotionInterface();
struct PromotedClass {
QDesignerWidgetDataBaseItemInterface *baseItem;
QDesignerWidgetDataBaseItemInterface *promotedItem;
};
typedef QList<PromotedClass> PromotedClasses;
virtual PromotedClasses promotedClasses() const = 0;
virtual QSet<QString> referencedPromotedClassNames() const = 0;
virtual bool addPromotedClass(const QString &baseClass,
const QString &className,
const QString &includeFile,
QString *errorMessage) = 0;
virtual bool removePromotedClass(const QString &className, QString *errorMessage) = 0;
virtual bool changePromotedClassName(const QString &oldClassName, const QString &newClassName, QString *errorMessage) = 0;
virtual bool setPromotedClassIncludeFile(const QString &className, const QString &includeFile, QString *errorMessage) = 0;
virtual QList<QDesignerWidgetDataBaseItemInterface *> promotionBaseClasses() const = 0;
};
QT_END_NAMESPACE
QT_END_HEADER
#endif // ABSTRACTPROMOTIONINTERFACE_H
| [
"ansel@copperspice.com"
] | ansel@copperspice.com |
b83ddf4e2f3871393354a6691dd4cfc699a3a885 | f7a923eba16f91594419d48f6f747d7cbc6230f5 | /src/bioio.h | db22f1cf98b5d0f235f2ba33778b50abf5f1d215 | [] | no_license | abruyneel/AlleleProfileR | 8682982914a11f845adf3af2d491b654d03ae67e | 168737311a453f6e5f3aff4010beea88d53319e4 | refs/heads/master | 2021-03-24T10:14:16.715133 | 2020-06-09T14:13:43 | 2020-06-09T14:13:43 | 110,288,019 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 30,336 | h | /* bioio.hpp -- FASTA/Q I/O
Copyright (C) 2017 University of Oxford.
Author: Daniel Cooke <dcooke@well.ox.ac.uk>
Use of this source code is governed by the MIT license:
Copyright 2017 Daniel Cooke
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 __bioio__bioio__
#define __bioio__bioio__
#include <string>
#include <vector>
#include <unordered_map>
#include <iostream>
#include <fstream>
#include <cstddef>
#include <limits>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <utility>
#include <type_traits>
namespace bioio {
namespace detail {
inline std::vector<std::string> split(const std::string& str, const char delim)
{
std::stringstream ss {str};
std::string item;
std::vector<std::string> result {};
while (std::getline(ss, item, delim)) result.emplace_back(item);
return result;
}
} // namespace detail
/*=======================================================================================
Types
=======================================================================================*/
struct FastaContigIndex
{
std::string contig_name;
std::size_t length;
std::size_t offset;
std::size_t line_length;
std::size_t line_byte_length;
FastaContigIndex() = default;
template <typename T>
explicit FastaContigIndex(T&& contig_name, std::size_t length, std::size_t offset,
std::size_t line_length, std::size_t line_byte_length)
: contig_name {std::forward<T>(contig_name)}
, length {length}
, offset {offset}
, line_length {line_length}
, line_byte_length {line_byte_length}
{}
template <typename T>
explicit FastaContigIndex(const T& fasta_index_line)
{
const auto parts = detail::split(fasta_index_line, '\t');
contig_name = parts[0];
length = std::stoull(parts[1]);
offset = std::stoull(parts[2]);
line_length = std::stoull(parts[3]);
line_byte_length = std::stoull(parts[4]);
}
};
using FastaIndex = std::unordered_map<std::string, FastaContigIndex>;
template <typename StringType = std::string, typename SequenceType = std::string>
struct FastaRecord
{
StringType name;
SequenceType sequence;
FastaRecord() = delete;
template <typename StringType_, typename SequenceType_>
explicit FastaRecord(StringType_&& name, SequenceType_&& sequence)
: name {std::forward<StringType_>(name)}
, sequence {std::forward<SequenceType_>(sequence)}
{}
};
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string>
struct FastqRecord
{
StringType name;
SequenceType1 seq;
SequenceType2 qual;
FastqRecord() = delete;
template <typename StringType_, typename SequenceType1_, typename SequenceType2_>
explicit FastqRecord(StringType_&& name, SequenceType1_&& seq, SequenceType2_&& qual)
:name {std::forward<StringType_>(name)}
, seq {std::forward<SequenceType1_>(seq)}
, qual {std::forward<SequenceType2_>(qual)}
{}
};
template <typename StringType = std::string>
using ReadIds = std::vector<StringType>;
template <typename StringType = std::string, typename SequenceType = std::string>
using FastaMap = std::unordered_map<StringType, SequenceType>;
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string>
using FastqMap = std::unordered_map<StringType, std::pair<SequenceType1, SequenceType2>>;
template <typename StringType = std::string, typename SequenceType = std::string>
using FastaReads = std::pair<ReadIds<StringType>, FastaMap<StringType, SequenceType>>;
template <typename StringType = std::string, typename SequenceType = std::string,
typename SequenceType2 = std::string>
using FastqReads = std::pair<ReadIds<StringType>, FastqMap<StringType, SequenceType, SequenceType2>>;
namespace detail
{
// Counts the occurrences of record_delim that follow a newline '\n'
inline size_t count_records(std::istream& is, const char record_delim)
{
const auto current_position = is.tellg();
size_t result {};
while (is) {
if (is.peek() == record_delim) ++result;
is.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
is.clear();
is.seekg(current_position, std::ios::beg);
return result;
}
static constexpr char fasta_delim {'>'};
static constexpr char fastq_delim {'@'};
template <typename StringType = std::string, typename SequenceType = std::string>
::bioio::FastaRecord<StringType, SequenceType>
read_fasta_record(std::istream& fasta)
{
StringType name;
std::getline(fasta, name); // name is always a single line
SequenceType line;
std::getline(fasta, line);
// The FASTA format is not as simple as FASTQ - the sequence
// may be broken into multiple lines. We assume each line is the same size.
if (!fasta.good() || fasta.peek() == fasta_delim) {
return ::bioio::FastaRecord<StringType, SequenceType> {std::move(name), std::move(line)};
} else {
const auto line_size = line.size();
line.resize(line_size);
SequenceType seq {};
seq.reserve(line_size * 100);
const auto line_begin = line.cbegin(), line_end = line.cend();
seq.insert(seq.end(), line_begin, line_end);
while (fasta.good()) {
fasta.getline(&line[0], line_size + 1);
if (line.front() == fasta_delim) {
if (fasta.good()) fasta.seekg(-fasta.gcount(), std::ios_base::cur);
break;
}
if (fasta.gcount() < line_size) {
seq.insert(seq.end(), line_begin, line_begin + fasta.gcount() - 1);
break;
}
seq.insert(seq.end(), line_begin, line_end);
}
seq.shrink_to_fit();
return ::bioio::FastaRecord<StringType, SequenceType> {std::move(name), std::move(seq)};
}
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string>
::bioio::FastqRecord<StringType, SequenceType1, SequenceType2>
read_fastq_record(std::istream& fastq)
{
StringType name;
SequenceType1 seq;
SequenceType2 quals;
// Unlike FASTA, FASTQ always use one line per field.
std::getline(fastq, name);
std::getline(fastq, seq);
fastq.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::getline(fastq, quals);
return ::bioio::FastqRecord<StringType, SequenceType1, SequenceType2>
{std::move(name), std::move(seq), std::move(quals)};
}
} // namespace detail
/*=======================================================================================
INDEX: For reading FASTA index files
=======================================================================================*/
inline std::size_t count_contigs_in_fasta_index(std::istream& fasta_index)
{
return std::count(std::istreambuf_iterator<char>(fasta_index),
std::istreambuf_iterator<char>(), '\n');
}
inline std::size_t count_contigs_in_fasta_index(const std::string& fasta_index_path)
{
std::ifstream fasta_index {fasta_index_path, std::ios::binary};
return count_contigs_in_fasta_index(fasta_index);
}
inline std::vector<std::string> read_fasta_index_contig_names(std::istream& fasta_index)
{
std::vector<std::string> result {};
result.reserve(100);
std::string line;
while (std::getline(fasta_index, line)) {
result.emplace_back(line.substr(0, line.find('\t')));
}
result.shrink_to_fit();
return result;
}
inline std::vector<std::string> read_fasta_index_contig_names(const std::string& fasta_index_path)
{
std::ifstream fasta_index {fasta_index_path, std::ios::binary};
return read_fasta_index_contig_names(fasta_index);
}
inline FastaIndex read_fasta_index(std::istream& fasta_index)
{
FastaIndex result {};
result.reserve(100);
std::string line;
while (std::getline(fasta_index, line)) {
FastaContigIndex contig_index {line};
result.emplace(contig_index.contig_name, std::move(contig_index));
}
result.rehash(result.size());
return result;
}
inline FastaIndex read_fasta_index(const std::string& fasta_index_path)
{
std::ifstream fasta_index {fasta_index_path, std::ios::binary};
return read_fasta_index(fasta_index);
}
inline std::size_t calculate_contig_size(std::istream& fasta_index, const std::string& contig_name)
{
const auto current_position = fasta_index.tellg();
fasta_index.seekg(0, std::ios::beg);
std::string line;
while (std::getline(fasta_index, line)) {
FastaContigIndex contig_index {line};
if (contig_index.contig_name == contig_name) return contig_index.length;
}
fasta_index.clear();
fasta_index.seekg(current_position, std::ios::beg);
return 0;
}
inline size_t calculate_contig_size(const std::string& fasta_index_path, const std::string& contig_name)
{
std::ifstream fasta_index {fasta_index_path, std::ios::binary};
return calculate_contig_size(fasta_index, contig_name);
}
/*=======================================================================================
FASTA: For reading FASTAs with index files
=======================================================================================*/
namespace detail {
inline std::size_t line_offset(const ::bioio::FastaContigIndex& index, const std::size_t begin) noexcept
{
return begin % index.line_length;
}
inline std::size_t region_offset(const ::bioio::FastaContigIndex& index, const std::size_t begin) noexcept
{
return index.offset + begin / index.line_length * index.line_byte_length + line_offset(index, begin);
}
inline std::size_t remaining_line_length(const ::bioio::FastaContigIndex& index, const std::size_t begin) noexcept
{
return index.line_length - line_offset(index, begin);
}
} // namespace detail
template <typename SequenceType = std::string>
SequenceType
read_fasta_contig(std::istream& fasta, const FastaContigIndex& index,
const std::size_t begin, std::size_t length)
{
SequenceType result {};
if (length == 0 || begin >= index.length) {
return result;
}
fasta.seekg(detail::region_offset(index, begin), std::ios::beg);
length = std::min(length, index.length - begin);
if (index.line_length == index.line_byte_length) {
result.resize(length);
fasta.read(&result[0], length);
} else {
const auto num_line_end_bytes = index.line_byte_length - index.line_length;
const auto num_remaining_curr_line_bytes = detail::remaining_line_length(index, begin);
if (length <= num_remaining_curr_line_bytes) {
result.resize(length);
fasta.read(&result[0], length);
} else {
// Allocate enough space to fit a full last line so we don't need to keep
// checking how much of the final line to read.
result.resize(length + detail::remaining_line_length(index, begin + length) + num_line_end_bytes);
fasta.read(&result[0], num_remaining_curr_line_bytes + num_line_end_bytes);
for (auto pos = num_remaining_curr_line_bytes; pos < length; pos += index.line_length) {
fasta.read(&result[pos], index.line_byte_length);
}
result.resize(length);
}
}
fasta.clear(); // assumes indexed queries do not need eof flag
return result;
}
template <typename SequenceType = std::string>
SequenceType
read_fasta_contig(const std::string& fasta_path, const FastaContigIndex& index,
const std::size_t begin, const std::size_t length)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_contig<SequenceType>(fasta, index, begin, length);
}
template <typename SequenceType = std::string>
SequenceType read_fasta_contig(std::istream& fasta, const FastaContigIndex& index)
{
return read_fasta_contig<SequenceType>(fasta, index, 0, index.length);
}
template <typename SequenceType = std::string>
SequenceType read_fasta_contig(const std::string& fasta_path, const FastaContigIndex& index)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_contig<SequenceType>(fasta, index);
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& os, const FastaRecord<T, U>& data)
{
os << ">" << data.first << "\n" << data.second;
return os;
}
/*=======================================================================================
FASTA: Optimised for reading a Fasta file with a single contig without an index
=======================================================================================*/
template <typename StringType = std::string, typename SequenceType = std::string>
FastaRecord<StringType, SequenceType> read_single_contig_fasta(const std::string& fasta_path)
{
std::ifstream fasta {fasta_path, std::ios::binary | std::ios::ate};
const auto file_length = static_cast<size_t>(fasta.tellg());
fasta.seekg(0, std::ios::beg);
StringType name;
std::getline(fasta, name);
SequenceType sequence;
sequence.resize(file_length - name.size() - 1);
fasta.read(&sequence[0], sequence.size());
sequence.erase(std::remove(sequence.begin(), sequence.end(), '\n'), sequence.end());
return FastaRecord<StringType, SequenceType> {std::move(name), std::move(sequence)};
}
/*=======================================================================================
FASTA: For reading multiple record Fasta files without an index
=======================================================================================*/
inline std::size_t count_fasta_records(std::istream& fasta)
{
return detail::count_records(fasta, detail::fasta_delim);
}
inline std::size_t count_fasta_records(const std::string& fasta_path)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return count_fasta_records(fasta);
}
template <typename UnaryPredicate,
typename = typename std::enable_if<
!std::is_convertible<UnaryPredicate, std::string>::value
>::type>
bool seek_fasta_record(std::istream& fasta, UnaryPredicate pred)
{
std::string record;
while (std::getline(fasta, record)) {
if (pred(record)) {
fasta.seekg(-(record.size() + 1), std::ios_base::cur);
return true;
}
while (fasta) {
if (fasta.peek() == detail::fasta_delim) break;
fasta.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
}
return false;
}
inline bool seek_fasta_record(std::istream& fasta, const std::string& name)
{
return seek_fasta_record(fasta,
[&] (const std::string& fasta_record) {
if (fasta_record.size() < name.size()) return false;
return std::equal(name.cbegin(), name.cend(),
std::next(fasta_record.cbegin()));
});
}
template <typename SequenceType = std::string, typename UnaryPredicate>
SequenceType read_fasta_seq(std::istream& fasta, UnaryPredicate pred)
{
if (seek_fasta_record(fasta, pred)) {
return detail::read_fasta_record<std::string, SequenceType>(fasta).sequence;
}
return SequenceType {};
}
template <typename SequenceType = std::string, typename UnaryPredicate>
SequenceType read_fasta_seq(const std::string& fasta_path, UnaryPredicate pred)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_seq(fasta, pred);
}
template <typename SequenceType = std::string>
SequenceType read_fasta_seq(std::istream& fasta, const std::string& name)
{
if (seek_fasta_record(fasta, name)) {
return detail::read_fasta_record<std::string, SequenceType>(fasta).sequence;
}
return SequenceType {};
}
template <typename SequenceType = std::string>
SequenceType read_fasta_seq(const std::string& fasta_path, const std::string& name)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_seq(fasta, name);
}
template <typename Container = std::vector<std::string>>
Container read_fasta_seqs(std::istream& fasta, size_t num_records)
{
Container result {};
result.reserve(num_records);
using SequenceType = typename Container::value_type;
for (; num_records > 0; --num_records) {
result.emplace_back(detail::read_fasta_record<std::string, SequenceType>(fasta).sequence);
}
return result;
}
template <typename Container = std::vector<std::string>>
Container read_fasta_seqs(std::istream& fasta)
{
return read_fasta_seqs<Container>(fasta, count_fasta_records(fasta));
}
template <typename Container = std::vector<std::string>>
Container read_fasta_seqs(const std::string& fasta_path)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_seqs<Container>(fasta);
}
template <typename Container = std::vector<std::string>>
Container read_fasta_seqs(const std::string& fasta_path, const std::size_t num_records)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_seqs<Container>(fasta, num_records);
}
template <typename StringType = std::string, typename SequenceType = std::string>
std::vector<FastaRecord<StringType, SequenceType>> read_fasta(std::istream& fasta,
std::size_t num_records)
{
std::vector<FastaRecord<StringType, SequenceType>> result {};
result.reserve(num_records);
for (; num_records > 0; --num_records) {
result.emplace_back(detail::read_fasta_record<StringType, SequenceType>(fasta));
}
return result;
}
template <typename StringType = std::string, typename SequenceType = std::string>
std::vector<FastaRecord<StringType, SequenceType>> read_fasta(std::istream& fasta)
{
return read_fasta<StringType, SequenceType>(fasta, count_fasta_records(fasta));
}
template <typename StringType = std::string, typename SequenceType = std::string>
std::vector<FastaRecord<StringType, SequenceType>> read_fasta(const std::string& fasta_path)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta<StringType, SequenceType>(fasta);
}
template <typename StringType = std::string, typename SequenceType = std::string>
std::vector<FastaRecord<StringType, SequenceType>> read_fasta(const std::string& fasta_path,
const std::size_t num_records)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta<StringType, SequenceType>(fasta, num_records);
}
template <typename StringType = std::string, typename SequenceType = std::string,
typename UnaryOperation>
FastaReads<StringType, SequenceType> read_fasta_map(std::istream& fasta,
std::size_t num_records,
UnaryOperation unary_op)
{
FastaMap<StringType, SequenceType> records {};
records.reserve(num_records);
ReadIds<StringType> contig_names {};
contig_names.reserve(num_records);
for (; num_records > 0; --num_records) {
auto record = detail::read_fasta_record<StringType, SequenceType>(fasta);
auto f_name = unary_op(std::move(record.name));
records.emplace(f_name, std::move(record.sequence));
contig_names.insert(std::move(f_name));
}
return FastaReads<StringType, SequenceType> {std::move(contig_names), std::move(records)};
}
template <typename StringType = std::string, typename SequenceType = std::string,
typename UnaryOperation>
FastaReads<StringType, SequenceType> read_fasta_map(std::istream& fasta,
UnaryOperation unary_op)
{
return read_fasta_map<StringType, SequenceType, UnaryOperation>(fasta,
count_fasta_records(fasta),
unary_op);
}
template <typename StringType = std::string, typename SequenceType = std::string,
typename UnaryOperation>
FastaReads<StringType, SequenceType> read_fasta_map(const std::string& fasta_path,
UnaryOperation unary_op)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_map<StringType, SequenceType, UnaryOperation>(fasta, unary_op);
}
template <typename StringType = std::string, typename SequenceType = std::string,
typename UnaryOperation>
FastaReads<StringType, SequenceType> read_fasta_map(const std::string& fasta_path,
size_t num_records,
UnaryOperation unary_op)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_map<StringType, SequenceType, UnaryOperation>(fasta, num_records, unary_op);
}
template <typename StringType = std::string, typename SequenceType = std::string>
FastaReads<StringType, SequenceType> read_fasta_map(const std::string& fasta_path)
{
return read_fasta_map<StringType, SequenceType>(fasta_path,
[] (StringType&& name) {
return name;
});
}
template <typename StringType = std::string, typename SequenceType = std::string,
typename UnaryOperation>
FastaReads<StringType, SequenceType>
read_fasta_map(std::istream& fasta, const ReadIds<StringType>& names,
UnaryOperation unary_op)
{
auto num_records = names.size();
FastaMap<StringType, SequenceType> records {};
records.reserve(num_records);
ReadIds<StringType> f_names {};
f_names.reserve(num_records);
for (; num_records > 0; --num_records) {
auto record = detail::read_fasta_record<StringType, SequenceType>(fasta);
auto f_name = unary_op(std::move(record.name));
if (names.find(f_name) != names.end()) {
records.emplace(f_name, std::move(record.sequence));
f_names.insert(std::move(f_name));
}
}
return FastaReads<StringType, SequenceType> {std::move(f_names), std::move(records)};
}
template <typename StringType = std::string, typename SequenceType = std::string,
typename UnaryOperation>
FastaReads<StringType, SequenceType>
read_fasta_map(const std::string& fasta_path, const ReadIds<StringType>& names,
UnaryOperation unary_op)
{
std::ifstream fasta {fasta_path, std::ios::binary};
return read_fasta_map<StringType, SequenceType, UnaryOperation>(fasta, names, unary_op);
}
template <typename StringType = std::string, typename SequenceType = std::string>
FastaReads<StringType, SequenceType>
read_fasta_map(const std::string& path, const ReadIds<StringType>& names)
{
return read_fasta_map(path, names,
[] (StringType&& name) { return name; });
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& os, const FastaReads<T, U>& records)
{
for (auto name : records.first) {
os << ">" << name << "\n" << records.second.at(name);
}
return os;
}
template <typename T, typename U>
void write_fasta(const std::string& path, const FastaReads<T, U>& records)
{
std::ofstream fasta {path, std::ios::out | std::ios::binary};
fasta << records;
}
/*=======================================================================================
FASTQ: For reading multiple line Fastq files.
=======================================================================================*/
inline std::size_t count_fastq_records(std::istream& fastq)
{
return detail::count_records(fastq, detail::fastq_delim);
}
inline std::size_t count_fastq_records(const std::string& fastq_path)
{
std::ifstream fastq {fastq_path, std::ios::binary};
return count_fasta_records(fastq);
}
template <typename SequenceType = std::string>
std::vector<SequenceType>
read_fastq_seqs(std::istream& fastq)
{
auto num_records = count_fastq_records(fastq);
std::vector<SequenceType> result {};
result.reserve(num_records);
for (; num_records > 0; --num_records) {
result.push_back(detail::read_fastq_record<std::string, SequenceType, std::string>(fastq).seq);
}
return result;
}
template <typename SequenceType = std::string>
std::vector<SequenceType>
read_fastq_seqs(const std::string& path)
{
std::ifstream fastq {path, std::ios::binary};
return read_fastq_seqs(fastq);
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string, typename F>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(std::istream& fastq, std::size_t num_records, F f)
{
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>> result {};
result.reserve(num_records);
for (; num_records > 0; --num_records) {
auto record = detail::read_fastq_record<StringType, SequenceType1, SequenceType2>(fastq);
result.emplace_back(f(std::move(record.name)), std::move(record.seq), std::move(record.qual));
}
return result;
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string, typename F>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(std::istream& fastq, F f)
{
return read_fastq<StringType, SequenceType1, SequenceType2, F>(fastq, count_fastq_records(fastq), f);
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string, typename F>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(const std::string& path, const std::size_t num_records, F f)
{
std::ifstream fastq {path, std::ios::binary};
return read_fastq<StringType, SequenceType1, SequenceType2, F>(fastq, num_records, f);
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string, typename F>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(const std::string& path, F f)
{
std::ifstream fastq {path, std::ios::binary};
return read_fastq<StringType, SequenceType1, SequenceType2, F>(fastq, f);
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(const std::string& path)
{
return read_fastq<StringType, SequenceType1, SequenceType2>(path, [] (const StringType& name) { return name; });
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(std::istream& fastq)
{
return read_fastq<StringType, SequenceType1, SequenceType2>(fastq, [] (const StringType& name) { return name; });
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(std::istream& fastq, const std::size_t num_records)
{
return read_fastq<StringType, SequenceType1, SequenceType2>(fastq, num_records, [] (const StringType& name) {
return name;
});
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string, typename IntegerType>
std::vector<FastqRecord<StringType, SequenceType1, SequenceType2>>
read_fastq(const std::string& path, const std::size_t num_records)
{
std::ifstream fastq {path, std::ios::binary};
return read_fastq<StringType, SequenceType1, SequenceType2>(fastq, num_records, [] (const StringType& name) {
return name;
});
}
template <typename StringType = std::string, typename SequenceType1 = std::string,
typename SequenceType2 = std::string>
FastqReads<StringType, SequenceType1, SequenceType2>
read_fastq_map(const std::string& path)
{
std::ifstream fastq {path, std::ios::binary};
auto num_records = count_fastq_records(fastq);
ReadIds<StringType> names {};
FastqMap<StringType, SequenceType1, SequenceType2> data {};
data.reserve(num_records);
for (; num_records > 0; --num_records) {
auto record = detail::read_fastq_record<StringType, SequenceType1, SequenceType2>(fastq);
data.emplace(record.name, {std::move(record.seq), std::move(record.qual)});
names.insert(std::move(record.name));
}
return {names, data};
}
} // namespace bioio
#endif
| [
"arne.bruyneel@gmail.com"
] | arne.bruyneel@gmail.com |
c673f82892cbef82250be5fcd1c1212d50a72712 | 1b22a1152258911bfe569afae9922be643bbeea5 | /sqlist.cpp | 252592dbff5804d3c7a6dcd81c36250378d04d1b | [] | no_license | Ambition111/- | c14bb5a439fa5028e4abe9f0d7c629c001f429e5 | 4a0e0c958a78a7d0903e1b2190ddbf3edd0c11d1 | refs/heads/master | 2023-04-16T11:01:38.044545 | 2021-04-15T16:00:00 | 2021-04-15T16:00:00 | 304,906,672 | 3 | 1 | null | null | null | null | GB18030 | C++ | false | false | 3,018 | cpp | #include "sqlist.h"
#include <malloc.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
//ๅจC่ฏญ่จไธญ ๅฎไนไธไธชstatic็ๅฝๆฐๆถ๏ผ ๆฌกๅฝๆฐๅช่ฝ่ขซๅฝๅๆไปถไธญ็ๅ
ถไปๅฝๆฐ่ฐ็จ
static int AppendSpace(SqList* sq)
{
ElemType* s = (ElemType*)malloc(sizeof(ElemType) * sq->size * 2);
if (s == NULL) return-1;
//ๅฐๅๆฅ็ฉบ้ด็ๆฐๆฎๅ
จ้จๅฏผๅ
ฅๅฐๆฐ็็ฉบ้ดไธญ
for (int i = 0; i < sq->size; i++)
{
s[i] = sq->data[i];
}
//ๅฐๅๆฅ็ฉบ้ด้ๆพ๏ผ็ถๅ่ฎฉsq->dataๆๅๆฐ็็ฉบ้ดs
free(s);
sq->data = s;
sq->size *= 2;
}
void InitSqlist(SqList* sq)
{
if (sq == NULL)
{
exit(0); //็ดๆฅ็ปๆ็จๅบ
}
sq->data = (ElemType*)malloc(sizeof(ElemType) * INTSIZE);
if (sq->data == NULL)
{
exit(0);
}
sq->length = 0;
sq->size = INTSIZE;
}
void InsertSqlistPos(SqList* sq, ElemType val, int pos)
{
if (sq == NULL) exit(0);
if (pos < 0 || pos > sq->length)
{
printf("Insert :: Pos is error\n");
return;
}
if (sq->length == sq->size)
{
if (-1 == AppendSpace(sq))
{
printf("Insert :: AppendSpace fail\n");
return;
}
}
int i = sq->length;
while (i > pos)
{
sq->data[i] = sq->data[i - 1];
i--;
}
sq->data[pos] = val;
sq->length++;
}
//ๅคดๆ
void SqListInsertHead(SqList* sq, ElemType val)
{
InsertSqlistPos(sq, val, 0);
}
//ๅฐพๆ
void SqListInsertTail(SqList* sq, ElemType val)
{
assert(sq != NULL);
InsertSqlistPos(sq, val, sq->length);
}
//ๅ ้ค
void FixSqListDeletePos(SqList* sq, int pos)
{
assert(sq != NULL);
if (sq->length == 0)
{
printf("Sqlist is Empty\n");
return;
}
if (pos < 0 || pos >= sq->length)
{
printf("Delete Pos is error\n");
return;
}
for (int i = pos; i < sq->length - 1; i++)
{
sq->data[i] = sq->data[i + 1];
}
sq->length--;
}
void FixSqListDeleteHead(SqList* sq) //ๅคดๅ
{
FixSqListDeletePos(sq, 0);
}
void FixSqListDeleteTail(SqList* sq) //ๅฐพๅ
{
if (sq == NULL) exit(0);
//้กบๅบ่กจๅทฒ็ปๆฏ็ฉบ็ไบ
if (sq->length == 0) return;
sq->length--;
}
void FixSqListDeleteVal1(SqList* sq, ElemType val)//ๆ้ๅคๅผๅ ้คO(n*2)
{
if (sq == NULL) exit(0);
for (int i = 0; i < sq->length;)
{
if (val == sq->data[i])
FixSqListDeletePos(sq, i);
else
i++;
}
}
void FixSqListDeleteVal22(SqList* sq, ElemType val)//ๆ้ๅคๅผๅ ้คO(n)
{
if (sq == NULL) exit(0);
int count = 0;
int i = 0;
while (i + count <= sq->length)
{
if (sq->data[i] == val)
count++;
else
i++;
sq->data[i] = sq->data[i + count];
}
sq->length -= count;
}
int FindValLast(SqList* sq, ElemType val)
{
if (sq == NULL) exit(0);
int index = -1;
for (int i = 0; i < sq->length; i++)
{
if (sq->data[i] == val)
{
index = i;
}
}
return index;
}
//ๆพ็คบ
void SqListShow(SqList* sq)
{
//assert(sq != NULL);
if (sq == NULL) exit(0);
for (int i = 0; i < sq->length; i++)
{
printf("%d ", sq->data[i]);
}
printf("\n");
}
void DestroyFixSqList(SqList* sq)
{
if (sq == NULL) exit(0);
free(sq->data);
sq->data = NULL;
sq->length = 0;
} | [
"2460819991@qq.com"
] | 2460819991@qq.com |
781efc3c12d79af6ef7e43a5a2f7945e552a0473 | 774d2c34f4a098edbd4f3c7bf34bb69c6deeeb7d | /code/leixiaohua1020/VideoEye/Audiodecode.h | 4412480fc126bed374e95e401f0ead4483014e88 | [] | no_license | z350z/ZDoc | 54dcbcef7c71ef24d31bb38fc1de02e070086d2e | 4f615a813c9176999c2c6c7ebed3b1fbcaa01b64 | refs/heads/master | 2021-01-19T14:06:39.798599 | 2017-04-07T04:56:38 | 2017-04-07T04:56:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 848 | h | ๏ปฟ/*
*
*
* VideoEye
*
* ้ท้้ช
Lei Xiaohua
* leixiaohua1020@126.com
* ไธญๅฝไผ ๅชๅคงๅญฆ/ๆฐๅญ็ต่งๆๆฏ
* Communication University of China / Digital TV Technology
* http://blog.csdn.net/leixiaohua1020
*
*/
#pragma once
#include "resource.h"
#include "stdafx.h"
#include "afxcmn.h"
// Audiodecode ๅฏน่ฏๆก
class Audiodecode : public CDialogEx
{
DECLARE_DYNAMIC(Audiodecode)
public:
Audiodecode(CWnd* pParent = NULL); // ๆ ๅๆ้ ๅฝๆฐ
virtual ~Audiodecode();
// ๅฏน่ฏๆกๆฐๆฎ
enum { IDD = IDD_AUDIODECODE };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ๆฏๆ
//่ชๅทฑๆทปๅ ็๏ผๅๅงๅTeechart
virtual BOOL OnInitDialog();
DECLARE_MESSAGE_MAP()
public:
void SystemClear();
CListCtrl m_decodeframe_a;
afx_msg void OnBnClickedCancel();
};
| [
"126.org@gmail.com"
] | 126.org@gmail.com |
6a2b6403b25f2327fbd3facdb7b197fa77645c01 | 5ee0eb940cfad30f7a3b41762eb4abd9cd052f38 | /play/case0/150/alphat | 02cb7e285b07d1e3ffb3584384cf0f5f484d9264 | [] | no_license | mamitsu2/aircond5_play4 | 052d2ff593661912b53379e74af1f7cee20bf24d | c5800df67e4eba5415c0e877bdeff06154d51ba6 | refs/heads/master | 2020-05-25T02:11:13.406899 | 2019-05-20T04:56:10 | 2019-05-20T04:56:10 | 187,570,146 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,422 | /*--------------------------------*- 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 "150";
object alphat;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -1 0 0 0 0];
internalField nonuniform List<scalar>
459
(
0.00163188
0.00183698
0.00202315
0.00198448
0.00169201
0.00141882
0.00115674
0.00101521
0.000909606
0.000827686
0.000771996
0.000734871
0.000708298
0.000688854
0.000672284
0.000498618
0.000591698
0.000611325
0.000576983
0.000522251
0.00045827
0.0003859
0.000249399
0.0001996
0.000202708
0.000211298
0.000210043
0.000203033
0.000215705
0.00025292
0.000311461
0.000387893
0.000396
0.000364317
0.00171816
0.0032034
0.00509036
0.00706824
0.00754882
0.00688326
0.00547015
0.00389371
0.00311975
0.00308886
0.00316769
0.00296008
0.00260938
0.00216148
0.00154899
0.00073304
0.000544366
0.000703884
0.00134402
0.0015711
0.00171549
0.00154455
0.00119637
0.000748757
0.000480499
0.000418125
0.00047157
0.000511676
0.000407426
0.000290255
0.000262256
0.000353477
0.000773183
0.0012274
0.00140846
0.000542762
0.00228637
0.00296866
0.00337929
0.00401161
0.00514305
0.00608986
0.00648373
0.00627116
0.00473533
0.00378461
0.00395906
0.00384854
0.00334446
0.00272998
0.00204928
0.00139386
0.000819227
0.000973258
0.00273055
0.00251748
0.00214429
0.00172962
0.00134594
0.000459028
0.000364542
0.000323676
0.000300964
0.000283771
0.000266704
0.000247525
0.000269536
0.000553214
0.00130749
0.00172812
0.00159569
0.000604705
0.00378518
0.00428137
0.00420629
0.00410755
0.00439142
0.00511013
0.00593005
0.00650044
0.00614351
0.00482691
0.00468956
0.00488215
0.00440501
0.00367276
0.00282833
0.00199842
0.00137569
0.00109585
0.00263387
0.00284624
0.00263136
0.00223984
0.00179342
0.0013174
0.000926489
0.000946006
0.000974208
0.00100743
0.00104394
0.00108367
0.00111791
0.0011288
0.00111139
0.00145231
0.00193177
0.0025962
0.00102381
0.00410923
0.00513879
0.00484602
0.00446048
0.00440392
0.00485291
0.00565916
0.00648089
0.00668018
0.00577375
0.00550716
0.00612559
0.00616177
0.00590905
0.00559254
0.00523822
0.00490593
0.00468734
0.00473035
0.00462122
0.0044753
0.00434278
0.00425063
0.00418972
0.00417702
0.00427191
0.00439408
0.00452293
0.00463452
0.00470528
0.00471595
0.00463968
0.00450454
0.00432594
0.00388568
0.00350069
0.0028738
0.00126531
0.00112471
0.00119429
0.00434949
0.00570377
0.00512326
0.00448282
0.00434882
0.00473221
0.00554689
0.00648141
0.00688665
0.00624441
0.00606177
0.00684629
0.00716401
0.00716478
0.00711161
0.00700887
0.00683193
0.0065916
0.00632041
0.00603097
0.00578846
0.00562547
0.00552809
0.00547044
0.00544021
0.00544054
0.00546404
0.00549178
0.00549491
0.00544746
0.0053449
0.0052167
0.00511817
0.00510549
0.00512723
0.00499362
0.00464449
0.00384259
0.00293902
0.0013856
0.00459905
0.005649
0.00442107
0.00424121
0.00429943
0.00472733
0.00556229
0.00651962
0.00693133
0.00643293
0.00626164
0.00706809
0.00749994
0.00760234
0.00764648
0.00763318
0.00752692
0.00732197
0.00704781
0.00675445
0.00649552
0.00629932
0.00615801
0.00604777
0.00595344
0.00588008
0.00583286
0.00579634
0.00573348
0.00560307
0.00539559
0.00516909
0.0050422
0.00512987
0.00543863
0.00574926
0.0056102
0.00483695
0.00402362
0.00160713
0.00492416
0.00548895
0.00450099
0.00403632
0.00453498
0.00499297
0.00571444
0.00654754
0.00690243
0.00651271
0.0062951
0.00691155
0.00737376
0.00752232
0.00760597
0.00763077
0.00757032
0.0074153
0.00718633
0.00692698
0.00668605
0.00649608
0.00636205
0.00626924
0.00620034
0.00615183
0.00612755
0.00611779
0.00607889
0.00593432
0.00561334
0.00511595
0.00453724
0.00400087
0.00357746
0.00320776
0.00285562
0.00256142
0.00232467
0.0016542
0.00545275
0.00635195
0.00800029
0.00425444
0.00491748
0.00568444
0.00611679
0.00670862
0.00696779
0.00659884
0.00621195
0.00641862
0.00682448
0.00701449
0.00709686
0.00711416
0.00706731
0.00695105
0.0067736
0.00656148
0.00635152
0.0061778
0.00606262
0.00601671
0.00604076
0.00612402
0.00624829
0.00639748
0.00655159
0.00666154
0.00664694
0.00644887
0.00607828
0.00554987
0.00491487
0.00431628
0.00383805
0.00352666
0.00334712
0.00183102
0.0126813
0.00649295
0.00482484
0.00660476
0.00680708
0.00711422
0.00721018
0.00672091
0.00624175
0.00608449
0.00612819
0.00615189
0.00612931
0.006075
0.00599529
0.00588853
0.00575417
0.00559981
0.00544183
0.00530153
0.00520113
0.0051635
0.00521347
0.00537159
0.00564123
0.00600105
0.00641949
0.00686611
0.00728564
0.00755669
0.00757994
0.00742881
0.00719214
0.00695425
0.00665031
0.00626083
0.00577029
0.00184883
0.00523276
0.00380879
0.0063217
0.00674824
0.00686988
0.00700093
0.00675792
0.00613795
0.00559065
0.00522577
0.00499823
0.00479439
0.00460441
0.0044384
0.00429455
0.00416656
0.00404818
0.00393592
0.00383065
0.00373773
0.00366664
0.00363096
0.00364936
0.00374564
0.0039448
0.0042635
0.00470342
0.00525372
0.00587768
0.00642774
0.00676291
0.00690725
0.00690778
0.00679985
0.00655746
0.00590851
0.00504874
0.00171805
0.00252546
0.00301661
0.00358241
0.00188937
0.00192573
0.0020926
0.00214593
0.00212374
0.00200247
0.00186829
0.00174912
0.00164657
0.00155679
0.00147914
0.00141083
0.00134913
0.00129231
0.00123929
0.00118943
0.00114238
0.00109806
0.0010566
0.00101832
0.000983823
0.00095403
0.000930396
0.000915173
0.000911711
0.000924747
0.000960131
0.00102223
0.00112052
0.00125522
0.00140127
0.00152863
0.00161132
0.00162184
0.00157476
0.00152976
0.00141009
)
;
boundaryField
{
floor
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar>
29
(
9.5074e-05
6.89826e-05
8.30871e-05
8.60232e-05
8.08797e-05
7.26015e-05
6.27786e-05
5.14611e-05
2.92831e-05
2.07811e-05
2.13131e-05
2.27878e-05
2.25734e-05
2.13675e-05
2.35425e-05
2.98298e-05
3.94776e-05
5.17259e-05
5.3014e-05
4.80002e-05
4.79995e-05
7.56876e-05
8.50171e-05
0.000145567
9.50729e-05
6.89818e-05
9.9729e-05
0.000138476
0.000155682
)
;
}
ceiling
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar>
43
(
0.000344832
0.00040662
0.000476519
0.000262819
0.000267591
0.000289318
0.000296224
0.000293351
0.000277599
0.000260046
0.00024434
0.000230732
0.000218742
0.000208309
0.000199079
0.000190699
0.000182943
0.000175672
0.000168801
0.000162289
0.000156127
0.000150338
0.000144971
0.000140115
0.000135905
0.000132556
0.000130393
0.000129903
0.000131759
0.00013678
0.00014554
0.000159275
0.000177882
0.000197804
0.000214988
0.000226061
0.000227468
0.000221172
0.00021513
0.000198989
0.000700652
0.000805455
0.000674669
)
;
}
sWall
{
type compressible::alphatWallFunction;
Prt 0.85;
value uniform 0.00034373;
}
nWall
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar> 6(0.000169081 0.000195226 0.000225055 0.00025707 0.000239837 0.00019863);
}
sideWalls
{
type empty;
}
glass1
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar> 9(0.000223522 0.00023505 0.000308349 0.000494288 0.000533261 0.000561944 0.000591572 0.000629959 0.00069193);
}
glass2
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar> 2(0.000229673 0.000253051);
}
sun
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar>
14
(
0.000228655
0.000255788
0.000280135
0.00027512
0.00023664
0.000200025
0.000164154
0.000144403
0.000129462
0.00011773
0.000109675
0.000104266
0.000100374
9.75159e-05
)
;
}
heatsource1
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar> 3(0.000179242 0.000159844 0.000169492);
}
heatsource2
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar> 4(0.000104153 7.60992e-05 7.60983e-05 0.000116665);
}
Table_master
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar> 9(6.30407e-05 4.81951e-05 4.16244e-05 3.79263e-05 3.51021e-05 3.22756e-05 2.90694e-05 3.27376e-05 7.74282e-05);
}
Table_slave
{
type compressible::alphatWallFunction;
Prt 0.85;
value nonuniform List<scalar> 9(0.000132033 0.000134805 0.000138797 0.000143483 0.000148611 0.000154167 0.000158933 0.000160443 0.000158019);
}
inlet
{
type fixedValue;
value uniform 1.94e-05;
}
outlet
{
type zeroGradient;
}
}
// ************************************************************************* //
| [
"mitsuaki.makino@tryeting.jp"
] | mitsuaki.makino@tryeting.jp | |
b21396021d0351d4089bd06bc74594e7cdecc9cf | 5740ea2c2d9d5fb5626ff5ad651f3789048ae86b | /PlasmaLibraries/Dash/Replicator.cpp | 814ed2f49ad6ac8e7f6f294043f78d80a8908e8a | [
"MIT"
] | permissive | donovan680/Plasma | 4945b92b7c6e642a557f12e05c7d53819186de55 | 51d40ef0669b7a3015f95e3c84c6d639d5469b62 | refs/heads/master | 2022-04-15T02:42:26.469268 | 2020-02-26T22:32:12 | 2020-02-26T22:32:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 53,821 | cpp | ///////////////////////////////////////////////////////////////////////////////
///
/// Authors: Andrew Colean
/// Copyright 2015, DigiPen Institute of Technology
///
///////////////////////////////////////////////////////////////////////////////
#include "Precompiled.hpp"
namespace Plasma
{
//---------------------------------------------------------------------------------//
// Replicator //
//---------------------------------------------------------------------------------//
void Replicator::ResetSession()
{
mRole = Role::Unspecified;
mReplicatorId = 0;
mReplicatorIdStore.Reset();
mReplicaIdStore.Reset();
mEmplaceIdStores.Clear();
mReplicaSet.Clear();
mCreateMap.Clear();
mReplicaMap.Clear();
mEmplaceMap.Clear();
mCreateContextCacher.Reset();
mReplicaTypeCacher.Reset();
mEmplaceContextCacher.Reset();
// mUserData = nullptr;
// mFrameFillWarning = 0;
// mFrameFillSkip = 0;
// mReplicaChannelTypes.Clear();
// mReplicaPropertyTypes.Clear();
}
Replicator::Replicator(Role::Enum role)
: PeerPlugin(),
mCreateContextCacher(this, ReplicatorMessageType::CreateContextItems),
mReplicaTypeCacher(this, ReplicatorMessageType::ReplicaTypeItems),
mEmplaceContextCacher(this, ReplicatorMessageType::EmplaceContextItems)
{
ResetSession();
ResetConfig();
SetRole(role);
}
//
// Operations
//
void Replicator::SetRole(Role::Enum role)
{
// Already initialized?
if(IsInitialized())
{
Assert(false);
return;
}
mRole = role;
}
Role::Enum Replicator::GetRole() const
{
return mRole;
}
ReplicatorId Replicator::GetReplicatorId() const
{
return mReplicatorId;
}
bool Replicator::HasLink(const IpAddress& ipAddress) const
{
return GetLink(ipAddress) ? true : false;
}
bool Replicator::HasLink(ReplicatorId replicatorId) const
{
return GetLink(replicatorId) ? true : false;
}
bool Replicator::HasLinks(const Route& route) const
{
return !GetLinks(route).Empty();
}
bool Replicator::HasLinks() const
{
return !GetLinks().Empty();
}
PeerLink* Replicator::GetLink(const IpAddress& ipAddress) const
{
// Get link with the specified IP address
PeerLink* link = GetPeer()->GetLink(ipAddress);
// Is a connected replicator link?
if(link && link->GetStatus() == LinkStatus::Connected && link->GetPlugin<ReplicatorLink>("ReplicatorLink"))
return link; // Success
// Failure
return nullptr;
}
PeerLink* Replicator::GetLink(ReplicatorId replicatorId) const
{
// For all links
PeerLinkSet links = GetPeer()->GetLinks();
forRange(PeerLink* link, links.All())
{
// Not connected?
if(link->GetStatus() != LinkStatus::Connected)
continue; // Skip
// Is a replicator link and has the specified replicator ID?
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
if(replicatorLink && replicatorLink->GetReplicatorId() == replicatorId)
return link; // Success
}
// Failure
return nullptr;
}
PeerLinkSet Replicator::GetLinks(const Route& route) const
{
// Is route all?
if(&route == &Route::All)
return GetLinks();
// Is route none?
else if(&route == &Route::None)
return PeerLinkSet();
// Otherwise route is custom
PeerLinkSet result;
result.Reserve(GetPeer()->GetLinkCount());
// Add links according to route mode
PeerLinkSet links = GetPeer()->GetLinks();
switch(route.mMode)
{
case RouteMode::Exclude:
// For all links
forRange(PeerLink* link, links.All())
{
// Not connected?
if(link->GetStatus() != LinkStatus::Connected)
continue; // Skip
// Is a replicator link and is not listed as a route target?
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
if(replicatorLink && !route.mTargets.Contains(replicatorLink->GetReplicatorId()))
result.Insert(link); // Link is a part of this route
}
break;
case RouteMode::Include:
// For all links
forRange(PeerLink* link, links.All())
{
// Not connected?
if(link->GetStatus() != LinkStatus::Connected)
continue; // Skip
// Is a replicator link and is listed as a route target?
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
if(replicatorLink && route.mTargets.Contains(replicatorLink->GetReplicatorId()))
result.Insert(link); // Link is a part of this route
}
break;
default:
Assert(false);
break;
}
return result;
}
PeerLinkSet Replicator::GetLinks() const
{
PeerLinkSet result;
result.Reserve(GetPeer()->GetLinkCount());
// For all links
PeerLinkSet links = GetPeer()->GetLinks();
forRange(PeerLink* link, links.All())
{
// Not connected?
if(link->GetStatus() != LinkStatus::Connected)
continue; // Skip
// Is a replicator link?
if(link->GetPlugin<ReplicatorLink>("ReplicatorLink"))
result.Insert(link);
}
return result;
}
void Replicator::Send(Status& status, const Message& message, const Route& route)
{
bool result = false;
// For all replicator links in route
PeerLinkSet links = GetLinks(route);
forRange(PeerLink* link, links.All())
{
// Send user message
Status linkSendStatus;
link->GetPlugin<ReplicatorLink>("ReplicatorLink")->Send(linkSendStatus, message);
if(linkSendStatus.Succeeded())
result = true;
else
status.SetFailed(linkSendStatus.Message);
}
// At least one send succeeded?
if(result)
status.SetSucceeded();
}
void Replicator::SetUserData(void* userData)
{
mUserData = userData;
}
void* Replicator::GetUserData() const
{
return mUserData;
}
//
// Replica Management
//
bool Replicator::HasReplica(ReplicaId replicaId) const
{
// Has replica in set?
return mReplicaSet.Contains(replicaId);
}
bool Replicator::HasReplica(Replica* replica) const
{
// Has replica in set?
return mReplicaSet.Contains(replica);
}
bool Replicator::HasReplicasByCreateContext(const CreateContext& createContext) const
{
// Has replicas in create context set?
CreateMap::const_iterator iter = mCreateMap.FindIterator(createContext);
if(iter != mCreateMap.End()) // Found?
{
Assert(!iter->second.Empty());
return true;
}
return false;
}
bool Replicator::HasReplicasByReplicaType(const ReplicaType& replicaType) const
{
// Has replicas in replica type set?
ReplicaMap::const_iterator iter = mReplicaMap.FindIterator(replicaType);
if(iter != mReplicaMap.End()) // Found?
{
Assert(!iter->second.Empty());
return true;
}
return false;
}
bool Replicator::HasReplicasByEmplaceContext(const EmplaceContext& emplaceContext) const
{
// Has replicas in emplace context set?
EmplaceMap::const_iterator iter = mEmplaceMap.FindIterator(emplaceContext);
if(iter != mEmplaceMap.End()) // Found?
{
Assert(!iter->second.Empty());
return true;
}
return false;
}
bool Replicator::HasReplicaByEmplaceContext(const EmplaceContext& emplaceContext, EmplaceId emplaceId) const
{
return GetReplicaByEmplaceContext(emplaceContext, emplaceId) ? true : false;
}
bool Replicator::HasReplicas() const
{
// Has replicas in set?
return !mReplicaSet.Empty();
}
Replica* Replicator::GetReplica(ReplicaId replicaId) const
{
// Find replica in set
ReplicaSet::const_iterator iter = mReplicaSet.FindIterator(replicaId);
if(iter != mReplicaSet.End()) // Found?
return *iter;
return nullptr;
}
Replica* Replicator::GetReplica(Replica* replica) const
{
// Find replica in set
ReplicaSet::const_iterator iter = mReplicaSet.FindIterator(replica);
if(iter != mReplicaSet.End()) // Found?
return *iter;
return nullptr;
}
ReplicaSet Replicator::GetReplicasByCreateContext(const CreateContext& createContext) const
{
// Find replicas in create context set
CreateMap::const_iterator iter = mCreateMap.FindIterator(createContext);
if(iter != mCreateMap.End()) // Found?
return iter->second;
return ReplicaSet();
}
ReplicaSet Replicator::GetReplicasByReplicaType(const ReplicaType& replicaType) const
{
// Find replicas in replica type set
ReplicaMap::const_iterator iter = mReplicaMap.FindIterator(replicaType);
if(iter != mReplicaMap.End()) // Found?
return iter->second;
return ReplicaSet();
}
ReplicaSet Replicator::GetReplicasByEmplaceContext(const EmplaceContext& emplaceContext) const
{
// Find replicas in emplace context set
EmplaceMap::const_iterator iter = mEmplaceMap.FindIterator(emplaceContext);
if(iter != mEmplaceMap.End()) // Found?
return iter->second;
return ReplicaSet();
}
Replica* Replicator::GetReplicaByEmplaceContext(const EmplaceContext& emplaceContext, EmplaceId emplaceId) const
{
// Find replicas in emplace context set
EmplaceMap::const_iterator iter = mEmplaceMap.FindIterator(emplaceContext);
if(iter != mEmplaceMap.End()) // Found?
{
// Find replica
const ReplicaSet& contextSet = iter->second;
forRange(Replica* replica, contextSet.All())
if(replica->GetEmplaceId() == emplaceId) // Found?
return replica;
}
return nullptr;
}
const ReplicaSet& Replicator::GetReplicas() const
{
return mReplicaSet;
}
size_t Replicator::GetReplicaCountByCreateContext(const CreateContext& createContext) const
{
// Count replicas in create context set
CreateMap::const_iterator iter = mCreateMap.FindIterator(createContext);
if(iter != mCreateMap.End()) // Found?
return iter->second.Size();
return 0;
}
size_t Replicator::GetReplicaCountByReplicaType(const ReplicaType& replicaType) const
{
// Count replicas in replica type set
ReplicaMap::const_iterator iter = mReplicaMap.FindIterator(replicaType);
if(iter != mReplicaMap.End()) // Found?
return iter->second.Size();
return 0;
}
size_t Replicator::GetReplicaCountByEmplaceContext(const EmplaceContext& emplaceContext) const
{
// Count replicas in emplace context set
EmplaceMap::const_iterator iter = mEmplaceMap.FindIterator(emplaceContext);
if(iter != mEmplaceMap.End()) // Found?
return iter->second.Size();
return 0;
}
size_t Replicator::GetReplicaCount() const
{
return mReplicaSet.Size();
}
//
// Replica Commands
//
bool Replicator::EmplaceReplica(Replica* replica, const EmplaceContext& emplaceContext)
{
// Emplace single replica
ReplicaArray replicas(PlasmaInit, replica);
return EmplaceReplicas(replicas, emplaceContext) != 0;
}
bool Replicator::EmplaceReplicas(const ReplicaArray& replicas, const EmplaceContext& emplaceContext)
{
// (All replicas should be invalid)
// (Hitting an assert here usually means an incorrect assumption was made in the calling logic about a replica's state)
AssertReplicas(replicas, replica->IsInvalid(), "");
AssertReplicas(replicas, replica->GetInitializationTimestamp() == cInvalidMessageTimestamp, "");
AssertReplicas(replicas, replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp, "");
// Create timestamp
TimeMs timestamp = GetPeer()->GetLocalTime();
// Handle replica emplace
if(!HandleEmplace(replicas, emplaceContext, timestamp)) // Unable?
return false;
// (All replicas should be valid (if client) or live (if server))
AssertReplicas(replicas, GetRole() == Role::Client ? replica->IsValid() : replica->IsLive(), "");
// Success
return true;
}
bool Replicator::SpawnReplica(Replica* replica, const Route& route)
{
// Spawn single replica
ReplicaArray replicas(PlasmaInit, replica);
return SpawnReplicas(replicas, route) != 0;
}
bool Replicator::SpawnReplicas(const ReplicaArray& replicas, const Route& route)
{
Assert(GetRole() == Role::Server);
// (All replicas should be invalid)
// (Hitting an assert here usually means an incorrect assumption was made in the calling logic about a replica's state)
AssertReplicas(replicas, replica->IsInvalid(), "");
AssertReplicas(replicas, replica->GetInitializationTimestamp() == cInvalidMessageTimestamp, "");
AssertReplicas(replicas, replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp, "");
// Create timestamp
TimeMs timestamp = GetPeer()->GetLocalTime();
// Handle replica spawn
if(!HandleSpawn(replicas, TransmissionDirection::Outgoing, timestamp)) // Unable?
return false;
// Route replica spawn
RouteSpawn(replicas, route, timestamp);
// (All replicas should be live)
AssertReplicas(replicas, replica->IsLive(), "");
// Success
return true;
}
bool Replicator::CloneReplica(Replica* replica, const Route& route)
{
// Clone single replica
ReplicaArray replicas(PlasmaInit, replica);
return CloneReplicas(replicas, route) != 0;
}
bool Replicator::CloneReplicas(const ReplicaArray& replicas, const Route& route)
{
Assert(GetRole() == Role::Server);
// (All replicas should be live)
// (Hitting an assert here usually means an incorrect assumption was made in the calling logic about a replica's state)
AssertReplicas(replicas, replica->IsLive(), "");
AssertReplicas(replicas, replica->GetInitializationTimestamp() != cInvalidMessageTimestamp, "");
AssertReplicas(replicas, replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp, "");
// Get timestamp from replicas original initialization time
TimeMs timestamp = GetInitializationTimestamp(replicas);
// Route replica clone
RouteClone(replicas, route, timestamp);
// Success
return true;
}
bool Replicator::CloneAllReplicas(const Route& route)
{
// Clone all replicas
ReplicaArray replicas = GetReplicas();
return CloneReplicas(replicas, route);
}
bool Replicator::ForgetReplica(Replica* replica, const Route& route)
{
// Forget single replica
ReplicaArray replicas(PlasmaInit, replica);
return ForgetReplicas(replicas, route) != 0;
}
bool Replicator::ForgetReplicas(const ReplicaArray& replicas, const Route& route)
{
// (All replicas should be valid (if client) or live (if server))
// (Hitting an assert here usually means an incorrect assumption was made in the calling logic about a replica's state)
AssertReplicas(replicas, GetRole() == Role::Client ? replica->IsValid() : replica->IsLive(), "");
AssertReplicas(replicas, GetRole() == Role::Client ? true : replica->GetInitializationTimestamp() != cInvalidMessageTimestamp, "");
AssertReplicas(replicas, replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp, "");
// Create timestamp
TimeMs timestamp = GetPeer()->GetLocalTime();
// Is server?
if(GetRole() == Role::Server)
{
// Route replica forget
RouteForget(replicas, route, timestamp);
}
// Handle replica forget
if(!HandleForget(replicas, TransmissionDirection::Outgoing, timestamp)) // Unable?
return false;
// (All replicas should be invalid)
AssertReplicas(replicas, replica->IsInvalid(), "");
// Success
return true;
}
bool Replicator::ForgetAllReplicas(const Route& route)
{
// Forget all replicas
ReplicaArray replicas = GetReplicas();
return ForgetReplicas(replicas, route);
}
bool Replicator::DestroyReplica(Replica* replica, const Route& route)
{
// Destroy single replica
ReplicaArray replicas(PlasmaInit, replica);
return DestroyReplicas(replicas, route) != 0;
}
bool Replicator::DestroyReplicas(const ReplicaArray& replicas, const Route& route)
{
Assert(GetRole() == Role::Server);
// (All replicas should be live)
// (Hitting an assert here usually means an incorrect assumption was made in the calling logic about a replica's state)
AssertReplicas(replicas, replica->IsLive(), "");
AssertReplicas(replicas, replica->GetInitializationTimestamp() != cInvalidMessageTimestamp, "");
AssertReplicas(replicas, replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp, "");
// Create timestamp
TimeMs timestamp = GetPeer()->GetLocalTime();
// Route replica destroy
RouteDestroy(replicas, route, timestamp);
// Handle replica destroy
if(!HandleDestroy(replicas, TransmissionDirection::Outgoing, timestamp)) // Unable?
return false;
// (All replicas should be invalid)
AssertReplicas(replicas, replica->IsInvalid(), "");
// Success
return true;
}
bool Replicator::DestroyAllReplicas(const Route& route)
{
// Destroy all replicas
ReplicaArray replicas = GetReplicas();
return DestroyReplicas(replicas, route);
}
bool Replicator::Interrupt(const Route& route)
{
Assert(GetRole() == Role::Server);
// Route interrupt
return RouteInterrupt(route);
}
//
// Configuration
//
void Replicator::ResetConfig()
{
SetFrameFillWarning();
SetFrameFillSkip();
}
void Replicator::SetFrameFillWarning(float frameFillWarning)
{
mFrameFillWarning = frameFillWarning;
}
float Replicator::GetFrameFillWarning() const
{
return mFrameFillWarning;
}
void Replicator::SetFrameFillSkip(float frameFillSkip)
{
mFrameFillSkip = frameFillSkip;
}
float Replicator::GetFrameFillSkip() const
{
return mFrameFillSkip;
}
//
// Replica Channel Type Management
//
bool Replicator::HasReplicaChannelType(const String& replicaChannelTypeName) const
{
return mReplicaChannelTypes.Contains(replicaChannelTypeName);
}
const ReplicaChannelType* Replicator::GetReplicaChannelType(const String& replicaChannelTypeName) const
{
const ReplicaChannelType* result = mReplicaChannelTypes.FindValue(replicaChannelTypeName, ReplicaChannelTypePtr());
return result;
}
ReplicaChannelType* Replicator::GetReplicaChannelType(const String& replicaChannelTypeName)
{
const ReplicaChannelType* result = mReplicaChannelTypes.FindValue(replicaChannelTypeName, ReplicaChannelTypePtr());
return const_cast<ReplicaChannelType*>(result);
}
const ReplicaChannelTypeSet& Replicator::GetReplicaChannelTypes() const
{
return mReplicaChannelTypes;
}
ReplicaChannelTypeSet& Replicator::GetReplicaChannelTypes()
{
return mReplicaChannelTypes;
}
ReplicaChannelType* Replicator::AddReplicaChannelType(ReplicaChannelTypePtr replicaChannelType)
{
// Add replica channel type
ReplicaChannelTypeSet::pointer_bool_pair result = mReplicaChannelTypes.Insert(replicaChannelType);
if(result.second) // Successful?
{
// Make the replica channel type valid now that it's registered with our replicator
(*result.first)->MakeValid(this);
// Success
return (*result.first);
}
// Failure
return nullptr;
}
bool Replicator::RemoveReplicaChannelType(const String& replicaChannelTypeName)
{
// Remove replica channel type
ReplicaChannelTypeSet::pointer_bool_pair result = mReplicaChannelTypes.EraseValue(replicaChannelTypeName);
return result.second;
}
void Replicator::ClearReplicaChannelTypes()
{
// Remove all replica channel types
mReplicaChannelTypes.Clear();
}
//
// Replica Property Type Management
//
bool Replicator::HasReplicaPropertyType(const String& replicaPropertyTypeName) const
{
return mReplicaPropertyTypes.Contains(replicaPropertyTypeName);
}
const ReplicaPropertyType* Replicator::GetReplicaPropertyType(const String& replicaPropertyTypeName) const
{
const ReplicaPropertyType* result = mReplicaPropertyTypes.FindValue(replicaPropertyTypeName, ReplicaPropertyTypePtr());
return result;
}
ReplicaPropertyType* Replicator::GetReplicaPropertyType(const String& replicaPropertyTypeName)
{
const ReplicaPropertyType* result = mReplicaPropertyTypes.FindValue(replicaPropertyTypeName, ReplicaPropertyTypePtr());
return const_cast<ReplicaPropertyType*>(result);
}
const ReplicaPropertyTypeSet& Replicator::GetReplicaPropertyTypes() const
{
return mReplicaPropertyTypes;
}
ReplicaPropertyTypeSet& Replicator::GetReplicaPropertyTypes()
{
return mReplicaPropertyTypes;
}
ReplicaPropertyType* Replicator::AddReplicaPropertyType(ReplicaPropertyTypePtr replicaPropertyType)
{
// Add replica property type
ReplicaPropertyTypeSet::pointer_bool_pair result = mReplicaPropertyTypes.Insert(replicaPropertyType);
if(result.second) // Successful?
{
// Make the replica property type valid now that it's registered with our replicator
(*result.first)->MakeValid(this);
// Success
return (*result.first);
}
// Failure
return nullptr;
}
bool Replicator::RemoveReplicaPropertyType(const String& replicaPropertyTypeName)
{
// Remove replica property type
ReplicaPropertyTypeSet::pointer_bool_pair result = mReplicaPropertyTypes.EraseValue(replicaPropertyTypeName);
return result.second;
}
void Replicator::ClearReplicaPropertyTypes()
{
// Remove all replica property types
mReplicaPropertyTypes.Clear();
}
//
// Replica Interface
//
void Replicator::ValidReplica(Replica* replica)
{
// User callback
OnValidReplica(replica);
}
void Replicator::LiveReplica(Replica* replica)
{
// (Sanity check)
Assert(replica->GetInitializationTimestamp() != cInvalidMessageTimestamp);
Assert(replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp);
// For all replica channels
forRange(ReplicaChannel* replicaChannel, replica->GetReplicaChannels().All())
{
// Schedule replica channel for change observation (as needed)
replicaChannel->GetReplicaChannelType()->ScheduleChannel(replicaChannel);
// (Scheduling replica properties for change convergence occurs once its first change is received, so there's nothing to do here)
}
// User callback
OnLiveReplica(replica);
}
void Replicator::InvalidReplica(Replica* replica, bool isForget)
{
// (Sanity check)
Assert(replica->GetUninitializationTimestamp() != cInvalidMessageTimestamp);
// User callback
OnInvalidReplica(replica, isForget);
// For all replica channels
forRange(ReplicaChannel* replicaChannel, replica->GetReplicaChannels().All())
{
// Unschedule replica channel for change observation (as needed)
replicaChannel->GetReplicaChannelType()->UnscheduleChannel(replicaChannel);
// For all replica properties
forRange(ReplicaProperty* replicaProperty, replicaChannel->GetReplicaProperties().All())
{
// Unschedule replica property for change convergence (as needed)
replicaProperty->SetConvergenceState(ConvergenceState::None);
}
}
// Clear replica timestamps
replica->SetInitializationTimestamp(cInvalidMessageTimestamp);
replica->SetLastChangeTimestamp(cInvalidMessageTimestamp);
replica->SetUninitializationTimestamp(cInvalidMessageTimestamp);
}
//
// Replica Helpers
//
bool Replicator::AddReplicaToLiveSet(Replica* replica)
{
// Add replica to live set
ReplicaSet::pointer_bool_pair result = mReplicaSet.Insert(replica);
if(!result.second) // Unable?
{
// Return failure (No clean up necessary)
return false;
}
// Success
return true;
}
bool Replicator::RemoveReplicaFromLiveSet(Replica* replica)
{
// Remove replica from live set
ReplicaSet::pointer_bool_pair result = mReplicaSet.EraseValue(replica);
// Result
return result.second;
}
bool Replicator::AddReplicaToCreateContextSet(Replica* replica)
{
// Add replica to create context set
ReplicaSet::pointer_bool_pair result = mCreateMap.FindOrInsert(replica->GetCreateContext()).Insert(replica);
if(!result.second) // Unable?
{
// Clean up and return failure
RemoveReplicaFromCreateContextSet(replica);
return false;
}
// Success
return true;
}
bool Replicator::RemoveReplicaFromCreateContextSet(Replica* replica)
{
// Get create context set
CreateMap::iterator iter = mCreateMap.FindIterator(replica->GetCreateContext());
if(iter != mCreateMap.End()) // Found?
{
// Remove replica from create context set
ReplicaSet::pointer_bool_pair result = iter->second.EraseValue(replica);
// Replica type set is empty?
if(iter->second.Empty())
mCreateMap.Erase(iter); // Erase create context set
// Result
return result.second;
}
// Failure
return false;
}
bool Replicator::AddReplicaToReplicaTypeSet(Replica* replica)
{
// Add replica to replica type set
ReplicaSet::pointer_bool_pair result = mReplicaMap.FindOrInsert(replica->GetReplicaType()).Insert(replica);
if(!result.second) // Unable?
{
// Clean up and return failure
RemoveReplicaFromReplicaTypeSet(replica);
return false;
}
// Success
return true;
}
bool Replicator::RemoveReplicaFromReplicaTypeSet(Replica* replica)
{
// Get replica type set
ReplicaMap::iterator iter = mReplicaMap.FindIterator(replica->GetReplicaType());
if(iter != mReplicaMap.End()) // Found?
{
// Remove replica from replica type set
ReplicaSet::pointer_bool_pair result = iter->second.EraseValue(replica);
// Replica type set is empty?
if(iter->second.Empty())
mReplicaMap.Erase(iter); // Erase replica type set
// Result
return result.second;
}
// Failure
return false;
}
bool Replicator::AddLiveReplica(Replica* replica)
{
Assert(replica->GetReplicaId() != 0);
// Add replica to live set
{
bool result = AddReplicaToLiveSet(replica);
if(!result) // Unable?
{
// Return failure (No clean up necessary)
Assert(false);
return false;
}
}
// Add replica to create context set
{
bool result = AddReplicaToCreateContextSet(replica);
if(!result) // Unable?
{
// Clean up and return failure
Assert(false);
RemoveReplicaFromLiveSet(replica);
return false;
}
}
// Add replica to replica type set
{
bool result = AddReplicaToReplicaTypeSet(replica);
if(!result) // Unable?
{
// Clean up and return failure
Assert(false);
RemoveReplicaFromCreateContextSet(replica);
RemoveReplicaFromLiveSet(replica);
return false;
}
}
// Set replicator
replica->SetReplicator(this);
Assert(replica->IsLive());
// Success
return true;
}
void Replicator::RemoveLiveReplica(Replica* replica)
{
Assert(replica->GetReplicaId() != 0);
// Remove replica from replica type set
{
bool result = RemoveReplicaFromReplicaTypeSet(replica);
Assert(result); // (Erase should have succeeded)
}
// Remove replica from create context set
{
bool result = RemoveReplicaFromCreateContextSet(replica);
Assert(result); // (Erase should have succeeded)
}
// Remove replica from live set
{
bool result = RemoveReplicaFromLiveSet(replica);
Assert(result); // (Erase should have succeeded)
}
// Clear replicator
replica->SetReplicator(nullptr);
Assert(replica->IsInvalid());
}
bool Replicator::AddEmplacedReplica(Replica* replica)
{
Assert(replica->GetEmplaceId() != 0);
// Add replica to emplace context set
{
// Get/create emplace context set
ReplicaSet& contextSet = mEmplaceMap.FindOrInsert(replica->GetEmplaceContext());
// Is client?
if(GetRole() == Role::Client)
{
// Linear search for replica in set
forRange(Replica* item, contextSet.All())
if(item == replica) // Already in set?
{
Assert(false);
return false;
}
// Push back replica
static_cast<ReplicaSet::array_type&>(contextSet).PushBack(replica);
}
// Is server?
else if(GetRole() == Role::Server)
{
Assert(replica->GetReplicaId() != 0);
// Insert replica at sorted position
ReplicaSet::pointer_bool_pair result = contextSet.Insert(replica);
if(!result.second) // Unable?
{
Assert(false);
return false;
}
}
}
// Set replicator
replica->SetReplicator(this);
Assert(replica->IsValid());
// Success
return true;
}
void Replicator::RemoveEmplacedReplica(Replica* replica)
{
Assert(replica->GetEmplaceId() != 0);
// Remove replica from emplace context set
{
// Get emplace context set
EmplaceMap::iterator iter = mEmplaceMap.FindIterator(replica->GetEmplaceContext());
if(iter != mEmplaceMap.End()) // Found?
{
// Get emplace context set
ReplicaSet& contextSet = iter->second;
// Is client?
if(GetRole() == Role::Client)
{
// Linear search for replica in set
bool result = false;
for(ReplicaSet::iterator iter = contextSet.Begin(); iter != contextSet.End(); ++iter)
if(*iter == replica) // Found?
{
// Erase replica
static_cast<ReplicaSet::array_type&>(contextSet).Erase(iter);
result = true;
break;
}
Assert(result);
}
// Is server?
else if(GetRole() == Role::Server)
{
Assert(replica->GetReplicaId() != 0);
// Erase replica from sorted position
ReplicaSet::pointer_bool_pair result = contextSet.EraseValue(replica);
Assert(result.second);
}
// Context set is empty?
if(contextSet.Empty())
mEmplaceMap.Erase(iter); // Erase emplace context set
}
else
Assert(false);
}
// Clear replicator
replica->SetReplicator(nullptr);
Assert(replica->IsInvalid());
}
//
// ID Helpers
//
void Replicator::SetReplicatorId(ReplicatorId replicatorId)
{
Assert(GetRole() == Role::Client);
mReplicatorId = replicatorId;
}
bool Replicator::AssignReplicatorId(ReplicatorLink* link)
{
Assert(GetRole() == Role::Server);
Assert(link->GetReplicatorId() == 0);
// Acquire replicator ID
ReplicatorId replicatorId = mReplicatorIdStore.AcquireId();
if(replicatorId == 0) // Unable?
return false;
// Assign replicator ID
link->SetReplicatorId(replicatorId);
Assert(link->GetReplicatorId() != 0);
// Success
return true;
}
void Replicator::ReleaseReplicatorId(ReplicatorLink* link)
{
Assert(GetRole() == Role::Server);
Assert(link->GetReplicatorId() != 0);
// Free replicator ID
bool result = mReplicatorIdStore.FreeId(link->GetReplicatorId());
Assert(result);
// Clear replicator ID
link->SetReplicatorId(0);
Assert(link->GetReplicatorId() == 0);
}
bool Replicator::AssignReplicaId(Replica* replica)
{
Assert(GetRole() == Role::Server);
Assert(replica->GetReplicaId() == 0);
// Acquire replica ID
ReplicaId replicaId = mReplicaIdStore.AcquireId();
if(replicaId == 0) // Unable?
return false;
// Assign replica ID
replica->SetReplicaId(replicaId);
Assert(replica->GetReplicaId() != 0);
// Success
return true;
}
void Replicator::ReleaseReplicaId(Replica* replica)
{
Assert(GetRole() == Role::Server);
Assert(replica->GetReplicaId() != 0);
// Free replica ID
bool result = mReplicaIdStore.FreeId(replica->GetReplicaId());
Assert(result);
// Clear replica ID
replica->SetReplicaId(0);
Assert(replica->GetReplicaId() == 0);
}
bool Replicator::AssignEmplaceId(Replica* replica)
{
Assert(replica->GetEmplaceId() == 0);
// Acquire emplace ID
EmplaceId emplaceId = mEmplaceIdStores.FindOrInsert(replica->GetEmplaceContext()).AcquireId();
if(emplaceId == 0) // Unable?
return false;
// Assign emplace ID
replica->SetEmplaceId(emplaceId);
Assert(replica->GetEmplaceId() != 0);
// Success
return true;
}
void Replicator::ReleaseEmplaceId(Replica* replica)
{
Assert(replica->GetEmplaceId() != 0);
// Get emplace ID store
EmplaceIdStores::iterator iter = mEmplaceIdStores.FindIterator(replica->GetEmplaceContext());
if(iter != mEmplaceIdStores.End()) // Found?
{
// Free emplace ID
bool result = iter->second.FreeId(replica->GetEmplaceId());
Assert(result);
// No emplace IDs left in use?
if(!iter->second.HasAcquiredIds())
mEmplaceIdStores.Erase(iter); // Erase emplace ID store
}
else
Assert(false);
// Clear emplace ID
replica->SetEmplaceId(0);
Assert(replica->GetEmplaceId() == 0);
}
//
// Replication Helpers
//
bool Replicator::ShouldIncludeAccurateTimestampOnInitialization(const ReplicaArray& replicas)
{
forRange(Replica* replica, replicas.All())
if(replica && replica->GetAccurateTimestampOnInitialization())
return true;
return false;
}
bool Replicator::ShouldIncludeAccurateTimestampOnUninitialization(const ReplicaArray& replicas)
{
forRange(Replica* replica, replicas.All())
if(replica && replica->GetAccurateTimestampOnUninitialization())
return true;
return false;
}
bool Replicator::ShouldIncludeAccurateTimestampOnChange(ReplicaChannel* replicaChannel)
{
return replicaChannel->GetReplica()->GetAccurateTimestampOnChange()
|| replicaChannel->GetReplicaChannelType()->GetAccurateTimestampOnChange();
}
TimeMs Replicator::GetInitializationTimestamp(const ReplicaArray& replicas)
{
#ifdef PlasmaDebug
// Verify all replica timestamps are the same
// (We only serialize a single timestamp for all replicas in the replication command, so we're assuming they're all the same!)
forRange(Replica* replica1, replicas.All())
forRange(Replica* replica2, replicas.All())
if((replica1 && replica2)
&& (replica1->GetInitializationTimestamp() != replica2->GetInitializationTimestamp()))
Assert(false);
#endif
forRange(Replica* replica, replicas.All())
if(replica && replica->GetInitializationTimestamp() != cInvalidMessageTimestamp)
return replica->GetInitializationTimestamp();
return cInvalidMessageTimestamp;
}
TimeMs Replicator::GetUninitializationTimestamp(const ReplicaArray& replicas)
{
#ifdef PlasmaDebug
// Verify all replica timestamps are the same
// (We only serialize a single timestamp for all replicas in the replication command, so we're assuming they're all the same!)
forRange(Replica* replica1, replicas.All())
forRange(Replica* replica2, replicas.All())
if((replica1 && replica2)
&& (replica1->GetUninitializationTimestamp() != replica2->GetUninitializationTimestamp()))
Assert(false);
#endif
forRange(Replica* replica, replicas.All())
if(replica && replica->GetUninitializationTimestamp() != cInvalidMessageTimestamp)
return replica->GetUninitializationTimestamp();
return cInvalidMessageTimestamp;
}
bool Replicator::HandleEmplace(const ReplicaArray& replicas, const EmplaceContext& emplaceContext, TimeMs timestamp)
{
//
// Handle ValidReplica and ReactToChannelPropertyChanges
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
Assert(replica->GetEmplaceId() == 0);
// Set emplace context
replica->SetEmplaceContext(emplaceContext);
// Assign emplace ID
if(!AssignEmplaceId(replica)) // Unable?
{
Assert(false);
return false;
}
Assert(replica->GetEmplaceId() != 0);
// Replica is about to made valid
Assert(replica->IsInvalid());
ValidReplica(replica);
// Is server?
if(GetRole() == Role::Server)
{
Assert(replica->GetInitializationTimestamp() == cInvalidMessageTimestamp);
// Set replica's initialization timestamp
replica->SetInitializationTimestamp(timestamp);
Assert(replica->GetInitializationTimestamp() != cInvalidMessageTimestamp);
Assert(replica->GetReplicaId() == 0);
// Emplace context not mapped to an ID?
if(!mEmplaceContextCacher.IsItemMapped(replica->GetEmplaceContext()))
{
// Map emplace context to ID
bool result = mEmplaceContextCacher.MapItem(replica->GetEmplaceContext());
Assert(result);
}
// Create context not mapped to an ID?
if(!mCreateContextCacher.IsItemMapped(replica->GetCreateContext()))
{
// Map create context to ID
bool result = mCreateContextCacher.MapItem(replica->GetCreateContext());
Assert(result);
}
// Replica type not mapped to an ID?
if(!mReplicaTypeCacher.IsItemMapped(replica->GetReplicaType()))
{
// Map replica type to ID
bool result = mReplicaTypeCacher.MapItem(replica->GetReplicaType());
Assert(result);
}
// Assign replica ID
if(!AssignReplicaId(replica)) // Unable?
{
Assert(false);
return false;
}
Assert(replica->GetReplicaId() != 0);
}
// Is client?
else if(GetRole() == Role::Client)
{
Assert(replica->GetReplicaId() == 0);
}
// Add emplaced replica
if(!AddEmplacedReplica(replica)) // Unable?
{
Assert(false);
return false;
}
// Replica is now valid
Assert(replica->IsValid());
// Is server?
if(GetRole() == Role::Server)
{
// Add live replica
if(!AddLiveReplica(replica)) // Unable?
{
Assert(false);
return false;
}
}
// Handle initial replica channel property values
// (Generate replica channel property changed notifications only if we're the server)
// (Because emplacements on the server make the object live immediately, but not on the client where theirs occurs on receiving an incoming clone)
replica->ReactToChannelPropertyChanges(timestamp, ReplicationPhase::Initialization, TransmissionDirection::Outgoing, (GetRole() == Role::Server));
}
//
// Handle LiveReplica
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
// Is server?
if(GetRole() == Role::Server)
{
// Replica is now live
Assert(replica->IsLive());
LiveReplica(replica);
}
Assert(replica->IsEmplaced());
}
// Success
return true;
}
bool Replicator::HandleSpawn(const ReplicaArray& replicas, TransmissionDirection::Enum direction, TimeMs timestamp)
{
//
// Handle ValidReplica and ReactToChannelPropertyChanges
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
Assert(replica->GetInitializationTimestamp() == cInvalidMessageTimestamp);
// Set replica's initialization timestamp
replica->SetInitializationTimestamp(timestamp);
Assert(replica->GetInitializationTimestamp() != cInvalidMessageTimestamp);
// Replica is about to made valid
Assert(replica->IsInvalid());
ValidReplica(replica);
// Outgoing spawn command?
if(direction == TransmissionDirection::Outgoing)
{
Assert(GetRole() == Role::Server);
Assert(replica->GetReplicaId() == 0);
// Create context not mapped to an ID?
if(!mCreateContextCacher.IsItemMapped(replica->GetCreateContext()))
{
// Map create context to ID
bool result = mCreateContextCacher.MapItem(replica->GetCreateContext());
Assert(result);
}
// Replica type not mapped to an ID?
if(!mReplicaTypeCacher.IsItemMapped(replica->GetReplicaType()))
{
// Map replica type to ID
bool result = mReplicaTypeCacher.MapItem(replica->GetReplicaType());
Assert(result);
}
// Assign replica ID
if(!AssignReplicaId(replica)) // Unable?
{
Assert(false);
return false;
}
Assert(replica->GetReplicaId() != 0);
}
// Incoming spawn command?
else
{
Assert(GetRole() == Role::Client);
Assert(replica->GetReplicaId() != 0);
}
// Add live replica
if(!AddLiveReplica(replica)) // Unable?
{
Assert(false);
return false;
}
// Replica is now valid
Assert(replica->IsValid());
// Handle initial replica channel property values
replica->ReactToChannelPropertyChanges(timestamp, ReplicationPhase::Initialization, direction, true);
}
//
// Handle LiveReplica
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
// Replica is now live
Assert(replica->IsLive());
LiveReplica(replica);
Assert(replica->IsSpawned());
}
// Success
return true;
}
bool Replicator::RouteSpawn(const ReplicaArray& replicas, const Route& route, TimeMs timestamp)
{
Assert(GetRole() == Role::Server);
// (All replicas should have a replica ID)
AssertReplicas(replicas, replica->GetReplicaId() != 0, "");
// Get links in route
PeerLinkSet links = GetLinks(route);
// For all links in route
forRange(PeerLink* link, links.All())
{
// Get replicator link
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
// Send spawn command
replicatorLink->SendSpawn(replicas, timestamp);
}
// Success
return true;
}
bool Replicator::HandleClone(const ReplicaArray& replicas, TransmissionDirection::Enum direction, TimeMs timestamp)
{
// Incoming clone command?
if(direction == TransmissionDirection::Incoming)
{
Assert(GetRole() == Role::Client);
//
// Handle ValidReplica and ReactToChannelPropertyChanges
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
Assert(replica->GetInitializationTimestamp() == cInvalidMessageTimestamp);
// Set replica's initialization timestamp
replica->SetInitializationTimestamp(timestamp);
Assert(replica->GetInitializationTimestamp() != cInvalidMessageTimestamp);
Assert(replica->GetReplicaId() != 0);
// Is spawned?
if(replica->IsSpawned())
{
// Replica is about to made valid
Assert(replica->IsInvalid());
ValidReplica(replica);
}
// Add live replica
if(!AddLiveReplica(replica)) // Unable?
{
Assert(false);
return false;
}
// Replica is now valid
Assert(replica->IsValid());
// Handle initial replica channel property values
replica->ReactToChannelPropertyChanges(timestamp, ReplicationPhase::Initialization, direction, true);
}
//
// Handle LiveReplica
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
// Replica is now live
Assert(replica->IsLive());
LiveReplica(replica);
}
}
// Success
return true;
}
bool Replicator::RouteClone(const ReplicaArray& replicas, const Route& route, TimeMs timestamp)
{
Assert(GetRole() == Role::Server);
// (All replicas should have a replica ID)
AssertReplicas(replicas, replica->GetReplicaId() != 0, "");
// Get links in route
PeerLinkSet links = GetLinks(route);
// For all links in route
forRange(PeerLink* link, links.All())
{
// Get replicator link
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
// Send clone command
replicatorLink->SendClone(replicas, timestamp);
}
// Success
return true;
}
bool Replicator::HandleForget(const ReplicaArray& replicas, TransmissionDirection::Enum direction, TimeMs timestamp)
{
//
// Handle ReactToChannelPropertyChanges
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
Assert(replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp);
// Set replica's uninitialization timestamp
replica->SetUninitializationTimestamp(timestamp);
Assert(replica->GetUninitializationTimestamp() != cInvalidMessageTimestamp);
// Handle final replica channel property values
replica->ReactToChannelPropertyChanges(timestamp, ReplicationPhase::Uninitialization, direction, true);
}
//
// Handle InvalidReplica
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
// Replica is about to become invalid
Assert(replica->IsValid());
InvalidReplica(replica, true);
// Replica is live?
if(replica->IsLive())
{
// Remove live replica
RemoveLiveReplica(replica);
}
// Replica was emplaced?
if(replica->IsEmplaced())
{
// Remove emplaced replica
RemoveEmplacedReplica(replica);
Assert(replica->GetEmplaceId() != 0);
// Release emplace ID
ReleaseEmplaceId(replica);
Assert(replica->GetEmplaceId() == 0);
}
// Is server?
if(GetRole() == Role::Server)
{
Assert(direction == TransmissionDirection::Outgoing);
Assert(replica->GetReplicaId() != 0);
// Release replica ID
ReleaseReplicaId(replica);
Assert(replica->GetReplicaId() == 0);
}
// Is client?
else if(GetRole() == Role::Client)
{
// Clear replica ID (if any)
replica->SetReplicaId(0);
Assert(replica->GetReplicaId() == 0);
}
Assert(replica->IsInvalid());
}
// Success
return true;
}
bool Replicator::RouteForget(const ReplicaArray& replicas, const Route& route, TimeMs timestamp)
{
Assert(GetRole() == Role::Server);
// (All replicas should have a replica ID)
AssertReplicas(replicas, replica->GetReplicaId() != 0, "");
// Get links in route
PeerLinkSet links = GetLinks(route);
// For all links in route
forRange(PeerLink* link, links.All())
{
// Get replicator link
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
// Send forget command
replicatorLink->SendForget(replicas, timestamp);
}
// Success
return true;
}
bool Replicator::HandleDestroy(const ReplicaArray& replicas, TransmissionDirection::Enum direction, TimeMs timestamp)
{
//
// Handle ReactToChannelPropertyChanges
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
Assert(replica->GetUninitializationTimestamp() == cInvalidMessageTimestamp);
// Set replica's uninitialization timestamp
replica->SetUninitializationTimestamp(timestamp);
Assert(replica->GetUninitializationTimestamp() != cInvalidMessageTimestamp);
// Handle final replica channel property values
replica->ReactToChannelPropertyChanges(timestamp, ReplicationPhase::Uninitialization, direction, true);
}
//
// Handle InvalidReplica
//
// For all replicas
forRange(Replica* replica, replicas.All())
{
// Absent replica?
if(!replica)
continue; // Skip
// Replica is about to become invalid
Assert(replica->IsLive());
InvalidReplica(replica, false);
// Remove live replica
RemoveLiveReplica(replica);
// Replica was emplaced?
if(replica->IsEmplaced())
{
// Remove emplaced replica
RemoveEmplacedReplica(replica);
Assert(replica->GetEmplaceId() != 0);
// Release emplace ID
ReleaseEmplaceId(replica);
Assert(replica->GetEmplaceId() == 0);
}
// Outgoing destroy command?
if(direction == TransmissionDirection::Outgoing)
{
Assert(GetRole() == Role::Server);
Assert(replica->GetReplicaId() != 0);
// Release replica ID
ReleaseReplicaId(replica);
Assert(replica->GetReplicaId() == 0);
}
// Incoming destroy command?
else
{
Assert(GetRole() == Role::Client);
Assert(replica->GetReplicaId() != 0);
// Clear replica ID
replica->SetReplicaId(0);
Assert(replica->GetReplicaId() == 0);
}
Assert(replica->IsInvalid());
}
// Success
return true;
}
bool Replicator::RouteDestroy(const ReplicaArray& replicas, const Route& route, TimeMs timestamp)
{
Assert(GetRole() == Role::Server);
// (All replicas should have a replica ID)
AssertReplicas(replicas, replica->GetReplicaId() != 0, "");
// Get links in route
PeerLinkSet links = GetLinks(route);
// For all links in route
forRange(PeerLink* link, links.All())
{
// Get replicator link
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
// Send destroy command
replicatorLink->SendDestroy(replicas, timestamp);
}
// Success
return true;
}
bool Replicator::RouteChange(ReplicaChannel* replicaChannel, const Route& route, TimeMs timestamp)
{
// Get replica
Replica* replica = replicaChannel->GetReplica();
ReplicaId::value_type replicaId = replica->GetReplicaId().value();
Assert(replica && replicaId);
// Route replica channel change
PeerLinkSet links = GetLinks(route);
if(!links.Empty()) // Links in route?
{
// Serialize replica channel change
Message message(ReplicatorMessageType::Change);
if(!SerializeChange(replicaChannel, message, timestamp)) // Unable?
return false;
// Should include an accurate timestamp with this message?
if(Replicator::ShouldIncludeAccurateTimestampOnChange(replicaChannel))
{
// Set accurate timestamp
message.SetTimestamp(timestamp);
}
// For all replicator links in route
forRange(PeerLink* link, links.All())
{
// Get replicator link
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
// Should skip change replication?
if(replicatorLink->ShouldSkipChangeReplication())
continue; // Skip link
// Has replica remotely?
if(replicatorLink->HasReplica(replica))
replicatorLink->SendChange(replicaChannel, message); // Send replica channel change
}
}
// Success
return true;
}
bool Replicator::SerializeChange(ReplicaChannel* replicaChannel, Message& message, TimeMs timestamp)
{
// Serialize replica channel change
BitStream& bitStream = message.GetData();
// Write replica channel
bool result = replicaChannel->Serialize(bitStream, ReplicationPhase::Change, timestamp);
if(!result) // Unable?
{
Assert(false);
return false;
}
// Success
return true;
}
bool Replicator::RouteInterrupt(const Route& route)
{
Assert(GetRole() == Role::Server);
// Route interrupt command
PeerLinkSet links = GetLinks(route);
if(!links.Empty()) // Links in route?
{
// Serialize interrupt command
Message message(ReplicatorMessageType::Interrupt);
// For all replicator links in route
forRange(PeerLink* link, links.All())
{
// Send interrupt command
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
replicatorLink->SendInterrupt(message);
}
}
// Success
return true;
}
//
// Peer Plugin Interface
//
bool Replicator::ShouldDeleteAfterRemoval()
{
return false;
}
bool Replicator::OnInitialize()
{
switch(GetRole())
{
default:
case Role::Unspecified:
{
// Invalid role, do not use replicator plugin
return false;
}
case Role::Client:
{
// Set connect response mode to deny
// Clients should not accept any incoming connections
GetPeer()->SetConnectResponseMode(ConnectResponseMode::Deny);
// Success, use replicator plugin
return true;
}
case Role::Server:
{
// Set connect response mode to custom
// Server should decide when to accept incoming connections
GetPeer()->SetConnectResponseMode(ConnectResponseMode::Custom);
// Success, use replicator plugin
return true;
}
}
}
void Replicator::OnUninitialize()
{
// Forget any remaining replicas locally
bool result = ForgetAllReplicas(Route::None);
Assert(result);
// (Sanity check)
Assert(mReplicaSet.Empty());
Assert(mCreateMap.Empty());
Assert(mReplicaMap.Empty());
Assert(mEmplaceMap.Empty());
Assert(!mReplicaIdStore.HasAcquiredIds());
Assert(mEmplaceIdStores.Empty());
// Reset session data
ResetSession();
}
void Replicator::OnUpdate()
{
ProfileScopeTree("Replication", "NetPeer", Color::Orange);
// Get current time
TimeMs now = GetPeer()->GetLocalTime();
//
// Update Start
//
// For all links
PeerLinkSet links = GetLinks();
forRange(PeerLink* link, links.All())
{
// Get replicator link
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
// Handle update start
replicatorLink->UpdateStart(now);
}
//
// Update
//
// For all replica channel types
forRange(ReplicaChannelTypePtr& replicaChannelType, mReplicaChannelTypes.All())
{
// Observe all scheduled replica channels of this type and replicate any changes
replicaChannelType->ObserveAndReplicateChanges();
}
// For all replica property types
forRange(ReplicaPropertyTypePtr& replicaPropertyType, mReplicaPropertyTypes.All())
{
// Converge all scheduled replica properties of this type
replicaPropertyType->ConvergeNow();
}
//
// Update End
//
// For all links
forRange(PeerLink* link, links.All())
{
// Get replicator link
ReplicatorLink* replicatorLink = link->GetPlugin<ReplicatorLink>("ReplicatorLink");
// Handle update end
replicatorLink->UpdateEnd(now);
}
}
bool Replicator::OnLinkAdd(PeerLink* link)
{
// Add replicator link plugin
ReplicatorLink* replicatorLink = new ReplicatorLink(this);
if(!link->AddPlugin(replicatorLink, "ReplicatorLink")) // Unable?
{
delete replicatorLink;
Assert(false);
return false;
}
// User callback
AddingLink(link);
// Success
return true;
}
void Replicator::OnLinkRemove(PeerLink* link)
{
// User callback
RemovingLink(link);
}
String GetReplicatorDisplayName(Replicator* replicator)
{
return GetReplicatorDisplayName(replicator->GetPeer()->GetLocalIpv4Address(), replicator->GetRole(), replicator->GetReplicatorId());
}
String GetReplicatorDisplayName(ReplicatorLink* replicatorLink)
{
return GetReplicatorDisplayName(replicatorLink->GetLink()->GetTheirIpAddress(), replicatorLink->GetTheirRole(), replicatorLink->GetReplicatorId());
}
String GetReplicatorDisplayName(const IpAddress& ipAddress, Role::Enum role, ReplicatorId replicatorId)
{
// Is client? (Replicator ID may be non-zero?)
if(role == Role::Client)
{
return String::Format("(%s) [%s %u]", ipAddress.GetString().c_str(), Role::Names[role], replicatorId.value());
}
// Is other role?
else
{
return String::Format("(%s) [%s]", ipAddress.GetString().c_str(), Role::Names[role]);
}
}
} // Namespace Plasma
| [
"dragonCASTjosh@gmail.com"
] | dragonCASTjosh@gmail.com |
a42ca04d3e8f171302d7d2aefcdc758d09651fe5 | dcf70d28532a0fb837c1b133c5537940228aa889 | /Robot Simulation/iteration2/src/light.cc | fb58d9674d2577ca86bb7f72d3c821b43389d900 | [] | no_license | Ndsamu/Portfolio | 624dc8b96e95ffcb753081547448409161b676f6 | 5e86ae66aa456b793675c09f0b14cfdc9bb45b29 | refs/heads/master | 2020-04-05T02:15:58.786013 | 2019-01-31T18:10:36 | 2019-01-31T18:10:36 | 156,450,125 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,985 | cc | /**
* @file light.cc
*
* @copyright 2017 3081 Staff, All rights reserved.
*/
/*******************************************************************************
* Includes
******************************************************************************/
#include "src/light.h"
#include "src/params.h"
/*******************************************************************************
* Namespaces
******************************************************************************/
NAMESPACE_BEGIN(csci3081);
/*******************************************************************************
* Constructors/Destructor
******************************************************************************/
Light::Light() :
motion_handler_(this),
motion_behavior_(this),
state_(0),
avoid_time_(80) {
set_type(kLight);
set_color(LIGHT_COLOR);
set_pose(LIGHT_INIT_POS);
set_radius(LIGHT_RADIUS);
sensor_touch_->Reset();
} /* Light() */
/*******************************************************************************
* Member Functions
******************************************************************************/
void Light::Reset() {
set_pose(set_pose_randomly());
set_heading(LIGHT_HEADING);
} /* Reset() */
void Light::TimestepUpdate(unsigned int dt) {
if (GetState() == 1 && avoid_time_ > 0) {
motion_handler_.set_velocity(AVOIDANCE_SPEED,
AVOIDANCE_SPEED);
set_heading(get_heading()-10);
avoid_time_ -= 5;
} else {
SetState(0);
motion_handler_.set_velocity(ACTIVE_SPEED, ACTIVE_SPEED);
avoid_time_ = 50;
}
// Update heading as indicated by touch sensor
motion_handler_.UpdateVelocity();
// Use velocity and position to update position
motion_behavior_.UpdatePose(dt, motion_handler_.get_velocity());
// Reset Sensor for next cycle
sensor_touch_->Reset();
} /* TimestepUpdate() */
void Light::HandleCollision() {
SetState(1);
} /* HandleCollision() */
NAMESPACE_END(csci3081);
| [
"samue289@umn.edu"
] | samue289@umn.edu |
e1d88bb3f0b953afecf6b8dec491c2340199724c | 8b8faa1ae046741473ea81f17fbbf4b55f7cc45d | /ConsoleApplication2/GameScene.h | 529edb10fb5088cb4d91830d607ab65f3c739c63 | [] | no_license | Vicen04/Space-Game-test | 634e476c41c3c7029a4415ad0d7793954fc9851e | b3ceb3da592319bba8925d9a4d6ceb3ad7778225 | refs/heads/master | 2023-02-10T02:00:09.549787 | 2021-01-02T19:03:08 | 2021-01-02T19:03:08 | 291,293,628 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,881 | h | #pragma once
#include "Player.h"
#include "Scene.h"
class CollisionDetection;
class Ally;
class SceneBase: public Scene
{
public:
SceneBase(shared_ptr<Text> _text, shared_ptr<CameraComponent> camera, shared_ptr<Player> player);
~SceneBase();
virtual void Update(float deltaTime);
virtual void BossBullets(std::shared_ptr<GameObject> enemy) = 0;
void Draw();
void AddObjects(std::shared_ptr<GameObject> object) { _gameObjects.push_back(object); }
void SetBackground(string texture);
void SpawnPlayerBullet();
void SpawnPlayerAllies();
void PlayerBomb();
void SpawnEnemyBullet(std::shared_ptr<GameObject> enemy);
void SpawnItems(std::shared_ptr<GameObject> enemy);
void CollisionManager(std::shared_ptr<GameObject> object1, std::shared_ptr<GameObject> object2);
vector<std::shared_ptr<GameObject>> GetGameObjects() { return _gameObjects; }
std::shared_ptr<GameObject> GetLastGameObject() { if (_gameObjects.size() > 1) return _gameObjects.at(_gameObjects.size() - 1); else return nullptr; }
shared_ptr<CameraComponent> GetCamera() { return _camera; }
LightAsset* GetLight() { return _light.get(); }
Shader* GetShader() { return _shader.get(); }
void SetPlayer(Player* player) { _player.reset(player); }
shared_ptr<Player> GetPlayer() { return _player; }
shared_ptr<Background> GetBackground() { return _background; };
shared_ptr<Texture2D> GetEnemyBulletTex() { return _enemyBulletTex; }
private:
vector< std::shared_ptr<GameObject>> _gameObjects;
shared_ptr<Background> _background;
shared_ptr<CameraComponent> _camera;
shared_ptr<LightAsset> _light;
shared_ptr<Shader> _shader;
shared_ptr<Player> _player;
shared_ptr<Text> _text;
unique_ptr<CollisionDetection> _collision;
shared_ptr<Texture2D> _playerbulletTex, _enemyBulletTex, _shield, _life, _bullet, _bomb, _speed, _bossBulletTex, _allyTex;
shared_ptr<Ally> _allyTop, _allyBottom;
};
| [
"vice.avu.15@gmail.com"
] | vice.avu.15@gmail.com |
f5bf75ff3983f6c72858727aed0fe99d1efc79fa | 09cad110644ae1e5d51040aa4112c07c5c86958b | /ARP/Problem/Workspace.hxx | 551c3dd9a71262bed080283210fb8e32bbe3ce5b | [
"MIT"
] | permissive | dechterlab/DBE | 6451dd4c3caf06c19548aeb689c4913b2334dd51 | b3910d39490f7e5bba5ae4ff5242c8df59ff6af5 | refs/heads/main | 2023-05-02T14:07:31.276658 | 2021-05-20T13:25:42 | 2021-05-20T13:25:42 | 369,210,018 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,598 | hxx | #ifndef ARE_workspace_HXX_INCLUDED
#define ARE_workspace_HXX_INCLUDED
#include <stdlib.h>
#if defined WINDOWS || _WINDOWS
#include <windows.h>
#endif // WINDOWS
#include "Explanation.hxx"
#include "Function.hxx"
namespace ARE { class ARP ; }
namespace ARE { class Function ; }
#ifndef ARP_nInfinity
#define ARP_nInfinity (-std::numeric_limits<double>::infinity())
#endif // ARP_nInfinity
#ifndef ARP_pInfinity
#define ARP_pInfinity (std::numeric_limits<double>::infinity())
#endif // ARP_pInfinity
#ifndef ARP_DBL_MAX
#define ARP_DBL_MAX DBL_MAX
// std::numeric_limits<double>::max()
#endif
namespace ARE
{
class Workspace
{
protected :
bool _IsValid ; // indicates whether workspace was constructed correctly
public :
inline bool IsValid(void) const { return _IsValid ; }
protected :
// we assume that the problem does NOT belong to the workspace unless otherwise specified
bool _ProblemBelongsToWorkspace ;
ARE::ARP *_Problem ;
public :
double time_ComputeOutputFunction_NN = 0;
int count_ComputeOutputFunction_NN = 0;
double time_TableEntryEx = 0;
int count_TableEntryEx = 0;
double time_Train = 0;
int count_Train = 0;
inline bool & ProblemBelongsToWorkspace(void) { return _ProblemBelongsToWorkspace ; }
inline ARE::ARP *Problem(void) const { return _Problem ; }
// **************************************************************************************************
// error codes occuring during computation
// **************************************************************************************************
protected :
bool _HasFatalError ;
ARE::Explanation *_ExplanationList ;
public :
inline bool HasFatalError(void) const { return _HasFatalError ; }
inline void SetFatalError(void) { _HasFatalError = true ; }
void AddErrorExplanation(ARE::Function *f) ;
void AddExplanation(ARE::Explanation & E) ;
bool HasErrorExplanation(void) ;
// **************************************************************************************************
// External Memory BE
// **************************************************************************************************
protected :
// This mutex is used to synchronize access to Function-Table-Block related data within this workspace.
// In particular, it is used :
// 1) protect access to _CurrentDiskMemorySpaceCached/_MaximumDiskMemorySpaceCached variables of this workspace.
// 2) _FTBsInMemory ptr (list) of functions in this workspace.
// 3) indirectly, the users list of each FTB.
// 4) maintain/update the _BucketFunctionBlockComputationResult arrays in each bucket
ARE::utils::RecursiveMutex _FTBMutex ;
public :
inline ARE::utils::RecursiveMutex & FTBMutex(void) { return _FTBMutex ; }
protected :
std::string _DiskSpaceDirectory ;
public :
inline const std::string & DiskSpaceDirectory(void) const { return _DiskSpaceDirectory ; }
protected :
__int64 _nInputTableBlocksWaited ;
__int64 _InputTableBlocksWaitPeriodTotal ;
__int64 _InputTableGetTimeTotal ; // time of Functio::GetFTB(). in milliseconds.
__int64 _FileLoadTimeTotal ; // in milliseconds.
__int64 _FileSaveTimeTotal ; // in milliseconds.
__int64 _FTBComputationTimeTotal ; // in milliseconds.
__int64 _nTableBlocksLoaded ;
__int64 _nTableBlocksSaved ;
__int64 _CurrentDiskMemorySpaceCached ;
__int64 _MaximumDiskMemorySpaceCached ;
int _nDiskTableBlocksInMemory ;
int _MaximumNumConcurrentDiskTableBlocksInMemory ;
int _nFTBsLoadedPerBucket[MAX_NUM_BUCKETS] ;
//
int _InputFTBWait_BucketIDX[128] ;
int _InputFTBWait_BlockIDX[128] ;
//
public :
void ResetStatistics(void)
{
_nInputTableBlocksWaited = _InputTableBlocksWaitPeriodTotal = _nTableBlocksLoaded = _nTableBlocksSaved = 0 ;
_InputTableGetTimeTotal = _FileLoadTimeTotal = _FileSaveTimeTotal = _FTBComputationTimeTotal = 0 ;
_CurrentDiskMemorySpaceCached = _MaximumDiskMemorySpaceCached = 0 ;
_nDiskTableBlocksInMemory = _MaximumNumConcurrentDiskTableBlocksInMemory = 0 ;
for (int i = 0 ; i < MAX_NUM_BUCKETS ; i++)
_nFTBsLoadedPerBucket[i] = 0 ;
}
inline __int64 nInputTableBlocksWaited(void) const { return _nInputTableBlocksWaited ; }
inline void InputTableBlockWaitDetails(int i, int & BucketIDX, __int64 & BlockIDX) const { BucketIDX = _InputFTBWait_BucketIDX[i] ; BlockIDX = _InputFTBWait_BlockIDX[i] ; }
inline __int64 InputTableBlocksWaitPeriodTotal(void) const { return _InputTableBlocksWaitPeriodTotal ; }
inline __int64 InputTableGetTimeTotal(void) const { return _InputTableGetTimeTotal ; }
inline __int64 FileLoadTimeTotal(void) const { return _FileLoadTimeTotal ; }
inline __int64 FileSaveTimeTotal(void) const { return _FileSaveTimeTotal ; }
inline __int64 FTBComputationTimeTotal(void) const { return _FTBComputationTimeTotal ; }
inline __int64 nTableBlocksLoaded(void) const { return _nTableBlocksLoaded ; }
inline __int64 nTableBlocksSaved(void) const { return _nTableBlocksSaved; }
inline int nFTBsLoadedPerBucket(int IDX) const { return _nFTBsLoadedPerBucket[IDX] ; }
inline void NoteInputTableGetTime(DWORD t)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
_InputTableGetTimeTotal += t ;
}
inline void NoteFileLoadTime(DWORD t)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
_FileLoadTimeTotal += t ;
}
inline void NoteFileSaveTime(DWORD t)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
_FileSaveTimeTotal += t ;
}
inline void NoteFTBComputationTime(DWORD t)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
_FTBComputationTimeTotal += t ;
}
inline void NoteInputTableBlocksWait(int BucketIDX, __int64 BlockIDX, bool Increment, long WaitInMilliseconds)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
_InputTableBlocksWaitPeriodTotal += WaitInMilliseconds ;
if (Increment) {
//if (_nInputTableBlocksWaited < 128) {
//_InputFTBWait_BucketIDX[_nInputTableBlocksWaited] = BucketIDX ;
//_InputFTBWait_BlockIDX[_nInputTableBlocksWaited] = BlockIDX ;
//}
++_nInputTableBlocksWaited ;
}
}
inline void IncrementnTableBlocksLoaded(int IDX)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
++_nTableBlocksLoaded ;
if (IDX >= 0)
_nFTBsLoadedPerBucket[IDX]++ ;
}
inline void IncrementnTableBlocksSaved(void)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
++_nTableBlocksSaved ;
}
inline __int64 CurrentDiskMemorySpaceCached(void) const { return _CurrentDiskMemorySpaceCached ; }
inline __int64 MaximumDiskMemorySpaceCached(void) const { return _MaximumDiskMemorySpaceCached ; }
inline int nDiskTableBlocksInMemory(void) const { return _nDiskTableBlocksInMemory ; }
inline int MaximumNumConcurrentDiskTableBlocksInMemory(void) const { return _MaximumNumConcurrentDiskTableBlocksInMemory ; }
void NoteDiskMemoryBlockLoaded(__int64 Space)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
++_nDiskTableBlocksInMemory ;
if (_nDiskTableBlocksInMemory > _MaximumNumConcurrentDiskTableBlocksInMemory)
_MaximumNumConcurrentDiskTableBlocksInMemory = _nDiskTableBlocksInMemory ;
_CurrentDiskMemorySpaceCached += Space ;
if (_CurrentDiskMemorySpaceCached > _MaximumDiskMemorySpaceCached)
_MaximumDiskMemorySpaceCached = _CurrentDiskMemorySpaceCached ;
}
void NoteDiskMemoryBlockUnLoaded(__int64 Space)
{
ARE::utils::AutoLock lock(_FTBMutex) ;
--_nDiskTableBlocksInMemory ;
_CurrentDiskMemorySpaceCached -= Space ;
}
void LogStatistics(time_t ttStart, time_t ttFinish) ;
public :
virtual int Initialize(ARE::ARP & Problem)
{
if (NULL != _Problem) {
if (&Problem != _Problem)
// cannot initialize twice, one atop another; must do reset in between.
return 1 ;
}
_Problem = &Problem ;
return 0 ;
}
virtual int Destroy(void) ;
Workspace(const char *BEEMDiskSpaceDirectory)
:
_IsValid(true),
_ProblemBelongsToWorkspace(false),
_Problem(NULL),
_HasFatalError(false),
_ExplanationList(NULL),
_nInputTableBlocksWaited(0),
_InputTableBlocksWaitPeriodTotal(0),
_InputTableGetTimeTotal(0),
_FileLoadTimeTotal(0),
_FileSaveTimeTotal(0),
_FTBComputationTimeTotal(0),
_nTableBlocksLoaded(0),
_nTableBlocksSaved(0),
_CurrentDiskMemorySpaceCached(0),
_MaximumDiskMemorySpaceCached(0),
_nDiskTableBlocksInMemory(0),
_MaximumNumConcurrentDiskTableBlocksInMemory(0)
{
if (NULL != BEEMDiskSpaceDirectory)
_DiskSpaceDirectory = BEEMDiskSpaceDirectory ;
}
virtual ~Workspace(void)
{
Destroy() ;
}
} ;
} // namespace ARE
#endif // ARE_workspace_HXX_INCLUDED
| [
"sakshi0594@gmail.com"
] | sakshi0594@gmail.com |
1211d98e04df930ad0dd7f1b637987cbfdaf3c5a | e7b21e44beddb5a52e94b141a9bb91c33bfb7232 | /ex8/main.cpp | 99c13cd2d320d8f52e5f6d8a12a19d88191748b7 | [] | no_license | tommasomartini/learn_cpp_libraries | ca940d266967a5ccdef0a37499d4504c10709a9b | aedd7e62cbd0a31afa7740c005bb585e8b8345d9 | refs/heads/master | 2020-09-21T07:36:11.270994 | 2019-12-03T22:37:41 | 2019-12-03T22:37:41 | 224,727,199 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 188 | cpp | #include <iostream>
#include "greet.hpp"
using namespace std;
int main() {
string name = "World";
string greetings = greet(name);
cout << greetings << endl;
return 0;
}
| [
"2669009+tommasomartini@users.noreply.github.com"
] | 2669009+tommasomartini@users.noreply.github.com |
a772d3bfc88dfd38bf4f3b17f87186897ab2ea64 | 33392bbfbc4abd42b0c67843c7c6ba9e0692f845 | /security/L1/tests/ecb/aes256enc/test.hpp | a9e889e22d5bd5f80308a5abb0c6ed9a3172c7f9 | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | Xilinx/Vitis_Libraries | bad9474bf099ed288418430f695572418c87bc29 | 2e6c66f83ee6ad21a7c4f20d6456754c8e522995 | refs/heads/main | 2023-07-20T09:01:16.129113 | 2023-06-08T08:18:19 | 2023-06-08T08:18:19 | 210,433,135 | 785 | 371 | Apache-2.0 | 2023-07-06T21:35:46 | 2019-09-23T19:13:46 | C++ | UTF-8 | C++ | false | false | 921 | hpp | /*
* Copyright 2019 Xilinx, Inc.
*
* 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 _TEST_HPP_
#define _TEST_HPP_
#include <ap_int.h>
#include "hls_stream.h"
void test(hls::stream<ap_uint<128> >& plaintext,
hls::stream<bool>& plaintext_e,
hls::stream<ap_uint<256> >& cipherkey,
hls::stream<ap_uint<128> >& ciphertext,
hls::stream<bool>& ciphertext_e);
#endif
| [
"sdausr@xilinx.com"
] | sdausr@xilinx.com |
bd1d47a75c233e4995d71f671e1cf5523e874513 | 38c10c01007624cd2056884f25e0d6ab85442194 | /media/base/fake_demuxer_stream.cc | fab0396cf582e7cad46670ea5e3812dc31d2bfbf | [
"BSD-3-Clause"
] | permissive | zenoalbisser/chromium | 6ecf37b6c030c84f1b26282bc4ef95769c62a9b2 | e71f21b9b4b9b839f5093301974a45545dad2691 | refs/heads/master | 2022-12-25T14:23:18.568575 | 2016-07-14T21:49:52 | 2016-07-23T08:02:51 | 63,980,627 | 0 | 2 | BSD-3-Clause | 2022-12-12T12:43:41 | 2016-07-22T20:14:04 | null | UTF-8 | C++ | false | false | 6,677 | cc | // Copyright (c) 2013 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 "media/base/fake_demuxer_stream.h"
#include <vector>
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/single_thread_task_runner.h"
#include "base/thread_task_runner_handle.h"
#include "media/base/bind_to_current_loop.h"
#include "media/base/decoder_buffer.h"
#include "media/base/media_util.h"
#include "media/base/test_helpers.h"
#include "media/base/timestamp_constants.h"
#include "media/base/video_frame.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
namespace media {
const int kStartTimestampMs = 0;
const int kDurationMs = 30;
const int kStartWidth = 320;
const int kStartHeight = 240;
const int kWidthDelta = 4;
const int kHeightDelta = 3;
const uint8 kKeyId[] = { 0x00, 0x01, 0x02, 0x03 };
const uint8 kIv[] = {
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
FakeDemuxerStream::FakeDemuxerStream(int num_configs,
int num_buffers_in_one_config,
bool is_encrypted)
: task_runner_(base::ThreadTaskRunnerHandle::Get()),
num_configs_(num_configs),
num_buffers_in_one_config_(num_buffers_in_one_config),
config_changes_(num_configs > 1),
is_encrypted_(is_encrypted),
read_to_hold_(-1) {
DCHECK_GT(num_configs, 0);
DCHECK_GT(num_buffers_in_one_config, 0);
Initialize();
UpdateVideoDecoderConfig();
}
FakeDemuxerStream::~FakeDemuxerStream() {}
void FakeDemuxerStream::Initialize() {
DCHECK_EQ(-1, read_to_hold_);
num_configs_left_ = num_configs_;
num_buffers_left_in_current_config_ = num_buffers_in_one_config_;
num_buffers_returned_ = 0;
current_timestamp_ = base::TimeDelta::FromMilliseconds(kStartTimestampMs);
duration_ = base::TimeDelta::FromMilliseconds(kDurationMs);
splice_timestamp_ = kNoTimestamp();
next_coded_size_ = gfx::Size(kStartWidth, kStartHeight);
next_read_num_ = 0;
}
void FakeDemuxerStream::Read(const ReadCB& read_cb) {
DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK(read_cb_.is_null());
read_cb_ = BindToCurrentLoop(read_cb);
if (read_to_hold_ == next_read_num_)
return;
DCHECK(read_to_hold_ == -1 || read_to_hold_ > next_read_num_);
DoRead();
}
AudioDecoderConfig FakeDemuxerStream::audio_decoder_config() {
DCHECK(task_runner_->BelongsToCurrentThread());
NOTREACHED();
return AudioDecoderConfig();
}
VideoDecoderConfig FakeDemuxerStream::video_decoder_config() {
DCHECK(task_runner_->BelongsToCurrentThread());
return video_decoder_config_;
}
// TODO(xhwang): Support audio if needed.
DemuxerStream::Type FakeDemuxerStream::type() const {
DCHECK(task_runner_->BelongsToCurrentThread());
return VIDEO;
}
bool FakeDemuxerStream::SupportsConfigChanges() {
return config_changes_;
}
VideoRotation FakeDemuxerStream::video_rotation() {
return VIDEO_ROTATION_0;
}
void FakeDemuxerStream::HoldNextRead() {
DCHECK(task_runner_->BelongsToCurrentThread());
read_to_hold_ = next_read_num_;
}
void FakeDemuxerStream::HoldNextConfigChangeRead() {
DCHECK(task_runner_->BelongsToCurrentThread());
// Set |read_to_hold_| to be the next config change read.
read_to_hold_ = next_read_num_ + num_buffers_in_one_config_ -
next_read_num_ % (num_buffers_in_one_config_ + 1);
}
void FakeDemuxerStream::SatisfyRead() {
DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK_EQ(read_to_hold_, next_read_num_);
DCHECK(!read_cb_.is_null());
read_to_hold_ = -1;
DoRead();
}
void FakeDemuxerStream::SatisfyReadAndHoldNext() {
DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK_EQ(read_to_hold_, next_read_num_);
DCHECK(!read_cb_.is_null());
++read_to_hold_;
DoRead();
}
void FakeDemuxerStream::Reset() {
read_to_hold_ = -1;
if (!read_cb_.is_null())
base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
}
void FakeDemuxerStream::SeekToStart() {
Reset();
Initialize();
}
void FakeDemuxerStream::UpdateVideoDecoderConfig() {
const gfx::Rect kVisibleRect(kStartWidth, kStartHeight);
video_decoder_config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
PIXEL_FORMAT_YV12, COLOR_SPACE_UNSPECIFIED,
next_coded_size_, kVisibleRect,
next_coded_size_, EmptyExtraData(),
is_encrypted_);
next_coded_size_.Enlarge(kWidthDelta, kHeightDelta);
}
void FakeDemuxerStream::DoRead() {
DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK(!read_cb_.is_null());
next_read_num_++;
if (num_buffers_left_in_current_config_ == 0) {
// End of stream.
if (num_configs_left_ == 0) {
base::ResetAndReturn(&read_cb_).Run(kOk,
DecoderBuffer::CreateEOSBuffer());
return;
}
// Config change.
num_buffers_left_in_current_config_ = num_buffers_in_one_config_;
UpdateVideoDecoderConfig();
base::ResetAndReturn(&read_cb_).Run(kConfigChanged, NULL);
return;
}
scoped_refptr<DecoderBuffer> buffer = CreateFakeVideoBufferForTest(
video_decoder_config_, current_timestamp_, duration_);
// TODO(xhwang): Output out-of-order buffers if needed.
if (is_encrypted_) {
buffer->set_decrypt_config(scoped_ptr<DecryptConfig>(
new DecryptConfig(std::string(kKeyId, kKeyId + arraysize(kKeyId)),
std::string(kIv, kIv + arraysize(kIv)),
std::vector<SubsampleEntry>())));
}
buffer->set_timestamp(current_timestamp_);
buffer->set_duration(duration_);
buffer->set_splice_timestamp(splice_timestamp_);
current_timestamp_ += duration_;
num_buffers_left_in_current_config_--;
if (num_buffers_left_in_current_config_ == 0)
num_configs_left_--;
num_buffers_returned_++;
base::ResetAndReturn(&read_cb_).Run(kOk, buffer);
}
FakeDemuxerStreamProvider::FakeDemuxerStreamProvider(
int num_video_configs,
int num_video_buffers_in_one_config,
bool is_video_encrypted)
: fake_video_stream_(num_video_configs,
num_video_buffers_in_one_config,
is_video_encrypted) {
}
FakeDemuxerStreamProvider::~FakeDemuxerStreamProvider() {
}
DemuxerStream* FakeDemuxerStreamProvider::GetStream(DemuxerStream::Type type) {
if (type == DemuxerStream::Type::AUDIO)
return nullptr;
return &fake_video_stream_;
};
} // namespace media
| [
"zeno.albisser@hemispherian.com"
] | zeno.albisser@hemispherian.com |
0039964e30c0f2c45c0d21a6688927e19e65bf1b | 600df3590cce1fe49b9a96e9ca5b5242884a2a70 | /third_party/WebKit/Source/platform/audio/AudioResamplerKernel.cpp | b400b1cbb4fa5c534340653bd0a68b093019c6f4 | [
"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 | metux/chromium-suckless | efd087ba4f4070a6caac5bfbfb0f7a4e2f3c438a | 72a05af97787001756bae2511b7985e61498c965 | refs/heads/orig | 2022-12-04T23:53:58.681218 | 2017-04-30T10:59:06 | 2017-04-30T23:35:58 | 89,884,931 | 5 | 3 | BSD-3-Clause | 2022-11-23T20:52:53 | 2017-05-01T00:09:08 | null | UTF-8 | C++ | false | false | 5,154 | cpp | /*
* Copyright (C) 2010, 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:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
#include "platform/audio/AudioResamplerKernel.h"
#include "platform/audio/AudioResampler.h"
#include "wtf/MathExtras.h"
namespace blink {
const size_t AudioResamplerKernel::MaxFramesToProcess = 128;
AudioResamplerKernel::AudioResamplerKernel(AudioResampler* resampler)
: m_resampler(resampler),
// The buffer size must be large enough to hold up to two extra sample
// frames for the linear interpolation.
m_sourceBuffer(
2 + static_cast<int>(MaxFramesToProcess * AudioResampler::MaxRate)),
m_virtualReadIndex(0.0),
m_fillIndex(0) {
m_lastValues[0] = 0.0f;
m_lastValues[1] = 0.0f;
}
float* AudioResamplerKernel::getSourcePointer(
size_t framesToProcess,
size_t* numberOfSourceFramesNeededP) {
ASSERT(framesToProcess <= MaxFramesToProcess);
// Calculate the next "virtual" index. After process() is called,
// m_virtualReadIndex will equal this value.
double nextFractionalIndex = m_virtualReadIndex + framesToProcess * rate();
// Because we're linearly interpolating between the previous and next sample
// we need to round up so we include the next sample.
int endIndex = static_cast<int>(nextFractionalIndex +
1.0); // round up to next integer index
// Determine how many input frames we'll need.
// We need to fill the buffer up to and including endIndex (so add 1) but
// we've already buffered m_fillIndex frames from last time.
size_t framesNeeded = 1 + endIndex - m_fillIndex;
if (numberOfSourceFramesNeededP)
*numberOfSourceFramesNeededP = framesNeeded;
// Do bounds checking for the source buffer.
bool isGood = m_fillIndex < m_sourceBuffer.size() &&
m_fillIndex + framesNeeded <= m_sourceBuffer.size();
ASSERT(isGood);
if (!isGood)
return 0;
return m_sourceBuffer.data() + m_fillIndex;
}
void AudioResamplerKernel::process(float* destination, size_t framesToProcess) {
ASSERT(framesToProcess <= MaxFramesToProcess);
float* source = m_sourceBuffer.data();
double rate = this->rate();
rate = clampTo(rate, 0.0, AudioResampler::MaxRate);
// Start out with the previous saved values (if any).
if (m_fillIndex > 0) {
source[0] = m_lastValues[0];
source[1] = m_lastValues[1];
}
// Make a local copy.
double virtualReadIndex = m_virtualReadIndex;
// Sanity check source buffer access.
ASSERT(framesToProcess > 0);
ASSERT(virtualReadIndex >= 0 &&
1 + static_cast<unsigned>(virtualReadIndex +
(framesToProcess - 1) * rate) <
m_sourceBuffer.size());
// Do the linear interpolation.
int n = framesToProcess;
while (n--) {
unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
double interpolationFactor = virtualReadIndex - readIndex;
double sample1 = source[readIndex];
double sample2 = source[readIndex + 1];
double sample =
(1.0 - interpolationFactor) * sample1 + interpolationFactor * sample2;
*destination++ = static_cast<float>(sample);
virtualReadIndex += rate;
}
// Save the last two sample-frames which will later be used at the beginning
// of the source buffer the next time around.
int readIndex = static_cast<int>(virtualReadIndex);
m_lastValues[0] = source[readIndex];
m_lastValues[1] = source[readIndex + 1];
m_fillIndex = 2;
// Wrap the virtual read index back to the start of the buffer.
virtualReadIndex -= readIndex;
// Put local copy back into member variable.
m_virtualReadIndex = virtualReadIndex;
}
void AudioResamplerKernel::reset() {
m_virtualReadIndex = 0.0;
m_fillIndex = 0;
m_lastValues[0] = 0.0f;
m_lastValues[1] = 0.0f;
}
double AudioResamplerKernel::rate() const {
return m_resampler->rate();
}
} // namespace blink
| [
"enrico.weigelt@gr13.net"
] | enrico.weigelt@gr13.net |
4377a63f6ee2e31b8e41a32565ba6f1f86d5bdaa | 88226b0ad9605a51b5f63d0fad72bca0c33d7e2b | /Sesi 1/4_looping for.cpp | b6c3c219ff66f2d1d42bc0ef09f9bc2ba52679fb | [] | no_license | AkhdanFirdaus/belajarCpp | a944eeba9439163dbc387dcd742ee07c4ce1ad70 | 7f0b39c925f224d0792f49142706588b1351b16f | refs/heads/master | 2022-11-11T14:46:06.950866 | 2020-06-30T08:48:56 | 2020-06-30T08:48:56 | 276,042,792 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 472 | cpp | #include <iostream>
using namespace std;
int main()
{
int i, n;
float rata, jumlah;
int data[10];
jumlah = 0;
cout << "masukan jumlah array :";
cin >> n;
for (i = 0; i < n; i++)
{
cout << "masukan data ke- " << i + 1 << ":";
cin >> data[i];
jumlah = jumlah + data[i];
}
rata = jumlah / n;
cout << " Jumlah ke- " << i << "data diatas adalah : " << jumlah << endl;
cout << "Rata-rata ke- " << i << " data diatas adalah : " << rata;
system("pause");
} | [
"akhdan.musyaffa.firdaus@gmail.com"
] | akhdan.musyaffa.firdaus@gmail.com |
63d6e1d8cfea8049230f94767a9162497a145699 | 5f7bfc86d39f4eba96d2eac2d23d4be5da95482b | /ipee/iPeeGamer/stdafx.cpp | 5dfd6750270a2098b8d3f013639f7637d5f98254 | [] | no_license | syagev/ipee | 4432810662340d5cac40adee8ad4beb64eaec496 | 4d2013b179f564189ac0b23b326443167214e469 | refs/heads/master | 2021-01-23T14:04:23.532011 | 2009-10-16T15:26:58 | 2009-10-16T15:26:58 | 32,187,660 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 209 | cpp | // stdafx.cpp : source file that includes just the standard includes
// iPeeGamer.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
| [
"syagev@e8544548-9470-11de-a998-73bdc75c5f85"
] | syagev@e8544548-9470-11de-a998-73bdc75c5f85 |
5a85d8da5f14cc5b1d68a111c33bc2efd3537141 | a9f0e738c922d3566b4a1bb664fe7a2dbbc9f473 | /Chess/mesh.h | 80d55ffb65da4fabd0445d2257f2baa80dc68503 | [] | no_license | Code-Guy/Chess3D | b9943b2569ba543496479cafd92709703f1a5f9c | 55b7691e7d01bccbe2d0f9dd24001ffde9e902df | refs/heads/master | 2021-01-22T18:10:31.757166 | 2017-01-12T07:17:03 | 2017-01-12T07:17:03 | 35,487,585 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,467 | h | #ifndef _MESH_H
#define _MESH_H
#include "octree.h"
#include "ork/render/FrameBuffer.h"
#define MAX_ID_LEN 50
#define MAX_STRING_LEN 1000
struct Material
{
ork::vec3f ambientColor;
ork::vec3f diffuseColor;
ork::vec3f specularColor;
Material(ork::vec3f ambientColor = ork::vec3f(0.5, 0.5, 0.5),
ork::vec3f diffuseColor = ork::vec3f(0.5, 0.5, 0.5),
ork::vec3f specularColor = ork::vec3f(0.5, 0.5, 0.5))
: ambientColor(ambientColor), diffuseColor(diffuseColor), specularColor(specularColor)
{
}
};
class OrkMesh
{
public:
OrkMesh(ork::ptr< ork::Mesh<V_UV_N_T_B, unsigned int> > mesh, Material material, AABB boundAABB, OctreeNode *root,
ork::ptr< ork::Texture2D > diffuseTexture = NULL, ork::ptr< ork::Texture2D > normalTexture = NULL, ork::ptr< ork::Texture2D > specularTexture = NULL, ork::ptr< ork::Texture2D > ambientTexture = NULL,
ork::vec3f translate = ork::vec3f::ZERO, ork::vec3f rotate = ork::vec3f::ZERO, ork::vec3f scale = ork::vec3f(1.0, 1.0, 1.0));
~OrkMesh();
friend ork::mat4f CalcModelMatrix(ork::vec3f translate = ork::vec3f::ZERO, ork::vec3f rotate = ork::vec3f::ZERO, ork::vec3f scale = ork::vec3f(1.0, 1.0, 1.0));
friend void CalcTB(ork::vec3f &T, ork::vec3f &B, const Face &face);
//ork::ptr< ork::Mesh<V_UV_N, unsigned int> > mesh;
ork::ptr< ork::Mesh<V_UV_N_T_B, unsigned int> > mesh;//normal mapping mesh
Material material;
ork::vec3f translate;
ork::vec3f rotate;
ork::vec3f scale;
AABB boundAABB;
OctreeNode *root;
ork::ptr< ork::Texture2D > diffuseTexture;//ๆผซๅๅฐ่ดดๅพ
ork::ptr< ork::Texture2D > normalTexture;//ๆณๅ่ดดๅพ
ork::ptr< ork::Texture2D > specularTexture;//้้ขๅๅฐ่ดดๅพ
ork::ptr< ork::Texture2D > ambientTexture;//้้ขๅๅฐ่ดดๅพ
};
class ObjMesh
{
public:
ObjMesh();
~ObjMesh();
void CalcNormal();//่ฎก็ฎmesh็ๆฏไธช้ข็ๆณๅ
AABB CalcAABB();//่ฎก็ฎAABBๅ
ๅด็
void CreateOctree(OctreeNode *root);//่ฎก็ฎๅ
ซๅๆ
AABB boundAABB;
void Clear();
std::vector<Face> faces;//ๆๆ็้ข
char ID[MAX_ID_LEN];//็ผๅท๏ผOBJๆไปถไธญ็group
char MID[MAX_ID_LEN];//materialๆ่ดจID
string diffuseTexName;//ๆผซๅๅฐ่ดดๅพๆไปถๅ็งฐ
string ambientTexName;//็ฏๅข่ดดๅพๆไปถๅ็งฐ
string specularTexName;//้้ขๅๅฐ่ดดๅพๆไปถๅ็งฐ
string normalTexName;//ๆณๅ่ดดๅพๆไปถๅ็งฐ
Material material;//ๆ่ดจ
static std::vector<ObjMesh>::iterator GetObjMeshWithMID(std::vector<ObjMesh> &objMeshes, const char *MID);
};
#endif //_MESH_H | [
"1964875003@qq.com"
] | 1964875003@qq.com |
f5ecc9d28cc26e6745376115ac7be6339cc7464d | 3ef16236cc4566b03328552843b28adde7389612 | /chromeos/services/multidevice_setup/global_state_feature_manager.h | a1ab9434afebf5e303f2c8d0787e24701fda559a | [
"BSD-3-Clause"
] | permissive | moteesh-in2tive/chromium | c5962834c8218ba607846ce59d0ba008be00fe2b | e1e495b29e1178a451f65980a6c4ae017c34dc94 | refs/heads/main | 2023-09-05T00:46:48.898998 | 2021-11-23T19:52:34 | 2021-11-23T19:52:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,568 | h | // 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.
#ifndef CHROMEOS_SERVICES_MULTIDEVICE_SETUP_GLOBAL_STATE_FEATURE_MANAGER_H_
#define CHROMEOS_SERVICES_MULTIDEVICE_SETUP_GLOBAL_STATE_FEATURE_MANAGER_H_
namespace chromeos {
namespace multidevice_setup {
// Manages the state of a feature whose host enabled state is synced across
// all connected devices. The global host enabled state will be used to
// determine whether the feature is enabled on this client device.
// Such features are different from normal features where the host enabled state
// is solely set by the host device, and a local enabled state is used to
// control whetether the feature is enabled on this client device.
class GlobalStateFeatureManager {
public:
virtual ~GlobalStateFeatureManager() = default;
GlobalStateFeatureManager(const GlobalStateFeatureManager&) = delete;
GlobalStateFeatureManager& operator=(const GlobalStateFeatureManager&) =
delete;
// Attempts to enable/disable the managed feature on the backend for the host
// device that is synced at the time SetIsFeatureEnabled is called.
virtual void SetIsFeatureEnabled(bool enabled) = 0;
// Returns whether the managed feature is enabled/disabled.
virtual bool IsFeatureEnabled() = 0;
protected:
GlobalStateFeatureManager() = default;
};
} // namespace multidevice_setup
} // namespace chromeos
#endif // CHROMEOS_SERVICES_MULTIDEVICE_SETUP_GLOBAL_STATE_FEATURE_MANAGER_H_
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
9385a5d7eb4e4d5be84a56193708db831207bc68 | 11c6060e56674d8b97db27c3067ec3ef9e7510a6 | /mfc/NexusCrypt/stdafx.h | 95c529ea03cafaf0f2a350a58383e93d0ea05ecb | [] | no_license | nexuspecial/NexusCrypt | b74554a0a27b00e8f50be2876fe172aaa21a1750 | 90409f39b25ecc0845a2192b6f57b07906d58853 | refs/heads/master | 2020-12-02T07:57:57.431380 | 2017-07-18T05:09:51 | 2017-07-18T05:09:51 | 96,754,023 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 2,405 | h |
// stdafx.h : ์์ฃผ ์ฌ์ฉํ์ง๋ง ์์ฃผ ๋ณ๊ฒฝ๋์ง๋ ์๋
// ํ์ค ์์คํ
ํฌํจ ํ์ผ ๋ฐ ํ๋ก์ ํธ ๊ด๋ จ ํฌํจ ํ์ผ์ด
// ๋ค์ด ์๋ ํฌํจ ํ์ผ์
๋๋ค.
#pragma once
#ifndef VC_EXTRALEAN
#define VC_EXTRALEAN // ๊ฑฐ์ ์ฌ์ฉ๋์ง ์๋ ๋ด์ฉ์ Windows ํค๋์์ ์ ์ธํฉ๋๋ค.
#endif
#include "targetver.h"
#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // ์ผ๋ถ CString ์์ฑ์๋ ๋ช
์์ ์ผ๋ก ์ ์ธ๋ฉ๋๋ค.
// MFC์ ๊ณตํต ๋ถ๋ถ๊ณผ ๋ฌด์ ๊ฐ๋ฅํ ๊ฒฝ๊ณ ๋ฉ์์ง์ ๋ํ ์จ๊ธฐ๊ธฐ๋ฅผ ํด์ ํฉ๋๋ค.
#define _AFX_ALL_WARNINGS
#include <afxwin.h> // MFC ํต์ฌ ๋ฐ ํ์ค ๊ตฌ์ฑ ์์์
๋๋ค.
#include <afxext.h> // MFC ํ์ฅ์
๋๋ค.
#include <afxdisp.h> // MFC ์๋ํ ํด๋์ค์
๋๋ค.
#ifndef _AFX_NO_OLE_SUPPORT
#include <afxdtctl.h> // Internet Explorer 4 ๊ณต์ฉ ์ปจํธ๋กค์ ๋ํ MFC ์ง์์
๋๋ค.
#endif
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h> // Windows ๊ณต์ฉ ์ปจํธ๋กค์ ๋ํ MFC ์ง์์
๋๋ค.
#endif // _AFX_NO_AFXCMN_SUPPORT
#include <afxcontrolbars.h> // MFC์ ๋ฆฌ๋ณธ ๋ฐ ์ปจํธ๋กค ๋ง๋ ์ง์
#ifdef _UNICODE
#if defined _M_IX86
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
#elif defined _M_X64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#else
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#endif
#endif
#include <vector>
#include <map>
#include <iostream>
#include <string>
#include <fstream>
#include <boost/smart_ptr.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/foreach.hpp>
#include <boost/algorithm/hex.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/endian/conversion.hpp>
#pragma comment(lib, "libcrypto.lib")
#pragma comment(lib, "libssl.lib")
#include <openssl/evp.h>
#include <openssl/rand.h>
enum WinTimerID
{
Timer_ClearClipboard = 0,
}; | [
"trade1532@gmail.com"
] | trade1532@gmail.com |
b2a578698057fe6e2e40c5c2cc4c22ad807c3b24 | 4315eec5d1ceff992286d62eba85b9bd45f878e3 | /DoorRandomizer/GUI/Log.h | 4fed0d670c052904f1d65b474ca2dac664145029 | [
"MIT"
] | permissive | YonicDev/mpdr-wx | 370d256842618558f4a7d9dd4a5b31689061135d | ff7cbf2f6997b09b89b3acbcaebdfc0723032c35 | refs/heads/master | 2022-04-10T04:44:35.203788 | 2019-12-24T14:51:46 | 2019-12-24T14:51:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 409 | h | #pragma once
#include <wx/wx.h>
#include <wx/log.h>
#include <wx/listctrl.h>
#include <map>
class CLogger : public wxLog
{
public:
CLogger(wxListCtrl* stack, wxStaticText* line);
~CLogger();
private:
virtual void DoLogRecord(wxLogLevel level, const wxString &msg, const wxLogRecordInfo &info);
std::map<unsigned long, const char*> log_level_labels;
wxListCtrl* log_stack;
wxStaticText* log_line;
};
| [
"yonicstudios@gmail.com"
] | yonicstudios@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.