/elec/propeller-clock

To get this branch, use:
bzr branch http://bzr.ed.am/elec/propeller-clock

« back to all changes in this revision

Viewing changes to src/utility/limits

  • Committer: edam
  • Date: 2012-02-25 01:31:43 UTC
  • Revision ID: tim@ed.am-20120225013143-9fet2y2d3fjlrwez
added ulibc

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/utility/limits
 
1
/*      Copyright (C) 2006 Garrett A. Kajmowicz
 
2
        This file is part of the uClibc++ Library.
 
3
 
 
4
        This library is free software; you can redistribute it and/or
 
5
        modify it under the terms of the GNU Lesser General Public
 
6
        License as published by the Free Software Foundation; either
 
7
        version 2.1 of the License, or (at your option) any later version.
 
8
 
 
9
        This library is distributed in the hope that it will be useful,
 
10
        but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
        Lesser General Public License for more details.
 
13
 
 
14
        You should have received a copy of the GNU Lesser General Public
 
15
        License along with this library; if not, write to the Free Software
 
16
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
*/
 
18
 
 
19
#include <climits>
 
20
 
 
21
#ifndef __STD_HEADER_LIMITS
 
22
#define __STD_HEADER_LIMITS 1
 
23
 
 
24
// Yeah, yeah we know
 
25
//#warning limits header is nowhere complete or accurate
 
26
 
 
27
#pragma GCC visibility push(default)
 
28
 
 
29
namespace std{
 
30
 
 
31
enum float_round_style{
 
32
        round_indeterminate             =-1,
 
33
        round_toward_zero               = 0,
 
34
        round_to_nearest                = 1,
 
35
        round_toward_infinity           = 2,
 
36
        round_toward_neg_infinity       = 3
 
37
};
 
38
 
 
39
template <int bitsize> struct __bits_to_base_10{
 
40
        static const int size = -1;
 
41
};
 
42
template <> struct __bits_to_base_10<7>{
 
43
        static const int size = 2;
 
44
};
 
45
template <> struct __bits_to_base_10<8>{
 
46
        static const int size = 2;
 
47
};
 
48
template <> struct __bits_to_base_10<9>{
 
49
        static const int size = 2;
 
50
};
 
51
template <> struct __bits_to_base_10<10>{
 
52
        static const int size = 3;
 
53
};
 
54
template <> struct __bits_to_base_10<15>{
 
55
        static const int size = 4;
 
56
};
 
57
template <> struct __bits_to_base_10<16>{
 
58
        static const int size = 4;
 
59
};
 
60
template <> struct __bits_to_base_10<17>{
 
61
        static const int size = 5;
 
62
};
 
63
template <> struct __bits_to_base_10<18>{
 
64
        static const int size = 5;
 
65
};
 
66
template <> struct __bits_to_base_10<31>{
 
67
        static const int size = 9;
 
68
};
 
69
template <> struct __bits_to_base_10<32>{
 
70
        static const int size = 9;
 
71
};
 
72
template <> struct __bits_to_base_10<35>{
 
73
        static const int size = 10;
 
74
};
 
75
template <> struct __bits_to_base_10<36>{
 
76
        static const int size = 10;
 
77
};
 
78
template <> struct __bits_to_base_10<63>{
 
79
        static const int size = 18;
 
80
};
 
81
template <> struct __bits_to_base_10<64>{
 
82
        static const int size = 19;
 
83
};
 
84
template <> struct __bits_to_base_10<71>{
 
85
        static const int size = 21;
 
86
};
 
87
template <> struct __bits_to_base_10<72>{
 
88
        static const int size = 21;
 
89
};
 
90
template <> struct __bits_to_base_10<79>{
 
91
        static const int size = 23;
 
92
};
 
93
template <> struct __bits_to_base_10<80>{
 
94
        static const int size = 24;
 
95
};
 
96
template <> struct __bits_to_base_10<127>{
 
97
        static const int size = 38;
 
98
};
 
99
template <> struct __bits_to_base_10<128>{
 
100
        static const int size = 38;
 
101
};
 
102
 
 
103
 
 
104
 
 
105
 
 
106
 
 
107
 
 
108
template <class T> class numeric_limits {
 
109
public:
 
110
        // General -- meaningful for all specializations.
 
111
 
 
112
        static const bool is_specialized = false;
 
113
        static T min();
 
114
        static T max();
 
115
        static const int radix;
 
116
        static const int digits;
 
117
        static const int digits10;
 
118
        static const bool is_signed;
 
119
        static const bool is_integer;
 
120
        static const bool is_exact;
 
121
        static const bool traps;
 
122
        static const bool is_modulo;
 
123
        static const bool is_bounded;
 
124
 
 
125
        // Floating point specific.
 
126
 
 
127
        static T epsilon();
 
128
        static T round_error();
 
129
        static const int min_exponent10;
 
130
        static const int max_exponent10;
 
131
        static const int min_exponent;
 
132
 
 
133
        static const int max_exponent;
 
134
        static const bool has_infinity;
 
135
        static const bool has_quiet_NaN;
 
136
        static const bool has_signaling_NaN;
 
137
        static const bool is_iec559;
 
138
        static const bool has_denorm;
 
139
        static const bool tinyness_before;
 
140
        static const float_round_style round_style;
 
141
        static T denorm_min();
 
142
        static T infinity();
 
143
        static T quiet_NaN();
 
144
        static T signaling_NaN();
 
145
};
 
146
 
 
147
template <> class numeric_limits<bool> {
 
148
public:
 
149
        typedef bool T;
 
150
        // General -- meaningful for all specializations.
 
151
        static const bool is_specialized = true;
 
152
        static T min(){
 
153
                return false;
 
154
        }
 
155
        static T max(){
 
156
                return true;
 
157
        }
 
158
        static const int radix = 2;
 
159
        static const int digits = 1;
 
160
        static const int digits10 = 0;
 
161
        static const bool is_signed = false;
 
162
        static const bool is_integer = true;
 
163
        static const bool is_exact = true;
 
164
        static const bool traps = false;
 
165
        static const bool is_modulo = false;
 
166
        static const bool is_bounded = true;
 
167
 
 
168
        // Floating point specific.
 
169
 
 
170
        static T epsilon(){
 
171
                return 0;
 
172
        }
 
173
        static T round_error(){
 
174
                return 0;
 
175
        }
 
176
        static const int min_exponent10 = 0;
 
177
        static const int max_exponent10 = 0;
 
178
        static const int min_exponent = 0;
 
179
 
 
180
        static const int max_exponent = 0;
 
181
        static const bool has_infinity = false;
 
182
        static const bool has_quiet_NaN = false;
 
183
        static const bool has_signaling_NaN = false;
 
184
        static const bool is_iec559 = false;
 
185
        static const bool has_denorm = false;
 
186
        static const bool tinyness_before = false;
 
187
        static const float_round_style round_style = round_indeterminate;
 
188
        static T denorm_min();
 
189
        static T infinity();
 
190
        static T quiet_NaN();
 
191
        static T signaling_NaN();
 
192
};
 
193
 
 
194
template <> class numeric_limits<unsigned char> {
 
195
public:
 
196
        typedef unsigned char T;
 
197
        // General -- meaningful for all specializations.
 
198
        static const bool is_specialized = true;
 
199
        static T min(){
 
200
                return 0;
 
201
        }
 
202
        static T max(){
 
203
                return UCHAR_MAX;
 
204
        }
 
205
        static const int radix = 2;
 
206
        static const int digits = CHAR_BIT;
 
207
        static const int digits10 = __bits_to_base_10<digits>::size;
 
208
        static const bool is_signed = false;
 
209
        static const bool is_integer = true;
 
210
        static const bool is_exact = true;
 
211
        static const bool traps = false;
 
212
        static const bool is_modulo = true;
 
213
        static const bool is_bounded = true;
 
214
 
 
215
        // Floating point specific.
 
216
 
 
217
        static T epsilon(){
 
218
                return 0;
 
219
        }
 
220
        static T round_error(){
 
221
                return 0;
 
222
        }
 
223
        static const int min_exponent10 = 0;
 
224
        static const int max_exponent10 = 0;
 
225
        static const int min_exponent = 0;
 
226
 
 
227
        static const int max_exponent = 0;
 
228
        static const bool has_infinity = false;
 
229
        static const bool has_quiet_NaN = false;
 
230
        static const bool has_signaling_NaN = false;
 
231
        static const bool is_iec559 = false;
 
232
        static const bool has_denorm = false;
 
233
        static const bool tinyness_before = false;
 
234
        static const float_round_style round_style = round_indeterminate;
 
235
        static T denorm_min();
 
236
        static T infinity();
 
237
        static T quiet_NaN();
 
238
        static T signaling_NaN();
 
239
};
 
240
 
 
241
template <> class numeric_limits<signed char> {
 
242
public:
 
243
        typedef signed char T;
 
244
        // General -- meaningful for all specializations.
 
245
        static const bool is_specialized = true;
 
246
        static T min(){
 
247
                return SCHAR_MIN;
 
248
        }
 
249
        static T max(){
 
250
                return SCHAR_MAX;
 
251
        }
 
252
        static const int radix = 2;
 
253
        static const int digits = CHAR_BIT - 1;
 
254
        static const int digits10 = __bits_to_base_10<digits>::size;
 
255
        static const bool is_signed = true;
 
256
        static const bool is_integer = true;
 
257
        static const bool is_exact = true;
 
258
        static const bool traps = false;
 
259
        static const bool is_modulo = true;
 
260
        static const bool is_bounded = true;
 
261
 
 
262
        // Floating point specific.
 
263
 
 
264
        static T epsilon(){
 
265
                return 0;
 
266
        }
 
267
        static T round_error(){
 
268
                return 0;
 
269
        }
 
270
        static const int min_exponent10 = 0;
 
271
        static const int max_exponent10 = 0;
 
272
        static const int min_exponent = 0;
 
273
 
 
274
        static const int max_exponent = 0;
 
275
        static const bool has_infinity = false;
 
276
        static const bool has_quiet_NaN = false;
 
277
        static const bool has_signaling_NaN = false;
 
278
        static const bool is_iec559 = false;
 
279
        static const bool has_denorm = false;
 
280
        static const bool tinyness_before = false;
 
281
        static const float_round_style round_style = round_indeterminate;
 
282
        static T denorm_min();
 
283
        static T infinity();
 
284
        static T quiet_NaN();
 
285
        static T signaling_NaN();
 
286
};
 
287
 
 
288
template <> class numeric_limits<char> {
 
289
public:
 
290
        typedef char T;
 
291
        // General -- meaningful for all specializations.
 
292
        static const bool is_specialized = true;
 
293
        static T min(){
 
294
                return CHAR_MIN;
 
295
        }
 
296
        static T max(){
 
297
                return CHAR_MAX;
 
298
        }
 
299
        static const int radix = 2;
 
300
        static const int digits = (CHAR_MIN != 0) ? CHAR_BIT - 1 : CHAR_BIT;
 
301
        static const int digits10 = __bits_to_base_10<digits>::size;
 
302
        static const bool is_signed = (CHAR_MIN != 0);
 
303
        static const bool is_integer = true;
 
304
        static const bool is_exact = true;
 
305
        static const bool traps = false;
 
306
        static const bool is_modulo = true;
 
307
        static const bool is_bounded = true;
 
308
 
 
309
        // Floating point specific.
 
310
 
 
311
        static T epsilon(){
 
312
                return 0;
 
313
        }
 
314
        static T round_error(){
 
315
                return 0;
 
316
        }
 
317
        static const int min_exponent10 = 0;
 
318
        static const int max_exponent10 = 0;
 
319
        static const int min_exponent = 0;
 
320
 
 
321
        static const int max_exponent = 0;
 
322
        static const bool has_infinity = false;
 
323
        static const bool has_quiet_NaN = false;
 
324
        static const bool has_signaling_NaN = false;
 
325
        static const bool is_iec559 = false;
 
326
        static const bool has_denorm = false;
 
327
        static const bool tinyness_before = false;
 
328
        static const float_round_style round_style = round_indeterminate;
 
329
        static T denorm_min();
 
330
        static T infinity();
 
331
        static T quiet_NaN();
 
332
        static T signaling_NaN();
 
333
};
 
334
 
 
335
template <> class numeric_limits<unsigned short> {
 
336
public:
 
337
        typedef unsigned short T;
 
338
        // General -- meaningful for all specializations.
 
339
        static const bool is_specialized = true;
 
340
        static T min(){
 
341
                return 0;
 
342
        }
 
343
        static T max(){
 
344
                return USHRT_MAX;
 
345
        }
 
346
        static const int radix = 2;
 
347
        static const int digits = CHAR_BIT * sizeof(T);
 
348
        static const int digits10 = __bits_to_base_10<digits>::size;
 
349
        static const bool is_signed = false;
 
350
        static const bool is_integer = true;
 
351
        static const bool is_exact = true;
 
352
        static const bool traps = false;
 
353
        static const bool is_modulo = true;
 
354
        static const bool is_bounded = true;
 
355
 
 
356
        // Floating point specific.
 
357
 
 
358
        static T epsilon(){
 
359
                return 0;
 
360
        }
 
361
        static T round_error(){
 
362
                return 0;
 
363
        }
 
364
        static const int min_exponent10 = 0;
 
365
        static const int max_exponent10 = 0;
 
366
        static const int min_exponent = 0;
 
367
 
 
368
        static const int max_exponent = 0;
 
369
        static const bool has_infinity = false;
 
370
        static const bool has_quiet_NaN = false;
 
371
        static const bool has_signaling_NaN = false;
 
372
        static const bool is_iec559 = false;
 
373
        static const bool has_denorm = false;
 
374
        static const bool tinyness_before = false;
 
375
        static const float_round_style round_style = round_indeterminate;
 
376
        static T denorm_min();
 
377
        static T infinity();
 
378
        static T quiet_NaN();
 
379
        static T signaling_NaN();
 
380
};
 
381
 
 
382
template <> class numeric_limits<signed short> {
 
383
public:
 
384
        typedef signed short T;
 
385
        // General -- meaningful for all specializations.
 
386
        static const bool is_specialized = true;
 
387
        static T min(){
 
388
                return SHRT_MIN;
 
389
        }
 
390
        static T max(){
 
391
                return SHRT_MAX;
 
392
        }
 
393
        static const int radix = 2;
 
394
        static const int digits = CHAR_BIT * sizeof(T);
 
395
        static const int digits10 = __bits_to_base_10<digits>::size;
 
396
        static const bool is_signed = true;
 
397
        static const bool is_integer = true;
 
398
        static const bool is_exact = true;
 
399
        static const bool traps = false;
 
400
        static const bool is_modulo = true;
 
401
        static const bool is_bounded = true;
 
402
 
 
403
        // Floating point specific.
 
404
 
 
405
        static T epsilon(){
 
406
                return 0;
 
407
        }
 
408
        static T round_error(){
 
409
                return 0;
 
410
        }
 
411
        static const int min_exponent10 = 0;
 
412
        static const int max_exponent10 = 0;
 
413
        static const int min_exponent = 0;
 
414
 
 
415
        static const int max_exponent = 0;
 
416
        static const bool has_infinity = false;
 
417
        static const bool has_quiet_NaN = false;
 
418
        static const bool has_signaling_NaN = false;
 
419
        static const bool is_iec559 = false;
 
420
        static const bool has_denorm = false;
 
421
        static const bool tinyness_before = false;
 
422
        static const float_round_style round_style = round_indeterminate;
 
423
        static T denorm_min();
 
424
        static T infinity();
 
425
        static T quiet_NaN();
 
426
        static T signaling_NaN();
 
427
};
 
428
 
 
429
template <> class numeric_limits<unsigned int> {
 
430
public:
 
431
        typedef unsigned int T;
 
432
        // General -- meaningful for all specializations.
 
433
        static const bool is_specialized = true;
 
434
        static T min(){
 
435
                return 0;
 
436
        }
 
437
        static T max(){
 
438
                return UINT_MAX;
 
439
        }
 
440
        static const int radix = 2;
 
441
        static const int digits = CHAR_BIT * sizeof(T);
 
442
        static const int digits10 = __bits_to_base_10<digits>::size;
 
443
        static const bool is_signed = false;
 
444
        static const bool is_integer = true;
 
445
        static const bool is_exact = true;
 
446
        static const bool traps = false;
 
447
        static const bool is_modulo = true;
 
448
        static const bool is_bounded = true;
 
449
 
 
450
        // Floating point specific.
 
451
 
 
452
        static T epsilon(){
 
453
                return 0;
 
454
        }
 
455
        static T round_error(){
 
456
                return 0;
 
457
        }
 
458
        static const int min_exponent10 = 0;
 
459
        static const int max_exponent10 = 0;
 
460
        static const int min_exponent = 0;
 
461
 
 
462
        static const int max_exponent = 0;
 
463
        static const bool has_infinity = false;
 
464
        static const bool has_quiet_NaN = false;
 
465
        static const bool has_signaling_NaN = false;
 
466
        static const bool is_iec559 = false;
 
467
        static const bool has_denorm = false;
 
468
        static const bool tinyness_before = false;
 
469
        static const float_round_style round_style = round_indeterminate;
 
470
        static T denorm_min();
 
471
        static T infinity();
 
472
        static T quiet_NaN();
 
473
        static T signaling_NaN();
 
474
};
 
475
 
 
476
template <> class numeric_limits<signed int> {
 
477
public:
 
478
        typedef signed int T;
 
479
        // General -- meaningful for all specializations.
 
480
        static const bool is_specialized = true;
 
481
        static T min(){
 
482
                return INT_MIN;
 
483
        }
 
484
        static T max(){
 
485
                return INT_MAX;
 
486
        }
 
487
        static const int radix = 2;
 
488
        static const int digits = CHAR_BIT * sizeof(T);
 
489
        static const int digits10 = __bits_to_base_10<digits>::size;
 
490
        static const bool is_signed = true;
 
491
        static const bool is_integer = true;
 
492
        static const bool is_exact = true;
 
493
        static const bool traps = false;
 
494
        static const bool is_modulo = true;
 
495
        static const bool is_bounded = true;
 
496
 
 
497
        // Floating point specific.
 
498
 
 
499
        static T epsilon(){
 
500
                return 0;
 
501
        }
 
502
        static T round_error(){
 
503
                return 0;
 
504
        }
 
505
        static const int min_exponent10 = 0;
 
506
        static const int max_exponent10 = 0;
 
507
        static const int min_exponent = 0;
 
508
 
 
509
        static const int max_exponent = 0;
 
510
        static const bool has_infinity = false;
 
511
        static const bool has_quiet_NaN = false;
 
512
        static const bool has_signaling_NaN = false;
 
513
        static const bool is_iec559 = false;
 
514
        static const bool has_denorm = false;
 
515
        static const bool tinyness_before = false;
 
516
        static const float_round_style round_style = round_indeterminate;
 
517
        static T denorm_min();
 
518
        static T infinity();
 
519
        static T quiet_NaN();
 
520
        static T signaling_NaN();
 
521
};
 
522
 
 
523
template <> class numeric_limits<unsigned long int> {
 
524
public:
 
525
        typedef unsigned long int T;
 
526
        // General -- meaningful for all specializations.
 
527
        static const bool is_specialized = true;
 
528
        static T min(){
 
529
                return 0;
 
530
        }
 
531
        static T max(){
 
532
                return ULONG_MAX;
 
533
        }
 
534
        static const int radix = 2;
 
535
        static const int digits = CHAR_BIT * sizeof(T);
 
536
        static const int digits10 = __bits_to_base_10<digits>::size;
 
537
        static const bool is_signed = false;
 
538
        static const bool is_integer = true;
 
539
        static const bool is_exact = true;
 
540
        static const bool traps = false;
 
541
        static const bool is_modulo = true;
 
542
        static const bool is_bounded = true;
 
543
 
 
544
        // Floating point specific.
 
545
 
 
546
        static T epsilon(){
 
547
                return 0;
 
548
        }
 
549
        static T round_error(){
 
550
                return 0;
 
551
        }
 
552
        static const int min_exponent10 = 0;
 
553
        static const int max_exponent10 = 0;
 
554
        static const int min_exponent = 0;
 
555
 
 
556
        static const int max_exponent = 0;
 
557
        static const bool has_infinity = false;
 
558
        static const bool has_quiet_NaN = false;
 
559
        static const bool has_signaling_NaN = false;
 
560
        static const bool is_iec559 = false;
 
561
        static const bool has_denorm = false;
 
562
        static const bool tinyness_before = false;
 
563
        static const float_round_style round_style = round_indeterminate;
 
564
        static T denorm_min();
 
565
        static T infinity();
 
566
        static T quiet_NaN();
 
567
        static T signaling_NaN();
 
568
};
 
569
 
 
570
template <> class numeric_limits<signed long int> {
 
571
public:
 
572
        typedef signed long int T;
 
573
        // General -- meaningful for all specializations.
 
574
        static const bool is_specialized = true;
 
575
        static T min(){
 
576
                return LONG_MIN;
 
577
        }
 
578
        static T max(){
 
579
                return LONG_MAX;
 
580
        }
 
581
        static const int radix = 2;
 
582
        static const int digits = CHAR_BIT * sizeof(T);
 
583
        static const int digits10 = __bits_to_base_10<digits>::size;
 
584
        static const bool is_signed = true;
 
585
        static const bool is_integer = true;
 
586
        static const bool is_exact = true;
 
587
        static const bool traps = false;
 
588
        static const bool is_modulo = true;
 
589
        static const bool is_bounded = true;
 
590
 
 
591
        // Floating point specific.
 
592
 
 
593
        static T epsilon(){
 
594
                return 0;
 
595
        }
 
596
        static T round_error(){
 
597
                return 0;
 
598
        }
 
599
        static const int min_exponent10 = 0;
 
600
        static const int max_exponent10 = 0;
 
601
        static const int min_exponent = 0;
 
602
 
 
603
        static const int max_exponent = 0;
 
604
        static const bool has_infinity = false;
 
605
        static const bool has_quiet_NaN = false;
 
606
        static const bool has_signaling_NaN = false;
 
607
        static const bool is_iec559 = false;
 
608
        static const bool has_denorm = false;
 
609
        static const bool tinyness_before = false;
 
610
        static const float_round_style round_style = round_indeterminate;
 
611
        static T denorm_min();
 
612
        static T infinity();
 
613
        static T quiet_NaN();
 
614
        static T signaling_NaN();
 
615
};
 
616
 
 
617
template <> class numeric_limits<double> {
 
618
public:
 
619
        typedef double numeric_type;
 
620
 
 
621
        static const bool is_specialized = true;
 
622
        static numeric_type min () { return __DBL_MIN__; }
 
623
        static numeric_type max () { return __DBL_MAX__; }
 
624
        static const int radix = __FLT_RADIX__;
 
625
        static const int digits = __DBL_MANT_DIG__;
 
626
        static const int digits10 = __DBL_DIG__;
 
627
        static const bool is_signed = true;
 
628
        static const bool is_integer = false;
 
629
        static const bool is_exact = false;
 
630
        static const bool traps = false; // this is a guess
 
631
        static const bool is_modulo = false;
 
632
        static const bool is_bounded = true;
 
633
 
 
634
        // Floating point specific.
 
635
 
 
636
        static numeric_type epsilon () { return __DBL_EPSILON__; }
 
637
        static numeric_type round_error () { return 0.5; }
 
638
        static const int min_exponent10 = -1; //How do I properly get this?
 
639
        static const int max_exponent10 = -1; //How do I properly get this?
 
640
        static const int min_exponent   = -1; //How do I properly get this?
 
641
        static const int max_exponent   = -1; //How do I properly get this?
 
642
        static const bool has_infinity  = false; //I don't know, so until I can find out, I'm saying no
 
643
        static const bool has_quiet_NaN = false; //I don't know, so until I can find out, I'm saying no
 
644
        static const bool has_signaling_NaN = false; //I don't know, so until I can find out, I'm saying no
 
645
        static const bool has_denorm = false; //I don't know, so until I can find out, I'm saying no
 
646
 
 
647
        static const bool is_iec559 = false;  //I don't know, so until I can find out, I'm saying no
 
648
        static const bool tinyness_before = false; // more questions
 
649
        static const float_round_style round_style = round_to_nearest; // more questions
 
650
        static numeric_type denorm_min () { return -1; } //How do I properly get this?
 
651
        static numeric_type infinity () { return -1; } //How do I properly get this?
 
652
        static numeric_type quiet_NaN () { return -1; } //How do I properly get this?
 
653
        static numeric_type signaling_NaN () { return -1; } //How do I properly get this?
 
654
};
 
655
 
 
656
 
 
657
 
 
658
 
 
659
 
 
660
}
 
661
 
 
662
#pragma GCC visibility pop
 
663
 
 
664
#endif