Attachment 1050707 Details for Bug 1241978 – Preprocessed source file, bug caused by line 3185

Preprocessed source file, bug caused by line 3185

random.o (text/plain), 56.74 KB, created by Eric Nichols on 2015-07-10 14:36:43 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Eric Nichols

Created: 2015-07-10 14:36:43 UTC

Size: 56.74 KB

patch

obsolete

># 1 "src/random.c"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "src/random.c"
>
>
>
>
>
>
>
># 1 "include/random.h" 1
># 11 "include/random.h"
># 1 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stdint.h" 1 3 4
># 9 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stdint.h" 3 4
># 1 "/usr/arm-none-eabi/include/stdint.h" 1 3 4
># 12 "/usr/arm-none-eabi/include/stdint.h" 3 4
># 1 "/usr/arm-none-eabi/include/machine/_default_types.h" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/arm-none-eabi/include/sys/features.h" 1 3 4
># 9 "/usr/arm-none-eabi/include/machine/_default_types.h" 2 3 4
># 27 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef signed char __int8_t;
>
>typedef unsigned char __uint8_t;
># 41 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef short int __int16_t;
>
>typedef short unsigned int __uint16_t;
># 63 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef long int __int32_t;
>
>typedef long unsigned int __uint32_t;
># 89 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef long long int __int64_t;
>
>typedef long long unsigned int __uint64_t;
># 120 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef signed char __int_least8_t;
>
>typedef unsigned char __uint_least8_t;
># 146 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef short int __int_least16_t;
>
>typedef short unsigned int __uint_least16_t;
># 168 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef long int __int_least32_t;
>
>typedef long unsigned int __uint_least32_t;
># 186 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef long long int __int_least64_t;
>
>typedef long long unsigned int __uint_least64_t;
># 200 "/usr/arm-none-eabi/include/machine/_default_types.h" 3 4
>typedef int __intptr_t;
>
>typedef unsigned int __uintptr_t;
># 13 "/usr/arm-none-eabi/include/stdint.h" 2 3 4
># 1 "/usr/arm-none-eabi/include/sys/_intsup.h" 1 3 4
># 14 "/usr/arm-none-eabi/include/stdint.h" 2 3 4
>
>
>
>
>
>
>typedef __int8_t int8_t ;
>typedef __uint8_t uint8_t ;
>
>
>
>
>typedef __int_least8_t int_least8_t;
>typedef __uint_least8_t uint_least8_t;
>
>
>
>
>typedef __int16_t int16_t ;
>typedef __uint16_t uint16_t ;
>
>
>
>
>typedef __int_least16_t int_least16_t;
>typedef __uint_least16_t uint_least16_t;
>
>
>
>
>typedef __int32_t int32_t ;
>typedef __uint32_t uint32_t ;
>
>
>
>
>typedef __int_least32_t int_least32_t;
>typedef __uint_least32_t uint_least32_t;
>
>
>
>
>typedef __int64_t int64_t ;
>typedef __uint64_t uint64_t ;
>
>
>
>
>typedef __int_least64_t int_least64_t;
>typedef __uint_least64_t uint_least64_t;
># 74 "/usr/arm-none-eabi/include/stdint.h" 3 4
>  typedef int int_fast8_t;
>  typedef unsigned int uint_fast8_t;
># 84 "/usr/arm-none-eabi/include/stdint.h" 3 4
>  typedef int int_fast16_t;
>  typedef unsigned int uint_fast16_t;
># 94 "/usr/arm-none-eabi/include/stdint.h" 3 4
>  typedef int int_fast32_t;
>  typedef unsigned int uint_fast32_t;
># 104 "/usr/arm-none-eabi/include/stdint.h" 3 4
>  typedef long long int int_fast64_t;
>  typedef long long unsigned int uint_fast64_t;
># 153 "/usr/arm-none-eabi/include/stdint.h" 3 4
>  typedef long long int intmax_t;
># 162 "/usr/arm-none-eabi/include/stdint.h" 3 4
>  typedef long long unsigned int uintmax_t;
>
>
>
>
>
>
>typedef __intptr_t intptr_t;
>typedef __uintptr_t uintptr_t;
># 10 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stdint.h" 2 3 4
># 12 "include/random.h" 2
># 1 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stdfix.h" 1 3 4
># 13 "include/random.h" 2
># 56 "include/random.h"
>uint32_t mars_kiss32 (void);
># 72 "include/random.h"
>uint32_t mars_kiss64_simp (void);
># 89 "include/random.h"
>void init_WELL1024a_simp (void);
>
>
>uint32_t WELL1024a_simp (void);
>
>
>
>
>
>
>
>typedef uint32_t mars_kiss64_seed_t [4];
>
>
>void validate_mars_kiss64_seed (mars_kiss64_seed_t seed);
>
>
>uint32_t mars_kiss64_seed (mars_kiss64_seed_t seed);
>
>
>
>
>typedef uint32_t WELL1024a_seed_t [33];
>
>
>void validate_WELL1024a_seed (WELL1024a_seed_t seed);
>
>
>
>uint32_t WELL1024a_seed (WELL1024a_seed_t seed);
># 141 "include/random.h"
>typedef uint32_t (*uniform_rng)(uint32_t*);
>
>
>
>
>
>_Accum exponential_dist_variate (uniform_rng uni_rng, uint32_t* seed_arg);
>
>
>
>
>_Accum gaussian_dist_variate (uniform_rng uni_rng, uint32_t* seed_arg);
>
>
>
>
>uint32_t poisson_dist_variate (uniform_rng uni_rng,
>                               uint32_t* seed_arg,
>                               _Accum lambda);
>
>
>
>uint32_t poisson_dist_variate_exp_minus_lambda
>             (uniform_rng uni_rng,
>              uint32_t* seed_arg,
>              unsigned long _Fract exp_minus_lambda);
># 9 "src/random.c" 2
>
># 1 "include/stdfix-full-iso.h" 1
># 34 "include/stdfix-full-iso.h"
># 1 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stdbool.h" 1 3 4
># 35 "include/stdfix-full-iso.h" 2
># 1 "include/arm_acle.h" 1
># 14 "include/arm_acle.h"
># 1 "include/arm_acle_gcc.h" 1
># 32 "include/arm_acle_gcc.h"
># 1 "include/static-assert.h" 1
># 33 "include/arm_acle_gcc.h" 2
># 1 "include/cmsis.h" 1
># 16 "include/cmsis.h"
>static inline uint32_t __get_CONTROL (void)
>{
>    uint32_t r;
>
>    asm volatile ("mrs %[r], cpsr" : [r] "=r" (r) : : "cc");
>
>    return (r);
>}
>
>static inline void __set_CONTROL (uint32_t r)
>{ asm volatile ("msr cpsr_f, %[r]" : : [r] "r" (r) : "cc"); }
># 34 "include/arm_acle_gcc.h" 2
># 467 "include/arm_acle_gcc.h"
>static inline void __ARM_ACLE_nop (void)
>{ asm volatile ("nop" : : : "cc"); }
>
>
>
>static inline void __wfi (void)
>
>{ asm volatile ("mcr p15, 0, r0, c7, c0, 4" : : : "cc"); }
># 494 "include/arm_acle_gcc.h"
>static inline void __wfe (void)
>{ __ARM_ACLE_nop(); }
># 504 "include/arm_acle_gcc.h"
>static inline void __sev (void)
>{ __ARM_ACLE_nop(); }
>
>
>
>
>
>
>
>static inline void __sevl (void)
>{ __ARM_ACLE_nop(); }
>
>
>
>
>
>
>
>static inline void __yield (void)
>{ __ARM_ACLE_nop(); }
>
>
>
>
>
>
>
>static inline void __dbg ( unsigned int n)
>{
>    if (n == n)
>        __ARM_ACLE_nop();
>}
># 548 "include/arm_acle_gcc.h"
>static inline uint32_t __swp_word (uint32_t x, volatile void* addr)
># 558 "include/arm_acle_gcc.h"
>{
>    register uint32_t r = 0;
>
>    asm volatile ("swp %[r], %[x], [ %[addr] ]"
>                  : [r] "+r" (r) : [x] "r" (x), [addr] "r" (addr) : );
>
>    return (r);
>}
>
>
>static inline uint32_t __swp_byte (uint32_t x, volatile void* addr)
># 578 "include/arm_acle_gcc.h"
>{
>    register uint32_t r = 0;
>
>    asm volatile ("swpb %[r], %[x], [ %[addr] ]"
>                  : [r] "+r" (r) : [x] "r" (x), [addr] "r" (addr) : );
>
>    return (r);
>}
># 693 "include/arm_acle_gcc.h"
>static inline int __saturation_occurred (void)
>{ return ((__get_CONTROL () & (1 << 27)) != 0); }
># 705 "include/arm_acle_gcc.h"
>static inline void __set_saturation_occurred (int q)
>{
>    register uint32_t r = __get_CONTROL () & ~((1 <<27) * (q & 1));
>
>    __set_CONTROL (r);
>}
># 722 "include/arm_acle_gcc.h"
>static inline void __ignore_saturation (void) {}
>
>
>
>
>static inline int __reset_and_saturation_occurred (void)
>{
>    __set_saturation_occurred (0);
>
>    return (__saturation_occurred ());
>}
># 926 "include/arm_acle_gcc.h"
>static inline uint32_t __ror_c (uint32_t x, uint32_t y)
>{
>    register uint32_t r;
>
>    switch (y) {
>    case 0x00:
>        r = x;
>        break;
>    case 0x01:
>        asm volatile ("ror %[r], %[x], #0x01" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x02:
>        asm volatile ("ror %[r], %[x], #0x02" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x03:
>        asm volatile ("ror %[r], %[x], #0x03" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x04:
>        asm volatile ("ror %[r], %[x], #0x04" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x05:
>        asm volatile ("ror %[r], %[x], #0x05" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x06:
>        asm volatile ("ror %[r], %[x], #0x06" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x07:
>        asm volatile ("ror %[r], %[x], #0x07" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x08:
>        asm volatile ("ror %[r], %[x], #0x08" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x09:
>        asm volatile ("ror %[r], %[x], #0x09" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x0A:
>        asm volatile ("ror %[r], %[x], #0x0A" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x0B:
>        asm volatile ("ror %[r], %[x], #0x0B" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x0C:
>        asm volatile ("ror %[r], %[x], #0x0C" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x0D:
>        asm volatile ("ror %[r], %[x], #0x0D" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x0E:
>        asm volatile ("ror %[r], %[x], #0x0E" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x0F:
>        asm volatile ("ror %[r], %[x], #0x0F" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x10:
>        asm volatile ("ror %[r], %[x], #0x10" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x11:
>        asm volatile ("ror %[r], %[x], #0x11" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x12:
>        asm volatile ("ror %[r], %[x], #0x12" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x13:
>        asm volatile ("ror %[r], %[x], #0x13" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x14:
>        asm volatile ("ror %[r], %[x], #0x14" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x15:
>        asm volatile ("ror %[r], %[x], #0x15" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x16:
>        asm volatile ("ror %[r], %[x], #0x16" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x17:
>        asm volatile ("ror %[r], %[x], #0x17" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x18:
>        asm volatile ("ror %[r], %[x], #0x18" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x19:
>        asm volatile ("ror %[r], %[x], #0x19" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x1A:
>        asm volatile ("ror %[r], %[x], #0x1A" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x1B:
>        asm volatile ("ror %[r], %[x], #0x1B" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x1C:
>        asm volatile ("ror %[r], %[x], #0x1C" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x1D:
>        asm volatile ("ror %[r], %[x], #0x1D" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x1E:
>        asm volatile ("ror %[r], %[x], #0x1E" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    case 0x1F:
>        asm volatile ("ror %[r], %[x], #0x1F" : [r] "=r" (r) : [x] "r" (x) : );
>        break;
>    default:
>        r = x ;
>        break;
>    }
>
>    return (r);
>}
>
>
>
>
>
>
>static inline uint32_t __ror_v (uint32_t x, uint32_t y)
>{
>    register uint32_t r;
>
>    asm volatile ("ror %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y & 0xFF) : );
>
>    return (r);
>}
># 1063 "include/arm_acle_gcc.h"
>static inline uint64_t __rorll (uint64_t x, uint32_t y)
>{
>    register union { struct {uint32_t lo; uint32_t hi;} s; uint64_t r; } z;
>    register uint32_t t;
>    register uint32_t lo_mask = (1 << (32-y)) - 1;
>    register uint32_t hi_mask = ((1 << y) - 1) << (32-y);
>
>    z.r = x;
>
>    (z.s).lo = ((__builtin_constant_p (y))? __ror_c((z.s).lo,(y&0x1F)) : __ror_v((z.s).lo,y));
>    t = ((__builtin_constant_p (y))? __ror_c((z.s).hi,(y&0x1F)) : __ror_v((z.s).hi,y));
>
>    (z.s).hi = ((z.s).lo & hi_mask) | (t & lo_mask);
>    (z.s).lo = (t & hi_mask) | ((z.s).lo & lo_mask);
>
>    if ((y & 0x20) != 0) {
>        t = (z.s).lo;
>        (z.s).lo = (z.s).hi;
>        (z.s).hi = t;
>    }
>
>    return (z.r);
>}
># 1107 "include/arm_acle_gcc.h"
>static inline unsigned int __clz (uint32_t x)
>{ return ((unsigned int)(__builtin_clz (x))); }
>
>
>
>
>
>static inline unsigned int __clzl(unsigned long x)
>{ return ((unsigned int)(__builtin_clzl (x))); }
>
>
>
>
>
>static inline unsigned int __clzll(uint64_t x)
>{ return ((unsigned int)(__builtin_clzll (x))); }
>
>
>
>
>
>static inline unsigned int __cls (uint32_t x)
>{ return ((unsigned int)(__builtin_clrsb (x))); }
>
>
>
>
>
>static inline unsigned int __clsl (unsigned long x)
>{ return ((unsigned int)(__builtin_clrsbl (x))); }
>
>
>
>
>
>static inline unsigned int __clsll (uint64_t x)
>{ return ((unsigned int)(__builtin_clrsbll (x))); }
># 1161 "include/arm_acle_gcc.h"
>static inline uint32_t __rev (uint32_t x)
>{
>    register union {uint32_t u; int32_t s;} t;
>
>    t.s = __builtin_bswap32 (x);
>
>    return (t.u);
>}
>
>
>
>
>
>static inline uint64_t __revll (uint64_t x)
>{
>    register union {uint64_t u; int64_t s;} t;
>
>    t.s = __builtin_bswap64 (x);
>
>    return (t.u);
>}
># 1201 "include/arm_acle_gcc.h"
>static inline uint32_t __rev16 (uint32_t x)
>{
>    register union { struct { uint8_t b0; uint8_t b1; uint8_t b2; uint8_t b3; } bs; uint32_t w; } r, t;
>
>    t.w = x;
>
>    (r.bs).b0 = (t.bs).b1;
>    (r.bs).b1 = (t.bs).b0;
>    (r.bs).b2 = (t.bs).b3;
>    (r.bs).b3 = (t.bs).b2;
>
>    return (r.w);
>}
>
>
>
>
>
>
>static inline uint64_t __rev16ll (uint64_t x)
>{
>    register
>        union { struct { uint32_t lo; uint32_t hi; } w; uint64_t dw; } r, t;
>
>    t.dw = x;
>
>    (r.w).lo = __rev16 ((t.w).lo);
>    (r.w).hi = __rev16 ((t.w).hi);
>
>    return (r.dw);
>}
># 1251 "include/arm_acle_gcc.h"
>static inline int16_t __revsh (int16_t x)
>{
>    register union { struct { uint8_t lo; uint8_t hi; } bs; int16_t hw; } r, t;
>
>    t.hw = x;
>
>    (r.bs).lo = (t.bs).hi;
>    (r.bs).hi = (t.bs).lo;
>
>    return (r.hw);
>}
># 1305 "include/arm_acle_gcc.h"
>static inline int32_t __smulbb (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("smulbb %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
>
>
>
>
>
>
>static inline int32_t __smulbt (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("smulbt %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
>
>
>
>
>
>
>static inline int32_t __smultb (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("smultb %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
>
>
>
>
>
>
>static inline int32_t __smultt (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("smultt %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
># 1367 "include/arm_acle_gcc.h"
>static inline int32_t __smulwb (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("smulwb %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
># 1384 "include/arm_acle_gcc.h"
>static inline int32_t __smulwt (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("smulwt %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
># 1641 "include/arm_acle_gcc.h"
>static inline int32_t __qadd (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("qadd %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
>
>
>
>
>
>
>static inline int32_t __qsub (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("qsub %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
>
>
>
>
>
>static inline int32_t __qdbl (int32_t x)
>{
>    register int32_t r;
>
>    asm volatile ("qadd %[r], %[x], %[x]"
>  : [r] "=r" (r) : [x] "r" (x) : );
>
>    return (r);
>}
># 1687 "include/arm_acle_gcc.h"
>static inline int32_t __qdadd (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("qdadd %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
>
>
>
>
>
>
>static inline int32_t __qdsub (int32_t x, int32_t y)
>{
>    register int32_t r;
>
>    asm volatile ("qdsub %[r], %[x], %[y]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y) : );
>
>    return (r);
>}
># 1731 "include/arm_acle_gcc.h"
>static inline int32_t __smlabb (int32_t x, int32_t y, int32_t acc)
>{
>    register int32_t r;
>
>    asm volatile ("smlabb %[r], %[x], %[y], %[a]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y), [a] "r" (acc) : );
>
>    return (r);
>}
># 1752 "include/arm_acle_gcc.h"
>static inline int32_t __smlabt (int32_t x, int32_t y, int32_t acc)
>{
>    register int32_t r;
>
>    asm volatile ("smlabt %[r], %[x], %[y], %[a]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y), [a] "r" (acc) : );
>
>    return (r);
>}
># 1772 "include/arm_acle_gcc.h"
>static inline int32_t __smlatb (int32_t x, int32_t y, int32_t acc)
>{
>    register int32_t r;
>
>    asm volatile ("smlatb %[r], %[x], %[y], %[a]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y), [a] "r" (acc) : );
>
>    return (r);
>}
># 1792 "include/arm_acle_gcc.h"
>static inline int32_t __smlatt (int32_t x, int32_t y, int32_t acc)
>{
>    register int32_t r;
>
>    asm volatile ("smlatt %[r], %[x], %[y], %[a]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y), [a] "r" (acc) : );
>
>    return (r);
>}
># 1814 "include/arm_acle_gcc.h"
>static inline int32_t __smlawb (int32_t x, int32_t y, int32_t acc)
>{
>    register int32_t r;
>
>    asm volatile ("smlawb %[r], %[x], %[y], %[a]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y), [a] "r" (acc) : );
>
>    return (r);
>}
># 1835 "include/arm_acle_gcc.h"
>static inline int32_t __smlawt (int32_t x, int32_t y, int32_t acc)
>{
>    register int32_t r;
>
>    asm volatile ("smlawt %[r], %[x], %[y], %[a]"
>                  : [r] "=r" (r) : [x] "r" (x), [y] "r" (y), [a] "r" (acc) : );
>
>    return (r);
>}
># 1858 "include/arm_acle_gcc.h"
>static inline int64_t __smlalbb (int64_t acc, int32_t x, int32_t y)
>{
>    register union { struct {uint32_t lo; uint32_t hi; } s_rep; int64_t i_rep; } r;
>
>    r.i_rep = acc;
>
>    asm volatile ("smlalbb %[r_lo], %[r_hi], %[x], %[y]"
>                  : [r_lo] "+r" ((r.s_rep).lo),
>      [r_hi] "+r" ((r.s_rep).hi)
>                  : [x] "r" (x), [y] "r" (y) : );
>
>    return (r.i_rep);
>}
># 1884 "include/arm_acle_gcc.h"
>static inline int64_t __smlalbt (int64_t acc, int32_t x, int32_t y)
>{
>    register union { struct {uint32_t lo; uint32_t hi; } s_rep; int64_t i_rep; } r;
>
>    r.i_rep = acc;
>
>    asm volatile ("smlalbt %[r_lo], %[r_hi], %[x], %[y]"
>                  : [r_lo] "+r" ((r.s_rep).lo),
>      [r_hi] "+r" ((r.s_rep).hi)
>                  : [x] "r" (x), [y] "r" (y) : );
>
>    return (r.i_rep);
>}
># 1910 "include/arm_acle_gcc.h"
>static inline int64_t __smlaltb (int64_t acc, int32_t x, int32_t y)
>{
>    register union { struct {uint32_t lo; uint32_t hi; } s_rep; int64_t i_rep; } r;
>
>    r.i_rep = acc;
>
>    asm volatile ("smlaltb %[r_lo], %[r_hi], %[x], %[y]"
>                  : [r_lo] "+r" ((r.s_rep).lo),
>      [r_hi] "+r" ((r.s_rep).hi)
>                  : [x] "r" (x), [y] "r" (y) : );
>
>    return (r.i_rep);
>}
># 1935 "include/arm_acle_gcc.h"
>static inline int64_t __smlaltt (int64_t acc, int32_t x, int32_t y)
>{
>    register union { struct {uint32_t lo; uint32_t hi; } s_rep; int64_t i_rep; } r;
>
>    r.i_rep = acc;
>
>    asm volatile ("smlaltt %[r_lo], %[r_hi], %[x], %[y]"
>                  : [r_lo] "+r" ((r.s_rep).lo),
>      [r_hi] "+r" ((r.s_rep).hi)
>                  : [x] "r" (x), [y] "r" (y) : );
>
>    return (r.i_rep);
>}
># 15 "include/arm_acle.h" 2
># 36 "include/stdfix-full-iso.h" 2
># 90 "include/stdfix-full-iso.h"
>void __stdfix_64x64_128 (uint64_t *hi, uint64_t *lo, uint64_t x, uint64_t y);
>
>
>
>
>typedef int8_t int_hr_t;
>
>
>
>typedef int16_t int_r_t;
>
>
>
>
>typedef int32_t int_lr_t;
>
>
>
>
>typedef int16_t int_hk_t;
>
>
>
>typedef int32_t int_k_t;
>
>
>
>
>typedef int64_t int_lk_t;
>
>
>
>
>typedef uint8_t uint_uhr_t;
>
>
>
>
>typedef uint16_t uint_ur_t;
>
>
>
>
>typedef uint32_t uint_ulr_t;
>
>
>
>
>typedef uint16_t uint_uhk_t;
>
>
>
>
>typedef uint32_t uint_uk_t;
>
>
>
>
>typedef uint64_t uint_ulk_t;
>
>
>
>
>
>
>typedef short _Fract s07;
>
>
>
>typedef _Fract s015;
>
>
>
>typedef long _Fract s031;
>
>
>
>typedef short _Accum s87;
>
>
>
>typedef _Accum s1615;
>
>
>
>typedef long _Accum s3231;
>
>
>
>typedef unsigned short _Fract u08;
>
>
>
>typedef unsigned _Fract u016;
>
>
>
>typedef unsigned long _Fract u032;
>
>
>
>typedef unsigned short _Accum u88;
>
>
>
>typedef unsigned _Accum u1616;
>
>
>
>typedef unsigned long _Accum u3232;
># 225 "include/stdfix-full-iso.h"
>static inline int_hr_t bitshr (const s07 f)
>{ union { int_hr_t r; s07 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline int_r_t bitsr (const s015 f)
>{ union { int_r_t r; s015 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline int_lr_t bitslr (const s031 f)
>{ union { int_lr_t r; s031 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline int_hk_t bitshk (const s87 f)
>{ union { int_hk_t r; s87 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline int_k_t bitsk (const s1615 f)
>{ union { int_k_t r; s1615 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline int_lk_t bitslk (const s3231 f)
>{ union { int_lk_t r; s3231 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline uint_uhr_t bitsuhr (const u08 f)
>{ union { uint_uhr_t r; u08 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline uint_ur_t bitsur (const u016 f)
>{ union { uint_ur_t r; u016 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline uint_ulr_t bitsulr (const u032 f)
>{ union { uint_ulr_t r; u032 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline uint_uhk_t bitsuhk (const u88 f)
>{ union { uint_uhk_t r; u88 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline uint_uk_t bitsuk (const u1616 f)
>{ union { uint_uk_t r; u1616 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>static inline uint_ulk_t bitsulk (const u3232 f)
>{ union { uint_ulk_t r; u3232 fx;} x; x.fx = f; return (x.r); }
>
>
>
>
>
>
>
>static inline s07 hrbits (const int_hr_t n)
>{ union { int_hr_t r; s07 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline s015 rbits (const int_r_t n)
>{ union { int_r_t r; s015 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline s031 lrbits (const int_lr_t n)
>{ union { int_lr_t r; s031 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline s87 hkbits (const int_hk_t n)
>{ union { int_hk_t r; s87 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline s1615 kbits (const int_k_t n)
>{ union { int_k_t r; s1615 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline s3231 lkbits (const int_lk_t n)
>{ union { int_lk_t r; s3231 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline u08 uhrbits (const uint_uhr_t n)
>{ union { uint_uhr_t r; u08 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline u016 urbits (const uint_ur_t n)
>{ union { uint_ur_t r; u016 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline u032 ulrbits (const uint_ulr_t n)
>{ union { uint_ulr_t r; u032 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline u88 uhkbits (const uint_uhk_t n)
>{ union { uint_uhk_t r; u88 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline u1616 ukbits (const uint_uk_t n)
>{ union { uint_uk_t r; u1616 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>static inline u3232 ulkbits (const uint_ulk_t n)
>{ union { uint_ulk_t r; u3232 fx;} x; x.r = n; return (x.fx); }
>
>
>
>
>
>
>
>static inline int32_t __stdfix_sat_hr (const int32_t x)
>{
>    if (x > 127) return (127);
>    if (x < (-127 - 1)) return ((-127 - 1));
>
>    return (x);
>}
>
>
>
>
>
>static inline int32_t __stdfix_sat_r (const int32_t x)
>{
>    if (x > 32767) return (32767);
>    if (x < (-32767 - 1)) return ((-32767 - 1));
>
>    return (x);
>}
>
>
>
>
>
>static inline int32_t __stdfix_sat_lr (const int64_t x)
>{
>    if (x > 2147483647L) return (2147483647L);
>    if (x < (-2147483647L - 1)) return ((-2147483647L - 1));
>
>    return ((int32_t)x);
>}
>
>
>
>
>
>static inline int32_t __stdfix_sat_hk (const int32_t x)
>{
>    if (x > 32767) return (32767);
>    if (x < (-32767 - 1)) return ((-32767 - 1));
>
>    return (x);
>}
>
>
>
>
>
>static inline int32_t __stdfix_sat_k (const int64_t x)
>{
>    if (x > 2147483647L) return (2147483647L);
>    if (x < (-2147483647L - 1)) return ((-2147483647L - 1));
>
>    return ((int32_t)x);
>}
>
>
>
>
>
>static inline uint32_t __stdfix_sat_uhr (const uint32_t x)
>{
>    if (x > 255) return (255);
>
>    return (x);
>}
>
>
>
>
>
>static inline uint32_t __stdfix_sat_ur (const uint32_t x)
>{
>    if (x > 65535) return (65535);
>
>    return (x);
>}
>
>
>
>
>
>static inline uint32_t __stdfix_sat_ulr (const uint64_t x)
>{
>    if (x > 4294967295UL) return (4294967295UL);
>
>    return ((uint32_t)x);
>}
>
>
>
>
>
>static inline uint32_t __stdfix_sat_uhk (const uint32_t x)
>{
>    if (x > 65535) return (65535);
>
>    return (x);
>}
>
>
>
>
>
>static inline uint32_t __stdfix_sat_uk (const uint64_t x)
>{
>    if (x > 4294967295UL) return (4294967295UL);
>
>    return ((uint32_t)x);
>}
># 515 "include/stdfix-full-iso.h"
>static inline int32_t __stdfix_sadd_hr (int_hr_t x, int_hr_t y)
>{ return (__stdfix_sat_hr ((int32_t)x + (int32_t)y)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_ssub_hr (int_hr_t x, int_hr_t y)
>{ return (__stdfix_sat_hr ((int32_t)x - (int32_t)y)); }
>
>
>
>
>
>static inline int32_t __stdfix_sneg_hr (int_hr_t x)
>{ return (__stdfix_sat_hr ((int32_t)-x)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_sadd_r (int32_t x, int32_t y)
>{ return (__stdfix_sat_r ((int32_t)x + (int32_t)y)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_ssub_r (int32_t x, int32_t y)
>{ return (__stdfix_sat_r ((int32_t)x - (int32_t)y)); }
>
>
>
>
>
>static inline int32_t __stdfix_sneg_r (int32_t x)
>{ return (__stdfix_sat_r ((int32_t)-x)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_sadd_lr (int32_t x, int32_t y)
>{ return (__stdfix_sat_lr ((int64_t)x + (int64_t)y)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_ssub_lr (int32_t x, int32_t y)
>{ return (__stdfix_sat_lr ((int64_t)x - (int64_t)y)); }
>
>
>
>
>
>static inline int32_t __stdfix_sneg_lr (int32_t x)
>{ return (__stdfix_sat_lr ((int64_t)-x)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_sadd_hk (int32_t x, int32_t y)
>{ return (__stdfix_sat_hk ((int32_t)x + (int32_t)y)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_ssub_hk (int32_t x, int32_t y)
>{ return (__stdfix_sat_hk ((int32_t)x - (int32_t)y)); }
>
>
>
>
>
>static inline int32_t __stdfix_sneg_hk (int32_t x)
>{ return (__stdfix_sat_hk ((int32_t)-x)); }
>
>
>
>
>
>
>static inline int32_t __stdfix_sadd_k (int32_t x, int32_t y)
>
>{ return (__qadd (x, y)); }
># 619 "include/stdfix-full-iso.h"
>static inline int32_t __stdfix_ssub_k (int32_t x, int32_t y)
>
>{ return (__qsub (x, y)); }
># 630 "include/stdfix-full-iso.h"
>static inline int32_t __stdfix_sneg_k (int32_t x)
>
>{ return (__qsub (0, x)); }
># 642 "include/stdfix-full-iso.h"
>int64_t __stdfix_sadd_lk (int64_t x, int64_t y);
>
>
>
>
>
>
>int64_t __stdfix_ssub_lk (int64_t x, int64_t y);
>
>
>
>
>
>int64_t __stdfix_sneg_lk (int64_t x);
>
>
>
>
>
>
>static inline int32_t __stdfix_smul_hr (int32_t x, int32_t y)
>{
>    if (x == (-127 - 1) && y == (-127 - 1)) return (127);
>
>    return ((int32_t)__stdfix_sat_hr (((int32_t)x * (int32_t)y) >> 7));
>}
>
>
>
>
>
>
>static inline int32_t __stdfix_smul_r (int32_t x, int32_t y)
>{
>    if (x == (-32767 - 1) && y == (-32767 - 1)) return (32767);
>
>    return ((int32_t)__stdfix_sat_r (((int32_t)x * (int32_t)y) >> 15));
>}
>
>
>
>
>
>
>static inline int32_t __stdfix_smul_lr (int32_t x, int32_t y)
>{
>    if (x == (-2147483647L - 1) && y == (-2147483647L - 1)) return (2147483647L);
>
>    return (__stdfix_sat_lr (((int64_t)x * (int64_t)y) >> 31));
>}
>
>
>
>
>
>
>static inline int32_t __stdfix_smul_hk (int32_t x, int32_t y)
>{
>    if (x == (-32767 - 1) && y == (-32767 - 1)) return (32767);
>
>    return (__stdfix_sat_hk (((int32_t)x * (int32_t)y) >> 7));
>}
>
>
>
>
>
>
>static inline int32_t __stdfix_smul_k (int32_t x, int32_t y)
>{
>    if (x == (-2147483647L - 1) && y == (-2147483647L - 1)) return (2147483647L);
>
>    return (__stdfix_sat_k (((int64_t)x * (int64_t)y) >> 15));
>}
>
>
>
>
>
>
>int64_t __stdfix_smul_lk (int64_t x, int64_t y);
>
>
>
>
>
>
>static inline uint32_t __stdfix_sadd_uhr (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uhr ((uint32_t)x + (uint32_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_ssub_uhr (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uhr ((uint32_t)x - (uint32_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_sadd_ur (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_ur ((uint32_t)x + (uint32_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_ssub_ur (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_ur ((uint32_t)x - (uint32_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_sadd_ulr (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_ulr ((uint64_t)x + (uint64_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_ssub_ulr (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_ulr ((uint64_t)x - (uint64_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_sadd_uhk (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uhk ((uint32_t)x + (uint32_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_ssub_uhk (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uhk ((uint32_t)x - (uint32_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_sadd_uk (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uk ((uint64_t)x + (uint64_t)y)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_ssub_uk (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uk ((uint64_t)x - (uint64_t)y)); }
>
>
>
>
>
>
>uint64_t __stdfix_sadd_ulk (uint64_t x, uint64_t y);
>
>
>
>
>
>
>uint64_t __stdfix_ssub_ulk (uint64_t x, uint64_t y);
>
>
>
>
>
>
>static inline uint32_t __stdfix_smul_uhr (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uhr (((uint32_t)x * (uint32_t)y) >> 8));}
>
>
>
>
>
>
>static inline uint32_t __stdfix_smul_ur (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_ur (((uint32_t)x * (uint32_t)y) >> 16)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_smul_ulr (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_ulr (((uint64_t)x * (uint64_t)y) >> 32)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_smul_uhk (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uhk (((uint32_t)x * (uint32_t)y) >> 8)); }
>
>
>
>
>
>
>static inline uint32_t __stdfix_smul_uk (uint32_t x, uint32_t y)
>{ return (__stdfix_sat_uk (((uint64_t)x * (uint64_t)y) >> 16)); }
>
>
>
>
>
>
>uint64_t __stdfix_smul_ulk (uint64_t x, uint64_t y);
># 872 "include/stdfix-full-iso.h"
>static inline int mulir (int n, s015 x)
>{ return ((int)(((int64_t)(n) * (int64_t)(bitsr (x))) >> 15)); }
>
>
>
>
>
>
>static inline long int mulilr (long int n, s031 x)
>{ return ((long int)(((int64_t)(n) * (int64_t)(bitslr (x))) >> 31)); }
>
>
>
>
>
>
>static inline int mulik (int n, s1615 x)
>{ return ((int)(((int64_t)(n) * (int64_t)(bitsk (x))) >> 15)); }
>
>
>
>
>
>
>static inline long int mulilk (long int n, s3231 x)
>{
>    int64_t r = bitslk (x);
>    int64_t k = (int64_t)(n) * (r >> 31);
>    int64_t c = ((int64_t)(n) * (r & 0x7FFFFFFLL)) >> 31;
>
>    return ((long int)(k + c));
>}
>
>
>
>
>
>
>static inline int divir (int n, s015 x)
>{ return ((int) ( ((int64_t)(n) << 15) / bitsr (x))); }
>
>
>
>
>
>
>static inline long int divilr (long int n, s031 x)
>{ return ((long int)( ((int64_t)(n) << 31) / bitslr (x))); }
>
>
>
>
>
>
>static inline int divik (int n, s1615 x)
>{ return ((long int)( ((int64_t)(n) << 15) / bitsk (x))); }
>
>
>
>
>
>
>static inline long int divilk (long int n, s3231 x)
>{ return ((long int)( ((int64_t)(n) << 31) / bitslk (x))); }
>
>
>
>
>
>
>static inline s015 rdivi (int i, int j)
>{ return (rbits ((int_r_t) (((int64_t)(i) << 15) / ((int64_t)j)))); }
>
>
>
>
>
>
>static inline s031 lrdivi (long int i, long int j)
>{ return (lrbits ((int_lr_t)(((int64_t)(i) << 31) / ((int64_t)j)))); }
>
>
>
>
>
>
>static inline s1615 kdivi (int i, int j)
>{ return (kbits ((int_k_t) (((int64_t)(i) << 15) / ((int64_t)j)))); }
>
>
>
>
>
>
>static inline s3231 lkdivi (long int i, long int j)
>{ return (lkbits ((int_lk_t)(((int64_t)(i) << 31) / ((int64_t)j)))); }
>
>
>
>
>
>
>static inline int idivr (s015 x, s015 y)
>{ return (int) (rbits (x) / rbits (y)); }
>
>
>
>
>
>
>static inline long int idivlr (s031 x, s031 y)
>{ return (long int)(lrbits (x) / lrbits (y)); }
>
>
>
>
>
>
>static inline int idivk (s1615 x, s1615 y)
>{ return (int) (kbits (x) / kbits (y)); }
>
>
>
>
>
>
>static inline long int idivlk (s3231 x, s3231 y)
>{ return (long int)(lkbits (x) / lkbits (y)); }
>
>
>
>
>
>
>
>static inline unsigned int muliur (unsigned int n, u016 x)
>{ return ((unsigned int)(((uint64_t)(n) * (uint64_t)(bitsur (x))) >> 16)); }
>
>
>
>
>
>
>
>static inline unsigned long int muliulr (unsigned long int n, u032 x)
>{ return ((unsigned long int)(((uint64_t)(n) *
>          (uint64_t)(bitsulr (x))) >> 32)); }
>
>
>
>
>
>
>
>static inline unsigned int muliuk (unsigned int n, u1616 x)
>{ return ((unsigned int)( ((uint64_t)(n) << 16) / bitsuk (x))); }
>
>
>
>
>
>
>
>static inline unsigned long int muliulk (unsigned long int n, u3232 x)
>{
>    uint64_t r = bitsulk (x);
>    uint64_t k = (uint64_t)(n) * (r >> 32);
>    uint64_t c = ((uint64_t)(n) * (r & 0xFFFFFFFLL)) >> 32;
>
>    return ((unsigned long int)(k + c));
>}
>
>
>
>
>
>
>
>static inline unsigned int diviur (unsigned int n, u016 x)
>{ return ((unsigned int) ( ((uint64_t)(n) << 16) / bitsur (x))); }
>
>
>
>
>
>
>
>static inline unsigned long int diviulr (unsigned long int n, u032 x)
>{ return ((unsigned long int)( ((uint64_t)(n) << 32) / bitsulr (x))); }
>
>
>
>
>
>
>
>static inline unsigned int diviuk (unsigned int n, u1616 x)
>{ return ((unsigned long int)( ((uint64_t)(n) << 16) / bitsuk (x))); }
>
>
>
>
>
>
>
>static inline unsigned long int diviulk (unsigned long int n, u3232 x)
>{ return ((unsigned long int)( ((uint64_t)(n) << 32) / bitsulk (x))); }
>
>
>
>
>
>
>static inline u016 urdivi (unsigned int i, unsigned int j)
>{ return (ulrbits ((uint_ulr_t)(((uint64_t)(i) << 16) / ((uint64_t)j)))); }
>
>
>
>
>
>
>
>static inline u032 ulrdivi (unsigned long int i, unsigned long int j)
>{ return (ulrbits ((uint_ulr_t)(((uint64_t)(i) << 32) / ((uint64_t)j)))); }
>
>
>
>
>
>
>static inline u1616 ukdivi (unsigned int i, unsigned int j)
>{ return (ukbits ((uint_uk_t) (((uint64_t)(i) << 16) / ((uint64_t)j)))); }
>
>
>
>
>
>
>
>static inline u3232 ulkdivi (unsigned long int i, unsigned long int j)
>{ return (ulkbits ((uint_ulk_t)(((uint64_t)(i) << 32) / ((uint64_t)j)))); }
>
>
>
>
>
>
>static inline unsigned int idivur (u016 x, u016 y)
>{ return (unsigned int) (urbits (x) / urbits (y)); }
>
>
>
>
>
>
>
>static inline unsigned long int idivulr (u032 x, u032 y)
>{ return (unsigned long int)(ulrbits (x) / ulrbits (y)); }
>
>
>
>
>
>
>static inline unsigned int idivuk (u1616 x, u1616 y)
>{ return (unsigned int) (ukbits (x) / ukbits (y)); }
>
>
>
>
>
>
>static inline unsigned long int idivulk (u3232 x, u3232 y)
>{ return (unsigned long int)(ulkbits (x) / ulkbits (y)); }
># 1166 "include/stdfix-full-iso.h"
>static inline s07 abshr (s07 f)
>{
>    int_hr_t r = bitshr (f);
>
>    if (r < 0)
> r = (r == (-127 - 1))? 127: -r;
>
>    return (hrbits (r));
>}
>
>
>
>
>
>static inline s015 absr (s015 f)
>{
>    int_r_t r = bitsr (f);
>
>    if (r < 0)
> r = (r == (-32767 - 1))? 32767: -r;
>
>    return (rbits (r));
>}
>
>
>
>
>
>static inline s031 abslr (s031 f)
>{
>    int_lr_t r = bitslr (f);
>
>    if (r < 0)
> r = (r == (-2147483647L - 1))? 2147483647L: -r;
>
>    return (lrbits (r));
>}
>
>
>
>
>
>static inline s87 abshk (s87 f)
>{
>    int_hk_t r = bitshk (f);
>
>    if (r < 0)
> r = (r == (-32767 - 1))? 32767: -r;
>
>    return (hkbits (r));
>}
>
>
>
>
>
>static inline s1615 absk (s1615 f)
>{
>    int_k_t r = bitsk (f);
>
>    if (r < 0)
> r = (r == (-2147483647L - 1))? 2147483647L: -r;
>
>    return (kbits (r));
>}
>
>
>
>
>
>static inline s3231 abslk (s3231 f)
>{
>    int_lk_t r = bitslk (f);
>
>    if (r < 0)
>    r = (r == (-9223372036854775807LL - 1))? 9223372036854775807LL: -r;
>
>    return (lkbits (r));
>}
># 1264 "include/stdfix-full-iso.h"
>static inline uint8_t __stdfix_round_u8 (uint8_t x, int n)
>{
>    register uint8_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline uint16_t __stdfix_round_u16 (uint16_t x, int n)
>{
>    register uint16_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline uint32_t __stdfix_round_u32 (uint32_t x, int n)
>{
>    register uint32_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline uint64_t __stdfix_round_u64 (uint64_t x, int n)
>{
>    register uint64_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline int8_t __stdfix_round_s8 (int8_t x, int n)
>{
>    register int8_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline int16_t __stdfix_round_s16 (int16_t x, int n)
>{
>    register int16_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline int32_t __stdfix_round_s32 (int32_t x, int n)
>{
>    register int32_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline int64_t __stdfix_round_s64 (int64_t x, int n)
>{
>    register int64_t r, c;
>
>    c = (x >> (n-1)) & 0x1;
>    r = x >> n;
>    r = (r + c) << n;
>
>    return (r);
>}
>
>
>
>
>
>
>
>static inline s07 roundhr (s07 f, int n)
>{ return (hrbits (__stdfix_round_s8 (bitshr (f), n))); }
>
>
>
>
>
>
>
>static inline s015 roundr (s015 f, int n)
>{ return (rbits (__stdfix_round_s16 (bitsr (f), n))); }
>
>
>
>
>
>
>
>static inline s031 roundlr (s031 f, int n)
>{ return (lrbits (__stdfix_round_s32 (bitslr (f), n))); }
>
>
>
>
>
>
>
>static inline s87 roundhk (s87 f, int n)
>{ return (hkbits (__stdfix_round_s16 (bitshk (f), n))); }
>
>
>
>
>
>
>static inline s1615 roundk (s1615 f, int n)
>{ return (kbits (__stdfix_round_s32 (bitsk (f), n))); }
>
>
>
>
>
>
>
>static inline s3231 roundlk (s3231 f, int n)
>{ return (lkbits (__stdfix_round_s64 (bitslk (f), n))); }
>
>
>
>
>
>
>
>static inline u08 rounduhr (u08 f, int n)
>{ return (uhrbits (__stdfix_round_u8 (bitsuhr (f), n))); }
>
>
>
>
>
>
>
>static inline u016 roundur (u016 f, int n)
>{ return (urbits (__stdfix_round_u16 (bitsur (f), n))); }
>
>
>
>
>
>
>
>static inline u032 roundulr (u032 f, int n)
>{ return (ulrbits (__stdfix_round_u32 (bitsulr (f), n))); }
>
>
>
>
>
>
>
>static inline u88 rounduhk (u88 f, int n)
>{ return (uhkbits (__stdfix_round_u16 (bitsuhk (f), n))); }
>
>
>
>
>
>
>
>static inline u1616 rounduk (u1616 f, int n)
>{ return (ukbits (__stdfix_round_u32 (bitsuk (f), n))); }
>
>
>
>
>
>
>
>static inline u3232 roundulk (u3232 f, int n)
>{ return (ulkbits (__stdfix_round_u64 (bitsulk (f), n))); }
># 1524 "include/stdfix-full-iso.h"
>static inline int countlshr (s07 f)
>{
>    int32_t n = (int32_t)(bitshr (f));
>
>    if (n == 0) return (7);
>
>    return (__builtin_clrsb (n) - 24);
>}
>
>
>
>
>
>static inline int countlsr (s015 f)
>{
>    int32_t n = (int32_t)(bitsr (f));
>
>    if (n == 0) return (15);
>
>    return (__builtin_clrsb (n) - 16);
>}
>
>
>
>
>
>
>static inline int countlslr (s031 f)
>{
>    int_lr_t n = bitslr (f);
>
>    if (n == 0) return (31);
>
>    return (__builtin_clrsb (n));
>}
>
>
>
>
>
>
>static inline int countlshk (s87 f)
>{
>    int32_t n = (int32_t)(bitshk (f));
>
>    if (n == 0) return (15);
>
>    return (__builtin_clrsb (n) - 16);
>}
>
>
>
>
>
>static inline int countlsk (s1615 f)
>{
>    int_k_t n = bitsk (f);
>
>    if (n == 0) return (31);
>
>    return (__builtin_clrsb (n));
>}
>
>
>
>
>
>
>static inline int countlslk (s3231 f)
>{
>    int64_t n = (int64_t)(bitslk (f));
>
>    if (n == 0) return (63);
>
>    return (__builtin_clrsbll (n));
>}
>
>
>
>
>
>
>static inline int countlsuhr (u08 f)
>{
>    uint32_t n = (uint32_t)(bitsuhr (f));
>
>    if (n == 0) return (8);
>
>    return (__builtin_clz (n) - 24);
>}
>
>
>
>
>
>
>static inline int countlsur (u016 f)
>{
>    uint32_t n = (uint32_t)(bitsur (f));
>
>    if (n == 0) return (16);
>
>    return (__builtin_clz (n) - 16);
>}
>
>
>
>
>
>
>static inline int countlsulr (u032 f)
>{
>    uint_ulr_t n = bitsulr (f);
>
>    if (n == 0) return (32);
>
>    return (__builtin_clz (n));
>}
>
>
>
>
>
>
>static inline int countlsuhk (u88 f)
>{
>    uint32_t n = (uint32_t)(bitsuhk (f));
>
>    if (n == 0) return (16);
>
>    return (__builtin_clz (n) - 16);
>}
>
>
>
>
>
>
>static inline int countlsuk (u1616 f)
>{
>    uint_uk_t n = (uint_uk_t)(bitsuk (f));
>
>    if (n == 0) return (32);
>
>    return (__builtin_clz (n));
>}
>
>
>
>
>
>
>static inline int countlsulk (u3232 f)
>{
>    uint_ulk_t n = (uint_ulk_t)(bitsulk (f));
>
>    if (n == 0) return (64);
>
>    return (__builtin_clzll (n));
>}
># 11 "src/random.c" 2
># 1 "include/stdfix-exp.h" 1
># 45 "include/stdfix-exp.h"
># 1 "include/stdfix-full-iso.h" 1
># 46 "include/stdfix-exp.h" 2
>
>
>
>
>_Accum expk( _Accum x );
>
>uint32_t exp_series (uint32_t x);
># 12 "src/random.c" 2
>
>
>
># 1 "/usr/arm-none-eabi/include/math.h" 1 3
>
>
>
>
># 1 "/usr/arm-none-eabi/include/sys/reent.h" 1 3
># 13 "/usr/arm-none-eabi/include/sys/reent.h" 3
># 1 "/usr/arm-none-eabi/include/_ansi.h" 1 3
># 15 "/usr/arm-none-eabi/include/_ansi.h" 3
># 1 "/usr/arm-none-eabi/include/newlib.h" 1 3
># 16 "/usr/arm-none-eabi/include/_ansi.h" 2 3
># 1 "/usr/arm-none-eabi/include/sys/config.h" 1 3
>
>
>
># 1 "/usr/arm-none-eabi/include/machine/ieeefp.h" 1 3
># 5 "/usr/arm-none-eabi/include/sys/config.h" 2 3
># 17 "/usr/arm-none-eabi/include/_ansi.h" 2 3
># 14 "/usr/arm-none-eabi/include/sys/reent.h" 2 3
># 1 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stddef.h" 1 3 4
># 147 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stddef.h" 3 4
>typedef int ptrdiff_t;
># 212 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stddef.h" 3 4
>typedef unsigned int size_t;
># 324 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stddef.h" 3 4
>typedef unsigned int wchar_t;
># 15 "/usr/arm-none-eabi/include/sys/reent.h" 2 3
># 1 "/usr/arm-none-eabi/include/sys/_types.h" 1 3
># 12 "/usr/arm-none-eabi/include/sys/_types.h" 3
># 1 "/usr/arm-none-eabi/include/machine/_types.h" 1 3
># 13 "/usr/arm-none-eabi/include/sys/_types.h" 2 3
># 1 "/usr/arm-none-eabi/include/sys/lock.h" 1 3
>
>
>
>
>
>typedef int _LOCK_T;
>typedef int _LOCK_RECURSIVE_T;
># 14 "/usr/arm-none-eabi/include/sys/_types.h" 2 3
>
>
>typedef long _off_t;
>
>
>
>typedef short __dev_t;
>
>
>
>typedef unsigned short __uid_t;
>
>
>typedef unsigned short __gid_t;
>
>
>
>__extension__ typedef long long _off64_t;
>
>
>
>
>
>
>
>typedef long _fpos_t;
># 55 "/usr/arm-none-eabi/include/sys/_types.h" 3
>typedef signed int _ssize_t;
># 67 "/usr/arm-none-eabi/include/sys/_types.h" 3
># 1 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stddef.h" 1 3 4
># 353 "/usr/lib/gcc/arm-none-eabi/4.9.2/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 68 "/usr/arm-none-eabi/include/sys/_types.h" 2 3
>
>
>
>typedef struct
>{
>  int __count;
>  union
>  {
>    wint_t __wch;
>    unsigned char __wchb[4];
>  } __value;
>} _mbstate_t;
>
>
>
>typedef _LOCK_RECURSIVE_T _flock_t;
>
>
>
>
>typedef void *_iconv_t;
># 16 "/usr/arm-none-eabi/include/sys/reent.h" 2 3
>
>
>
>
>
>
>typedef unsigned long __ULong;
># 38 "/usr/arm-none-eabi/include/sys/reent.h" 3
>struct _reent;
>
>
>
>
>
>
>struct _Bigint
>{
>  struct _Bigint *_next;
>  int _k, _maxwds, _sign, _wds;
>  __ULong _x[1];
>};
>
>
>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;
>};
>
>
>
>
>
>
>
>struct _on_exit_args {
> void * _fnargs[32];
> void * _dso_handle[32];
>
> __ULong _fntypes;
>
>
> __ULong _is_cxa;
>};
># 91 "/usr/arm-none-eabi/include/sys/reent.h" 3
>struct _atexit {
> struct _atexit *_next;
> int _ind;
>
> void (*_fns[32])(void);
>        struct _on_exit_args _on_exit_args;
>};
># 115 "/usr/arm-none-eabi/include/sys/reent.h" 3
>struct __sbuf {
> unsigned char *_base;
> int _size;
>};
># 179 "/usr/arm-none-eabi/include/sys/reent.h" 3
>struct __sFILE {
>  unsigned char *_p;
>  int _r;
>  int _w;
>  short _flags;
>  short _file;
>  struct __sbuf _bf;
>  int _lbfsize;
>
>
>
>
>
>
>  void * _cookie;
>
>  int (* _read) (struct _reent *, void *, char *, int)
>                                          ;
>  int (* _write) (struct _reent *, void *, const char *, int)
>
>                                   ;
>  _fpos_t (* _seek) (struct _reent *, void *, _fpos_t, int);
>  int (* _close) (struct _reent *, void *);
>
>
>  struct __sbuf _ub;
>  unsigned char *_up;
>  int _ur;
>
>
>  unsigned char _ubuf[3];
>  unsigned char _nbuf[1];
>
>
>  struct __sbuf _lb;
>
>
>  int _blksize;
>  _off_t _offset;
>
>
>  struct _reent *_data;
>
>
>
>  _flock_t _lock;
>
>  _mbstate_t _mbstate;
>  int _flags2;
>};
># 285 "/usr/arm-none-eabi/include/sys/reent.h" 3
>typedef struct __sFILE __FILE;
>
>
>
>struct _glue
>{
>  struct _glue *_next;
>  int _niobs;
>  __FILE *_iobs;
>};
># 317 "/usr/arm-none-eabi/include/sys/reent.h" 3
>struct _rand48 {
>  unsigned short _seed[3];
>  unsigned short _mult[3];
>  unsigned short _add;
>
>
>
>
>};
># 569 "/usr/arm-none-eabi/include/sys/reent.h" 3
>struct _reent
>{
>  int _errno;
>
>
>
>
>  __FILE *_stdin, *_stdout, *_stderr;
>
>  int _inc;
>  char _emergency[25];
>
>  int _current_category;
>  const char *_current_locale;
>
>  int __sdidinit;
>
>  void (* __cleanup) (struct _reent *);
>
>
>  struct _Bigint *_result;
>  int _result_k;
>  struct _Bigint *_p5s;
>  struct _Bigint **_freelist;
>
>
>  int _cvtlen;
>  char *_cvtbuf;
>
>  union
>    {
>      struct
>        {
>          unsigned int _unused_rand;
>          char * _strtok_last;
>          char _asctime_buf[26];
>          struct __tm _localtime_buf;
>          int _gamma_signgam;
>          __extension__ unsigned long long _rand_next;
>          struct _rand48 _r48;
>          _mbstate_t _mblen_state;
>          _mbstate_t _mbtowc_state;
>          _mbstate_t _wctomb_state;
>          char _l64a_buf[8];
>          char _signal_buf[24];
>          int _getdate_err;
>          _mbstate_t _mbrlen_state;
>          _mbstate_t _mbrtowc_state;
>          _mbstate_t _mbsrtowcs_state;
>          _mbstate_t _wcrtomb_state;
>          _mbstate_t _wcsrtombs_state;
>   int _h_errno;
>        } _reent;
>
>
>
>      struct
>        {
>
>          unsigned char * _nextf[30];
>          unsigned int _nmalloc[30];
>        } _unused;
>    } _new;
>
>
>
>  struct _atexit *_atexit;
>  struct _atexit _atexit0;
>
>
>
>  void (**(_sig_func))(int);
>
>
>
>
>  struct _glue __sglue;
>  __FILE __sf[3];
>};
># 762 "/usr/arm-none-eabi/include/sys/reent.h" 3
>extern struct _reent *_impure_ptr ;
>extern struct _reent *const _global_impure_ptr ;
>
>void _reclaim_reent (struct _reent *);
># 6 "/usr/arm-none-eabi/include/math.h" 2 3
># 1 "/usr/arm-none-eabi/include/machine/ieeefp.h" 1 3
># 7 "/usr/arm-none-eabi/include/math.h" 2 3
># 1 "/usr/arm-none-eabi/include/_ansi.h" 1 3
># 8 "/usr/arm-none-eabi/include/math.h" 2 3
>
>
>
>
>
>
>union __dmath
>{
>  double d;
>  __ULong i[2];
>};
>
>union __fmath
>{
>  float f;
>  __ULong i[1];
>};
>
>
>union __ldmath
>{
>  long double ld;
>  __ULong i[4];
>};
># 108 "/usr/arm-none-eabi/include/math.h" 3
>extern double atan (double);
>extern double cos (double);
>extern double sin (double);
>extern double tan (double);
>extern double tanh (double);
>extern double frexp (double, int *);
>extern double modf (double, double *);
>extern double ceil (double);
>extern double fabs (double);
>extern double floor (double);
>
>
>
>
>
>
>extern double acos (double);
>extern double asin (double);
>extern double atan2 (double, double);
>extern double cosh (double);
>extern double sinh (double);
>extern double exp (double);
>extern double ldexp (double, int);
>extern double log (double);
>extern double log10 (double);
>extern double pow (double, double);
>extern double sqrt (double);
>extern double fmod (double, double);
># 155 "/usr/arm-none-eabi/include/math.h" 3
>    typedef float float_t;
>    typedef double double_t;
># 199 "/usr/arm-none-eabi/include/math.h" 3
>extern int __isinff (float x);
>extern int __isinfd (double x);
>extern int __isnanf (float x);
>extern int __isnand (double x);
>extern int __fpclassifyf (float x);
>extern int __fpclassifyd (double x);
>extern int __signbitf (float x);
>extern int __signbitd (double x);
># 259 "/usr/arm-none-eabi/include/math.h" 3
>extern double infinity (void);
>extern double nan (const char *);
>extern int finite (double);
>extern double copysign (double, double);
>extern double logb (double);
>extern int ilogb (double);
>
>extern double asinh (double);
>extern double cbrt (double);
>extern double nextafter (double, double);
>extern double rint (double);
>extern double scalbn (double, int);
>
>extern double exp2 (double);
>extern double scalbln (double, long int);
>extern double tgamma (double);
>extern double nearbyint (double);
>extern long int lrint (double);
>extern long long int llrint (double);
>extern double round (double);
>extern long int lround (double);
>extern long long int llround (double);
>extern double trunc (double);
>extern double remquo (double, double, int *);
>extern double fdim (double, double);
>extern double fmax (double, double);
>extern double fmin (double, double);
>extern double fma (double, double, double);
>
>
>extern double log1p (double);
>extern double expm1 (double);
>
>
>
>extern double acosh (double);
>extern double atanh (double);
>extern double remainder (double, double);
>extern double gamma (double);
>extern double lgamma (double);
>extern double erf (double);
>extern double erfc (double);
>extern double log2 (double);
>
>
>
>
>
>extern double hypot (double, double);
>
>
>
>
>
>
>extern float atanf (float);
>extern float cosf (float);
>extern float sinf (float);
>extern float tanf (float);
>extern float tanhf (float);
>extern float frexpf (float, int *);
>extern float modff (float, float *);
>extern float ceilf (float);
>extern float fabsf (float);
>extern float floorf (float);
>
>
>extern float acosf (float);
>extern float asinf (float);
>extern float atan2f (float, float);
>extern float coshf (float);
>extern float sinhf (float);
>extern float expf (float);
>extern float ldexpf (float, int);
>extern float logf (float);
>extern float log10f (float);
>extern float powf (float, float);
>extern float sqrtf (float);
>extern float fmodf (float, float);
>
>
>
>
>extern float exp2f (float);
>extern float scalblnf (float, long int);
>extern float tgammaf (float);
>extern float nearbyintf (float);
>extern long int lrintf (float);
>extern long long int llrintf (float);
>extern float roundf (float);
>extern long int lroundf (float);
>extern long long int llroundf (float);
>extern float truncf (float);
>extern float remquof (float, float, int *);
>extern float fdimf (float, float);
>extern float fmaxf (float, float);
>extern float fminf (float, float);
>extern float fmaf (float, float, float);
>
>extern float infinityf (void);
>extern float nanf (const char *);
>extern int finitef (float);
>extern float copysignf (float, float);
>extern float logbf (float);
>extern int ilogbf (float);
>
>extern float asinhf (float);
>extern float cbrtf (float);
>extern float nextafterf (float, float);
>extern float rintf (float);
>extern float scalbnf (float, int);
>extern float log1pf (float);
>extern float expm1f (float);
>
>
>extern float acoshf (float);
>extern float atanhf (float);
>extern float remainderf (float, float);
>extern float gammaf (float);
>extern float lgammaf (float);
>extern float erff (float);
>extern float erfcf (float);
>extern float log2f (float);
>extern float hypotf (float, float);
>
>
>
>
>
>
>extern long double atanl (long double);
>extern long double cosl (long double);
>extern long double sinl (long double);
>extern long double tanl (long double);
>extern long double tanhl (long double);
>extern long double frexpl (long double, int *);
>extern long double modfl (long double, long double *);
>extern long double ceill (long double);
>extern long double fabsl (long double);
>extern long double floorl (long double);
>extern long double log1pl (long double);
>extern long double expm1l (long double);
>
>
>
>
>extern long double acosl (long double);
>extern long double asinl (long double);
>extern long double atan2l (long double, long double);
>extern long double coshl (long double);
>extern long double sinhl (long double);
>extern long double expl (long double);
>extern long double ldexpl (long double, int);
>extern long double logl (long double);
>extern long double log10l (long double);
>extern long double powl (long double, long double);
>extern long double sqrtl (long double);
>extern long double fmodl (long double, long double);
>extern long double hypotl (long double, long double);
>
>
>extern long double copysignl (long double, long double);
>extern long double nanl (const char *);
>extern int ilogbl (long double);
>extern long double asinhl (long double);
>extern long double cbrtl (long double);
>extern long double nextafterl (long double, long double);
>extern float nexttowardf (float, long double);
>extern double nexttoward (double, long double);
>extern long double nexttowardl (long double, long double);
>extern long double logbl (long double);
>extern long double log2l (long double);
>extern long double rintl (long double);
>extern long double scalbnl (long double, int);
>extern long double exp2l (long double);
>extern long double scalblnl (long double, long);
>extern long double tgammal (long double);
>extern long double nearbyintl (long double);
>extern long int lrintl (long double);
>extern long long int llrintl (long double);
>extern long double roundl (long double);
>extern long lroundl (long double);
>extern long long int llroundl (long double);
>extern long double truncl (long double);
>extern long double remquol (long double, long double, int *);
>extern long double fdiml (long double, long double);
>extern long double fmaxl (long double, long double);
>extern long double fminl (long double, long double);
>extern long double fmal (long double, long double, long double);
>
>extern long double acoshl (long double);
>extern long double atanhl (long double);
>extern long double remainderl (long double, long double);
>extern long double lgammal (long double);
>extern long double erfl (long double);
>extern long double erfcl (long double);
># 469 "/usr/arm-none-eabi/include/math.h" 3
>extern double drem (double, double);
>extern void sincos (double, double *, double *);
>extern double gamma_r (double, int *);
>extern double lgamma_r (double, int *);
>
>extern double y0 (double);
>extern double y1 (double);
>extern double yn (int, double);
>extern double j0 (double);
>extern double j1 (double);
>extern double jn (int, double);
>
>extern float dremf (float, float);
>extern void sincosf (float, float *, float *);
>extern float gammaf_r (float, int *);
>extern float lgammaf_r (float, int *);
>
>extern float y0f (float);
>extern float y1f (float);
>extern float ynf (int, float);
>extern float j0f (float);
>extern float j1f (float);
>extern float jnf (int, float);
>
>
>
>extern double exp10 (double);
>
>
>extern double pow10 (double);
>
>
>extern float exp10f (float);
>
>
>extern float pow10f (float);
># 514 "/usr/arm-none-eabi/include/math.h" 3
>extern int *__signgam (void);
># 525 "/usr/arm-none-eabi/include/math.h" 3
>struct exception
>
>{
>  int type;
>  char *name;
>  double arg1;
>  double arg2;
>  double retval;
>  int err;
>};
>
>
>
>
>extern int matherr (struct exception *e);
># 589 "/usr/arm-none-eabi/include/math.h" 3
>enum __fdlibm_version
>{
>  __fdlibm_ieee = -1,
>  __fdlibm_svid,
>  __fdlibm_xopen,
>  __fdlibm_posix
>};
>
>
>
>
>extern enum __fdlibm_version __fdlib_version;
># 609 "/usr/arm-none-eabi/include/math.h" 3
>
># 16 "src/random.c" 2
># 44 "src/random.c"
>static uint32_t STATE[32];
># 66 "src/random.c"
>void init_WELL1024a_simp (void)
>{
>
>    for (int j = 0; j < 32; j++) {
> STATE[j] = mars_kiss64_simp();
>
>
>    }
>
>}
>
>
>
>uint32_t WELL1024a_simp (void)
>{
>    static uint32_t state_i = 0;
>    uint32_t z0, z1, z2;
>
>    z0 = STATE[(state_i+31) & 0x0000001fU];
>    z1 = (STATE[state_i ]) ^ (STATE[(state_i+3) & 0x0000001fU]^(STATE[(state_i+3) & 0x0000001fU]>>8));
>    z2 = (STATE[(state_i+24) & 0x0000001fU]^(STATE[(state_i+24) & 0x0000001fU]<<(-(-19)))) ^ (STATE[(state_i+10) & 0x0000001fU]^(STATE[(state_i+10) & 0x0000001fU]<<(-(-14))));
>    STATE[state_i ] = z1 ^ z2;
>    STATE[(state_i+31) & 0x0000001fU] = (z0^(z0<<(-(-11)))) ^ (z1^(z1<<(-(-7)))) ^ (z2^(z2<<(-(-13))));
>    state_i = (state_i + 31) & 0x0000001fU;
>
>    return (STATE [state_i]);
>}
>
>
>
>
>void validate_WELL1024a_seed (WELL1024a_seed_t seed)
>{
>    seed[33] = 0;
>}
>
>
>
>
>uint32_t WELL1024a_seed (WELL1024a_seed_t STATE)
>{
>    uint32_t z0, z1, z2;
>
>    z0 = STATE[(STATE[33]+31) & 0x0000001fU];
>    z1 = (STATE[STATE[33] ]) ^ (STATE[(STATE[33]+3) & 0x0000001fU]^(STATE[(STATE[33]+3) & 0x0000001fU]>>8));
>    z2 = (STATE[(STATE[33]+24) & 0x0000001fU]^(STATE[(STATE[33]+24) & 0x0000001fU]<<(-(-19)))) ^ (STATE[(STATE[33]+10) & 0x0000001fU]^(STATE[(STATE[33]+10) & 0x0000001fU]<<(-(-14))));
>    STATE[STATE[33] ] = z1 ^ z2;
>    STATE[(STATE[33]+31) & 0x0000001fU] = (z0^(z0<<(-(-11)))) ^ (z1^(z1<<(-(-7)))) ^ (z2^(z2<<(-(-13))));
>    STATE[33] = (STATE[33] + 31) & 0x0000001fU;
>
>    return (STATE [STATE[33]]);
>}
># 150 "src/random.c"
>uint32_t mars_kiss32 (void)
>{
>    static uint32_t
>        x = 123456789,
>        y = 234567891,
>        z = 345678912,
>        w = 456789123,
>        c = 0;
>    int32_t t;
>
>    y ^= ( y << 5);
>    y ^= ( y >> 7);
>    y ^= ( y << 22);
>    t = z + w + c;
>    z = w;
>    c = t < 0;
>    w = t & 2147483647;
>    x += 1411392427;
>
>    return ((uint32_t)x + y + w);
>}
># 180 "src/random.c"
>uint32_t mars_kiss64_simp (void)
>{
>    static uint32_t
>        x = 123456789,
>        y = 987654321,
>        z = 43219876,
>        c = 6543217;
>    uint64_t t;
>
>    x = 314527869 * x + 1234567;
>    y ^= y << 5;
>    y ^= y >> 7;
>    y ^= y << 22;
>    t = 4294584393ULL * z + c;
>    c = t >> 32;
>    z = t;
>
>    return ((uint32_t)x + y + z);
>}
># 210 "src/random.c"
>uint32_t mars_kiss64_seed (mars_kiss64_seed_t seed)
>{
>    uint64_t t;
>
>    seed[0] = 314527869 * seed[0] + 1234567;
>    seed[1] ^= seed[1] << 5;
>    seed[1] ^= seed[1] >> 7;
>    seed[1] ^= seed[1] << 22;
>    t = 4294584393ULL * seed[2] + seed[3];
>    seed[3] = t >> 32;
>    seed[2] = t;
>
>    return ((uint32_t)seed[0] + seed[1] + seed[2]);
>}
>
>
>
>
>
>
>
>void validate_mars_kiss64_seed (mars_kiss64_seed_t seed)
>{
>    if (seed[1] == 0)
>        seed[1] = 13031301;
>
>
>    seed[3] = seed[3] % 698769068 + 1;
>
>}
># 260 "src/random.c"
>_Accum exponential_dist_variate (uniform_rng uni_rng, uint32_t* seed_arg)
>{
>    _Accum A = 0.0k;
>    uint32_t U, U0, USTAR;
>
>outer:
>    U = uni_rng (seed_arg);
>    U0 = U;
>
>inner:
>    USTAR = uni_rng (seed_arg);
>    if (U < USTAR) return A + (_Accum) ulrbits (U0);
>
>
>    U = uni_rng (seed_arg);
>    if (U < USTAR) goto inner;
>
>    A += 1.0k;
>    goto outer;
>}
>
>
>
>
>
>
>_Accum gaussian_dist_variate (uniform_rng uni_rng, uint32_t* seed_arg)
>{
>    static _Bool set = 0;
>    static float gset;
>    float fac, rsq, v1, v2;
>
>    if (!set) {
> do {
>     v1 = (uni_rng (seed_arg) / 2147483648.0f) - 1.0f;
>
>     v2 = (uni_rng (seed_arg) / 2147483648.0f) - 1.0f;
>
>     rsq = v1*v1 + v2*v2;
> } while (rsq >= 1.0f || rsq == 0.0f);
>
> fac = sqrtf (-2.0f * logf (rsq) / rsq);
>
> gset = v1 * fac;
> set = 1;
> return ((_Accum) v2 * fac);
>    }
>    else {
> set = 0;
> return ((_Accum) gset);
>    }
>}
># 320 "src/random.c"
>uint32_t poisson_dist_variate (uniform_rng uni_rng,
>                               uint32_t* seed_arg,
>          _Accum lambda)
>{
>    unsigned long _Fract exp_minus_lambda = (unsigned long _Fract) expk (-lambda);
>
>
>
>    return (poisson_dist_variate_exp_minus_lambda (uni_rng, seed_arg, exp_minus_lambda));
>}
>
>
>
>
>
>
>
>uint32_t poisson_dist_variate_exp_minus_lambda
>    (uniform_rng uni_rng,
>     uint32_t* seed_arg,
>     unsigned long _Fract exp_minus_lambda)
>{
>    unsigned long _Fract p = 1.0ulr;
>    uint32_t k = 0;
># 354 "src/random.c"
>    do {
> k++;
> p *= ulrbits (uni_rng (seed_arg));
>    } while (p > exp_minus_lambda);
>
>    return (k - 1);
>}

Actions: View

Attachments on bug 1241978: 1050707