futhark 0.25.29 → 0.25.30

raw patch · 39 files changed

+3212/−4318 lines, 39 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +45/−0
• docs/error-index.rst +22/−0
• docs/language-reference.rst +14/−8
• futhark.cabal +1/−1
• prelude/ad.fut +16/−11
• prelude/array.fut +1/−1
• prelude/functional.fut +7/−7
• prelude/math.fut +170/−125
• prelude/prelude.fut +10/−8
• prelude/zip.fut +2/−1
• rts/c/atomics.h +20/−20
• rts/c/scalar.h +1845/−3026
• rts/c/scalar_f16.h +225/−761
• rts/cuda/prelude.cu +15/−0
• rts/opencl/transpose.cl +4/−0
• rts/python/scalar.py +100/−0
• src/Futhark/AD/Derivatives.hs +57/−0
• src/Futhark/AD/Fwd.hs +1/−1
• src/Futhark/AD/Rev.hs +3/−24
• src/Futhark/AD/Rev/Monad.hs +64/−52
• src/Futhark/AD/Rev/SOAC.hs +3/−0
• src/Futhark/Analysis/HORep/MapNest.hs +148/−88
• src/Futhark/Analysis/HORep/SOAC.hs +14/−0
• src/Futhark/CLI/Run.hs +1/−1
• src/Futhark/CodeGen/ImpGen/GPU/SegHist.hs +1/−1
• src/Futhark/IR/SOACS/Simplify.hs +76/−2
• src/Futhark/Internalise/Entry.hs +7/−2
• src/Futhark/Internalise/LiftLambdas.hs +1/−1
• src/Futhark/Internalise/Monomorphise.hs +8/−3
• src/Futhark/Optimise/Fusion/TryFusion.hs +26/−49
• src/Futhark/Optimise/Simplify/Engine.hs +7/−0
• src/Futhark/Optimise/Simplify/Rules/Simple.hs +1/−0
• src/Futhark/Pass/ExplicitAllocations/GPU.hs +3/−1
• src/Futhark/Pkg/Types.hs +1/−1
• src/Language/Futhark/Interpreter.hs +80/−47
• src/Language/Futhark/Interpreter/AD.hs +149/−60
• src/Language/Futhark/Interpreter/Values.hs +8/−16
• src/Language/Futhark/Primitive.hs +55/−0
• src/Language/Futhark/TypeChecker/Consumption.hs +1/−0

@@ -5,6 +5,47 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). +## [0.25.30]++### Added++* New math functions: `f16.rsqrt`, `f32.rsqrt`, `f64.rsqrt`.++* New math functions: `cospi`, `sinpi`, `tanpi`, `acospi`, `asinpi`,+  `atanpi`, `atan2pi`, in each of the `f16`/`f32`/`f64` modules. (#2243)++* Slight improvements in the ability of the fusion engine to fuse+  across `map` nests separated by `reshape` operations. Only works if+  the innermost return type is purely scalar.++* `futhark pkg` now allows underscores in package paths.++### Fixed++* The interpreter no longer crashes when passing a sum-typed value+  into AD, but it is unlikely to produce a usable result (#2238).++* The partial derivatives of comparisons are now always zero.+  Previously we had some code that made an attempt at giving these+  another interpretation, but it was never mathematically sound, not+  useful, and sometimes buggy. (#2239).++* Out-of-bounds reads in GPU backends when transposing a great many+  matrices in parallel (#2241).++* `vjp` in the interpreter is now asymptotically efficient (#2187,+  #2240). Work by Marcus Jensen.++* The interpreter did not handle `open` correctly.++* Incorrect handling of some size inference edge cases during+  monomorphisation (#2252).++* Incorrect registration of entry point types when mixing type+  abbreviations and arrays (#2253).++* Reverse mode AD now handles sequential streams. (#2256)+ ## [0.25.29]  ### Fixed@@ -29,6 +70,10 @@   ways (#2234).  * Fusion could crash after AD in some circumstances (#2236).++* Under very unlikely circumstances, an "intrablock" flat parallel+  operation could be hoisted out of its enclosing GPU kernel, causing+  a compiler crash.  ## [0.25.28] 

@@ -367,6 +367,28 @@ Here the type rules force ``A`` to have size ``x``, leading to a problematic type.  It can be fixed using the techniques above. +.. _aliases-previously-returned:++"Return value for consuming loop parameter *x* aliases previously returned value"+---------------------------------------------------------------------------------++This error occurs when you have a loop with multiple loop parameters,+at least one of which is consuming, and the values returned by the+loop body alias each other. This would result in the consuming loop+parameter aliasing another loop parameter, which is not allowed. It is+essentially :ref:`unique-return-aliased` from a loop perspective.++A (contrived) example of this error is the following:++.. code-block:: futhark++  loop (acc: []f64, arr: *[][]f64) for i < length arr-1 do+    let arr[i] = acc+    -- Error, because 'arr[i]' and 'arr' are aliased, yet the latter+    -- is consumed.+    in (arr[i+1], arr)++ Size errors ----------- 

@@ -370,15 +370,21 @@ ~~~~~~~~~~~~  Apart from declaring a function with the keyword ``def``, it can also-be declared with ``entry``.  When the Futhark program is compiled any-top-level function declared with ``entry`` will be exposed as an entry-point.  If the Futhark program has been compiled as a library, these-are the functions that will be exposed.  If compiled as an executable,-you can use the ``--entry-point`` command line option of the generated-executable to select the entry point you wish to run.+be declared with ``entry``. When the Futhark program is compiled any+top-level function declared with ``entry`` *in the single file passed+directly to the Futhark compiler* will be exposed as an entry point.+This means that any functions defined with ``entry`` in a file that is+accessed via ``import`` are not considered entry points, but they are+still usable as normal functions. -Any top-level function named ``main`` will always be considered an-entry point, whether it is declared with ``entry`` or not.+If the Futhark program has been compiled as a library, these entry+points are the functions that will be exposed as the library+interface. If compiled as an executable, you can use the+``--entry-point`` command line option of the generated executable to+select the entry point you wish to run.++Any top-level function named ``main`` is treated as if it had been+defined with ``entry``.  The name of an entry point must not contain an apostrophe (``'``), even though that is normally permitted in Futhark identifiers.

@@ -1,6 +1,6 @@ cabal-version: 2.4 name:           futhark-version:        0.25.29+version:        0.25.30 synopsis:       An optimising compiler for a functional, array-oriented language.  description:    Futhark is a small programming language designed to be compiled to

@@ -55,23 +55,23 @@ -- Both `jvp` and `vjp` work by transforming the program to carry -- along extra information associated with each scalar value. ----- In the case of `vjp`, this extra information takes the form of an+-- In the case of `jvp`, this extra information takes the form of an -- additional scalar representing the tangent, which is then -- propagated in each scalar computation using essentially the [chain -- rule](https://en.wikipedia.org/wiki/Chain_rule). Therefore, `jvp` -- has a memory overhead of approximately *2x*, and a computational -- overhead of slightly more, but usually less than *4x*. ----- In the case of `jvp`, since our starting point is a *cotangent*,+-- In the case of `vjp`, since our starting point is a *cotangent*, -- the function is essentially first run forward, then backwards (the -- *return sweep*) to propagate the cotangent. During the return -- sweep, all intermediate results computed during the forward sweep -- must still be available, and must therefore be stored in memory--- during the forward sweep. This means that the memory usage of `jvp`--- is essentially proportional to the number of sequential steps of--- the original function (essentially turning *time* into *space*).--- The compiler does a nontrivial amount of optimisation to ameliorate--- this overhead (see [AD for an Array Language with Nested+-- during the forward sweep. This means that the memory usage of `vjp`+-- is proportional to the number of sequential steps of the original+-- function (essentially turning *time* into *space*). The compiler+-- does a nontrivial amount of optimisation to ameliorate this+-- overhead (see [AD for an Array Language with Nested -- Parallelism](https://futhark-lang.org/publications/sc22-ad.pdf)), -- but it can still be substantial for programs with deep sequential -- loops.@@ -85,6 +85,11 @@ -- primitive floating-point operations, without ever converting to or -- from integers. --+-- Note that a function whose input or output is a sum type with more+-- than one constructor is *not* differentiable (or at least the+-- sum-typed part is not). This is because the choice of constructor+-- is not a continuous quantity.+-- -- ## Limitations -- -- `jvp` is expected to work in all cases. `vjp` has limitations when@@ -95,18 +100,18 @@  -- | Jacobian-Vector Product ("forward mode"), producing also the -- primal result as the first element of the result tuple.-def jvp2 'a 'b (f: a -> b) (x: a) (x': a): (b, b) =+def jvp2 'a 'b (f: a -> b) (x: a) (x': a) : (b, b) =   intrinsics.jvp2 f x x'  -- | Vector-Jacobian Product ("reverse mode"), producing also the -- primal result as the first element of the result tuple.-def vjp2 'a 'b (f: a -> b) (x: a) (y': b): (b, a) =+def vjp2 'a 'b (f: a -> b) (x: a) (y': b) : (b, a) =   intrinsics.vjp2 f x y'  -- | Jacobian-Vector Product ("forward mode").-def jvp 'a 'b (f: a -> b) (x: a) (x': a): b =+def jvp 'a 'b (f: a -> b) (x: a) (x': a) : b =   (jvp2 f x x').1  -- | Vector-Jacobian Product ("reverse mode").-def vjp 'a 'b (f: a -> b) (x: a) (y': b): a =+def vjp 'a 'b (f: a -> b) (x: a) (y': b) : a =   (vjp2 f x y').1

@@ -3,7 +3,7 @@ import "math" import "soacs" import "functional"-open import "zip" -- Rexport.+open import "zip"  -- | The size of the outer dimension of an array. --

@@ -6,7 +6,7 @@ -- ``` -- x |> f |> g |> h -- ```-def (|>) '^a '^b (x: a) (f: a -> b): b = f x+def (|>) '^a '^b (x: a) (f: a -> b) : b = f x  -- | Right to left application. --@@ -35,35 +35,35 @@ -- ``` -- -- In such cases you can use the pipe operator `|>`@term instead.-def (>->) '^a '^b '^c (f: a -> b) (g: b -> c) (x: a): c = g (f x)+def (>->) '^a '^b '^c (f: a -> b) (g: b -> c) (x: a) : c = g (f x)  -- | Function composition, with values flowing from right to left. -- This is the same as the `∘` operator known from mathematics. -- -- Has the same restrictions with respect to anonymous sizes as -- `>->`@term.-def (<-<) '^a '^b '^c (g: b -> c) (f: a -> b) (x: a): c = g (f x)+def (<-<) '^a '^b '^c (g: b -> c) (f: a -> b) (x: a) : c = g (f x)  -- | Flip the arguments passed to a function. -- -- ``` -- f x y == flip f y x -- ```-def flip '^a '^b '^c (f: a -> b -> c) (b: b) (a: a): c =+def flip '^a '^b '^c (f: a -> b -> c) (b: b) (a: a) : c =   f a b  -- | Transform a function taking a pair into a function taking two -- arguments.-def curry '^a '^b '^c (f: (a, b) -> c) (a: a) (b: b): c =+def curry '^a '^b '^c (f: (a, b) -> c) (a: a) (b: b) : c =   f (a, b)  -- | Transform a function taking two arguments in a function taking a -- pair.-def uncurry '^a '^b '^c (f: a -> b -> c) (a: a, b: b): c =+def uncurry '^a '^b '^c (f: a -> b -> c) (a: a, b: b) : c =   f a b  -- | The constant function.-def const '^a '^b (x: a) (_: b): a = x+def const '^a '^b (x: a) (_: b) : a = x  -- | The identity function. def id '^a (x: a) = x

@@ -7,21 +7,21 @@ module type from_prim = {   type t -  val i8: i8 -> t-  val i16: i16 -> t-  val i32: i32 -> t-  val i64: i64 -> t+  val i8 : i8 -> t+  val i16 : i16 -> t+  val i32 : i32 -> t+  val i64 : i64 -> t -  val u8: u8 -> t-  val u16: u16 -> t-  val u32: u32 -> t-  val u64: u64 -> t+  val u8 : u8 -> t+  val u16 : u16 -> t+  val u32 : u32 -> t+  val u64 : u64 -> t -  val f16: f16 -> t-  val f32: f32 -> t-  val f64: f64 -> t+  val f16 : f16 -> t+  val f32 : f32 -> t+  val f64 : f64 -> t -  val bool: bool -> t+  val bool : bool -> t }  -- | A basic numeric module type that can be implemented for both@@ -29,51 +29,51 @@ module type numeric = {   include from_prim -  val +: t -> t -> t-  val -: t -> t -> t-  val *: t -> t -> t-  val /: t -> t -> t-  val %: t -> t -> t-  val **: t -> t -> t+  val + : t -> t -> t+  val - : t -> t -> t+  val * : t -> t -> t+  val / : t -> t -> t+  val % : t -> t -> t+  val ** : t -> t -> t -  val to_i64: t -> i64+  val to_i64 : t -> i64 -  val ==: t -> t -> bool-  val <: t -> t -> bool-  val >: t -> t -> bool-  val <=: t -> t -> bool-  val >=: t -> t -> bool-  val !=: t -> t -> bool+  val == : t -> t -> bool+  val < : t -> t -> bool+  val > : t -> t -> bool+  val <= : t -> t -> bool+  val >= : t -> t -> bool+  val != : t -> t -> bool    -- | Arithmetic negation (use `!` for bitwise negation).-  val neg: t -> t-  val max: t -> t -> t-  val min: t -> t -> t+  val neg : t -> t+  val max : t -> t -> t+  val min : t -> t -> t -  val abs: t -> t+  val abs : t -> t    -- | Sign function.  Produces -1, 0, or 1 if the argument is   -- respectively less than, equal to, or greater than zero.-  val sgn: t -> t+  val sgn : t -> t    -- | The most positive representable number.-  val highest: t+  val highest : t    -- | The least positive representable number (most negative for   -- signed types).-  val lowest: t+  val lowest : t    -- | Returns zero on empty input.-  val sum [n]: [n]t -> t+  val sum [n] : [n]t -> t    -- | Returns one on empty input.-  val product [n]: [n]t -> t+  val product [n] : [n]t -> t    -- | Returns `lowest` on empty input.-  val maximum [n]: [n]t -> t+  val maximum [n] : [n]t -> t    -- | Returns `highest` on empty input.-  val minimum [n]: [n]t -> t+  val minimum [n] : [n]t -> t }  -- | An extension of `numeric`@mtype that provides facilities that are@@ -83,57 +83,57 @@    -- | Like `/`@term, but rounds towards zero.  This only matters when   -- one of the operands is negative.  May be more efficient.-  val //: t -> t -> t+  val // : t -> t -> t    -- | Like `%`@term, but rounds towards zero.  This only matters when   -- one of the operands is negative.  May be more efficient.-  val %%: t -> t -> t+  val %% : t -> t -> t    -- | Bitwise and.-  val &: t -> t -> t+  val & : t -> t -> t    -- | Bitwise or.-  val |: t -> t -> t+  val | : t -> t -> t    -- | Bitwise xor.-  val ^: t -> t -> t+  val ^ : t -> t -> t    -- | Bitwise negation.-  val not: t -> t+  val not : t -> t    -- | Left shift; inserting zeroes.-  val <<: t -> t -> t+  val << : t -> t -> t    -- | Arithmetic right shift, using sign extension for the leftmost bits.-  val >>: t -> t -> t+  val >> : t -> t -> t    -- | Logical right shift, inserting zeroes for the leftmost bits.-  val >>>: t -> t -> t+  val >>> : t -> t -> t -  val num_bits: i32-  val get_bit: i32 -> t -> i32-  val set_bit: i32 -> t -> i32 -> t+  val num_bits : i32+  val get_bit : i32 -> t -> i32+  val set_bit : i32 -> t -> i32 -> t    -- | Count number of one bits.-  val popc: t -> i32+  val popc : t -> i32    -- | Computes `x * y` and returns the high half of the product of x   -- and y.-  val mul_hi: (x: t) -> (y: t) -> t+  val mul_hi : (x: t) -> (y: t) -> t    -- | Computes `mul_hi a b + c`, but perhaps in a more efficient way,   -- depending on the target platform.-  val mad_hi: (a: t) -> (b: t) -> (c: t) -> t+  val mad_hi : (a: t) -> (b: t) -> (c: t) -> t    -- | Count number of zero bits preceding the most significant set   -- bit.  Returns the number of bits in the type if the argument is   -- zero.-  val clz: t -> i32+  val clz : t -> i32    -- | Count number of trailing zero bits following the least   -- significant set bit.  Returns the number of bits in the type if   -- the argument is zero.-  val ctz: t -> i32+  val ctz : t -> i32 }  -- | Numbers that model real numbers to some degree.@@ -141,105 +141,126 @@   include numeric    -- | Multiplicative inverse.-  val recip: t -> t+  val recip : t -> t -  val from_fraction: i64 -> i64 -> t-  val to_i64: t -> i64-  val to_f64: t -> f64+  val from_fraction : i64 -> i64 -> t+  val to_i64 : t -> i64+  val to_f64 : t -> f64    -- | Square root.-  val sqrt: t -> t+  val sqrt : t -> t +  -- | Inverse square root. Depending on the backend, this may be+  -- faster than `1/sqrt(x)`.+  val rsqrt : t -> t+   -- | Cube root.-  val cbrt: t -> t-  val exp: t -> t+  val cbrt : t -> t+  val exp : t -> t -  val sin: t -> t-  val cos: t -> t-  val tan: t -> t+  val sin : t -> t+  val cos : t -> t+  val tan : t -> t -  val asin: t -> t-  val acos: t -> t-  val atan: t -> t+  -- | `sin(pi*x)` - depending on backing, may be faster or more+  -- accurate.+  val sinpi : t -> t -  val sinh: t -> t-  val cosh: t -> t-  val tanh: t -> t+  -- | `cos(pi*x)` - depending on backing, may be faster or more+  -- accurate.+  val cospi : t -> t -  val asinh: t -> t-  val acosh: t -> t-  val atanh: t -> t+  -- | `tan(pi*x)` - depending on backing, may be faster or more+  -- accurate.+  val tanpi : t -> t -  val atan2: t -> t -> t+  val asin : t -> t+  val acos : t -> t+  val atan : t -> t +  val asinpi : t -> t+  val acospi : t -> t+  val atanpi : t -> t++  val sinh : t -> t+  val cosh : t -> t+  val tanh : t -> t++  val asinh : t -> t+  val acosh : t -> t+  val atanh : t -> t++  val atan2 : t -> t -> t+  val atan2pi : t -> t -> t+   -- | Compute the length of the hypotenuse of a right-angled   -- triangle.  That is, `hypot x y` computes *√(x²+y²)*.  Put another   -- way, the distance of *(x,y)* from origin in an Euclidean space.   -- The calculation is performed without undue overflow or underflow   -- during intermediate steps (specific accuracy depends on the   -- backend).-  val hypot: t -> t -> t+  val hypot : t -> t -> t    -- | The true Gamma function.-  val gamma: t -> t+  val gamma : t -> t    -- | The natural logarithm of the absolute value of `gamma`@term.-  val lgamma: t -> t+  val lgamma : t -> t    -- | The error function.-  val erf: t -> t+  val erf : t -> t    -- | The complementary error function.-  val erfc: t -> t+  val erfc : t -> t    -- | Linear interpolation.  The third argument must be in the range   -- `[0,1]` or the results are unspecified.-  val lerp: t -> t -> t -> t+  val lerp : t -> t -> t -> t    -- | Natural logarithm.-  val log: t -> t+  val log : t -> t    -- | Base-2 logarithm.-  val log2: t -> t+  val log2 : t -> t    -- | Base-10 logarithm.-  val log10: t -> t+  val log10 : t -> t    -- | Compute `log (1 + x)` accurately even when `x` is very small.-  val log1p: t -> t+  val log1p : t -> t    -- | Round towards infinity.-  val ceil: t -> t+  val ceil : t -> t    -- | Round towards negative infinity.-  val floor: t -> t+  val floor : t -> t    -- | Round towards zero.-  val trunc: t -> t+  val trunc : t -> t    -- | Round to the nearest integer, with halfway cases rounded to the   -- nearest even integer.  Note that this differs from `round()` in   -- C, but matches more modern languages.-  val round: t -> t+  val round : t -> t    -- | Computes `a*b+c`.  Depending on the compiler backend, this may   -- be fused into a single operation that is faster but less   -- accurate.  Do not confuse it with `fma`@term.-  val mad: (a: t) -> (b: t) -> (c: t) -> t+  val mad : (a: t) -> (b: t) -> (c: t) -> t    -- | Computes `a*b+c`, with `a*b` being rounded with infinite   -- precision.  Rounding of intermediate products shall not   -- occur. Edge case behavior is per the IEEE 754-2008 standard.-  val fma: (a: t) -> (b: t) -> (c: t) -> t+  val fma : (a: t) -> (b: t) -> (c: t) -> t -  val isinf: t -> bool-  val isnan: t -> bool+  val isinf : t -> bool+  val isnan : t -> bool -  val inf: t-  val nan: t+  val inf : t+  val nan : t -  val pi: t-  val e: t+  val pi : t+  val e : t }  -- | An extension of `real`@mtype that further gives access to the@@ -255,31 +276,31 @@   -- 't'.   type int_t -  val from_bits: int_t -> t-  val to_bits: t -> int_t+  val from_bits : int_t -> t+  val to_bits : t -> int_t -  val num_bits: i32-  val get_bit: i32 -> t -> i32-  val set_bit: i32 -> t -> i32 -> t+  val num_bits : i32+  val get_bit : i32 -> t -> i32+  val set_bit : i32 -> t -> i32 -> t    -- | The difference between 1.0 and the next larger representable   -- number.-  val epsilon: t+  val epsilon : t    -- | Produces the next representable number from `x` in the   -- direction of `y`.-  val nextafter: (x: t) -> (y: t) -> t+  val nextafter : (x: t) -> (y: t) -> t    -- | Multiplies floating-point value by 2 raised to an integer power.-  val ldexp: t -> i32 -> t+  val ldexp : t -> i32 -> t    -- | Compose a floating-point value with the magnitude of `x` and the sign of `y`.-  val copysign: (x: t) -> (y: t) -> t+  val copysign : (x: t) -> (y: t) -> t }  -- | Boolean numbers.  When converting from a number to `bool`, 0 is -- considered `false` and any other value is `true`.-module bool: from_prim with t = bool = {+module bool : from_prim with t = bool = {   type t = bool    def i8 = intrinsics.itob_i8_bool@@ -299,7 +320,7 @@   def bool (x: bool) = x } -module i8: (integral with t = i8) = {+module i8 : (integral with t = i8) = {   type t = i8    def (+) (x: i8) (y: i8) = intrinsics.add8 (x, y)@@ -374,7 +395,7 @@   def minimum = reduce min highest } -module i16: (integral with t = i16) = {+module i16 : (integral with t = i16) = {   type t = i16    def (+) (x: i16) (y: i16) = intrinsics.add16 (x, y)@@ -449,7 +470,7 @@   def minimum = reduce min highest } -module i32: (integral with t = i32) = {+module i32 : (integral with t = i32) = {   type t = i32    def sign (x: u32) = intrinsics.sign_i32 x@@ -527,7 +548,7 @@   def minimum = reduce min highest } -module i64: (integral with t = i64) = {+module i64 : (integral with t = i64) = {   type t = i64    def sign (x: u64) = intrinsics.sign_i64 x@@ -605,7 +626,7 @@   def minimum = reduce min highest } -module u8: (integral with t = u8) = {+module u8 : (integral with t = u8) = {   type t = u8    def sign (x: u8) = intrinsics.sign_i8 x@@ -683,7 +704,7 @@   def minimum = reduce min highest } -module u16: (integral with t = u16) = {+module u16 : (integral with t = u16) = {   type t = u16    def sign (x: u16) = intrinsics.sign_i16 x@@ -761,7 +782,7 @@   def minimum = reduce min highest } -module u32: (integral with t = u32) = {+module u32 : (integral with t = u32) = {   type t = u32    def sign (x: u32) = intrinsics.sign_i32 x@@ -839,7 +860,7 @@   def minimum = reduce min highest } -module u64: (integral with t = u64) = {+module u64 : (integral with t = u64) = {   type t = u64    def sign (x: u64) = intrinsics.sign_i64 x@@ -917,7 +938,7 @@   def minimum = reduce min highest } -module f64: (float with t = f64 with int_t = u64) = {+module f64 : (float with t = f64 with int_t = u64) = {   type t = f64   type int_t = u64 @@ -967,6 +988,7 @@   def abs (x: f64) = intrinsics.fabs64 x    def sqrt (x: f64) = intrinsics.sqrt64 x+  def rsqrt (x: f64) = intrinsics.rsqrt64 x   def cbrt (x: f64) = intrinsics.cbrt64 x    def log (x: f64) = intrinsics.log64 x@@ -977,9 +999,15 @@   def sin (x: f64) = intrinsics.sin64 x   def cos (x: f64) = intrinsics.cos64 x   def tan (x: f64) = intrinsics.tan64 x+  def sinpi (x: f64) = intrinsics.sinpi64 x+  def cospi (x: f64) = intrinsics.cospi64 x+  def tanpi (x: f64) = intrinsics.tanpi64 x   def acos (x: f64) = intrinsics.acos64 x   def asin (x: f64) = intrinsics.asin64 x   def atan (x: f64) = intrinsics.atan64 x+  def acospi (x: f64) = intrinsics.acospi64 x+  def asinpi (x: f64) = intrinsics.asinpi64 x+  def atanpi (x: f64) = intrinsics.atanpi64 x   def sinh (x: f64) = intrinsics.sinh64 x   def cosh (x: f64) = intrinsics.cosh64 x   def tanh (x: f64) = intrinsics.tanh64 x@@ -987,6 +1015,7 @@   def asinh (x: f64) = intrinsics.asinh64 x   def atanh (x: f64) = intrinsics.atanh64 x   def atan2 (x: f64) (y: f64) = intrinsics.atan2_64 (x, y)+  def atan2pi (x: f64) (y: f64) = intrinsics.atan2pi_64 (x, y)   def hypot (x: f64) (y: f64) = intrinsics.hypot64 (x, y)   def gamma = intrinsics.gamma64   def lgamma = intrinsics.lgamma64@@ -999,7 +1028,7 @@    def ceil = intrinsics.ceil64   def floor = intrinsics.floor64-  def trunc (x: f64): f64 = i64 (i64m.f64 x)+  def trunc (x: f64) : f64 = i64 (i64m.f64 x)    def round = intrinsics.round64 @@ -1007,8 +1036,8 @@   def ldexp x y = intrinsics.ldexp64 (x, y)   def copysign x y = intrinsics.copysign64 (x, y) -  def to_bits (x: f64): u64 = u64m.i64 (intrinsics.to_bits64 x)-  def from_bits (x: u64): f64 = intrinsics.from_bits64 (intrinsics.sign_i64 x)+  def to_bits (x: f64) : u64 = u64m.i64 (intrinsics.to_bits64 x)+  def from_bits (x: u64) : f64 = intrinsics.from_bits64 (intrinsics.sign_i64 x)    def num_bits = 64i32   def get_bit (bit: i32) (x: t) = u64m.get_bit bit (to_bits x)@@ -1033,7 +1062,7 @@   def minimum = reduce min highest } -module f32: (float with t = f32 with int_t = u32) = {+module f32 : (float with t = f32 with int_t = u32) = {   type t = f32   type int_t = u32 @@ -1084,6 +1113,7 @@   def abs (x: f32) = intrinsics.fabs32 x    def sqrt (x: f32) = intrinsics.sqrt32 x+  def rsqrt (x: f32) = intrinsics.rsqrt32 x   def cbrt (x: f32) = intrinsics.cbrt32 x    def log (x: f32) = intrinsics.log32 x@@ -1094,9 +1124,15 @@   def sin (x: f32) = intrinsics.sin32 x   def cos (x: f32) = intrinsics.cos32 x   def tan (x: f32) = intrinsics.tan32 x+  def sinpi (x: f32) = intrinsics.sinpi32 x+  def cospi (x: f32) = intrinsics.cospi32 x+  def tanpi (x: f32) = intrinsics.tanpi32 x   def acos (x: f32) = intrinsics.acos32 x   def asin (x: f32) = intrinsics.asin32 x   def atan (x: f32) = intrinsics.atan32 x+  def acospi (x: f32) = intrinsics.acospi32 x+  def asinpi (x: f32) = intrinsics.asinpi32 x+  def atanpi (x: f32) = intrinsics.atanpi32 x   def sinh (x: f32) = intrinsics.sinh32 x   def cosh (x: f32) = intrinsics.cosh32 x   def tanh (x: f32) = intrinsics.tanh32 x@@ -1104,6 +1140,7 @@   def asinh (x: f32) = intrinsics.asinh32 x   def atanh (x: f32) = intrinsics.atanh32 x   def atan2 (x: f32) (y: f32) = intrinsics.atan2_32 (x, y)+  def atan2pi (x: f32) (y: f32) = intrinsics.atan2pi_32 (x, y)   def hypot (x: f32) (y: f32) = intrinsics.hypot32 (x, y)   def gamma = intrinsics.gamma32   def lgamma = intrinsics.lgamma32@@ -1116,7 +1153,7 @@    def ceil = intrinsics.ceil32   def floor = intrinsics.floor32-  def trunc (x: f32): f32 = i32 (i32m.f32 x)+  def trunc (x: f32) : f32 = i32 (i32m.f32 x)    def round = intrinsics.round32 @@ -1124,8 +1161,8 @@   def ldexp x y = intrinsics.ldexp32 (x, y)   def copysign x y = intrinsics.copysign32 (x, y) -  def to_bits (x: f32): u32 = u32m.i32 (intrinsics.to_bits32 x)-  def from_bits (x: u32): f32 = intrinsics.from_bits32 (intrinsics.sign_i32 x)+  def to_bits (x: f32) : u32 = u32m.i32 (intrinsics.to_bits32 x)+  def from_bits (x: u32) : f32 = intrinsics.from_bits32 (intrinsics.sign_i32 x)    def num_bits = 32i32   def get_bit (bit: i32) (x: t) = u32m.get_bit bit (to_bits x)@@ -1154,7 +1191,7 @@ -- support half precision.  This means you might get more accurate -- results than on real systems, but it is also likely to be -- significantly slower than just using `f32` in the first place.-module f16: (float with t = f16 with int_t = u16) = {+module f16 : (float with t = f16 with int_t = u16) = {   type t = f16   type int_t = u16 @@ -1205,6 +1242,7 @@   def abs (x: f16) = intrinsics.fabs16 x    def sqrt (x: f16) = intrinsics.sqrt16 x+  def rsqrt (x: f16) = intrinsics.rsqrt16 x   def cbrt (x: f16) = intrinsics.cbrt16 x    def log (x: f16) = intrinsics.log16 x@@ -1215,9 +1253,15 @@   def sin (x: f16) = intrinsics.sin16 x   def cos (x: f16) = intrinsics.cos16 x   def tan (x: f16) = intrinsics.tan16 x+  def sinpi (x: f16) = intrinsics.sinpi16 x+  def cospi (x: f16) = intrinsics.cospi16 x+  def tanpi (x: f16) = intrinsics.tanpi16 x   def acos (x: f16) = intrinsics.acos16 x   def asin (x: f16) = intrinsics.asin16 x   def atan (x: f16) = intrinsics.atan16 x+  def acospi (x: f16) = intrinsics.acospi16 x+  def asinpi (x: f16) = intrinsics.asinpi16 x+  def atanpi (x: f16) = intrinsics.atanpi16 x   def sinh (x: f16) = intrinsics.sinh16 x   def cosh (x: f16) = intrinsics.cosh16 x   def tanh (x: f16) = intrinsics.tanh16 x@@ -1225,6 +1269,7 @@   def asinh (x: f16) = intrinsics.asinh16 x   def atanh (x: f16) = intrinsics.atanh16 x   def atan2 (x: f16) (y: f16) = intrinsics.atan2_16 (x, y)+  def atan2pi (x: f16) (y: f16) = intrinsics.atan2pi_16 (x, y)   def hypot (x: f16) (y: f16) = intrinsics.hypot16 (x, y)   def gamma = intrinsics.gamma16   def lgamma = intrinsics.lgamma16@@ -1237,7 +1282,7 @@    def ceil = intrinsics.ceil16   def floor = intrinsics.floor16-  def trunc (x: f16): f16 = i16 (i16m.f16 x)+  def trunc (x: f16) : f16 = i16 (i16m.f16 x)    def round = intrinsics.round16 @@ -1245,8 +1290,8 @@   def ldexp x y = intrinsics.ldexp16 (x, y)   def copysign x y = intrinsics.copysign16 (x, y) -  def to_bits (x: f16): u16 = u16m.i16 (intrinsics.to_bits16 x)-  def from_bits (x: u16): f16 = intrinsics.from_bits16 (intrinsics.sign_i16 x)+  def to_bits (x: f16) : u16 = u16m.i16 (intrinsics.to_bits16 x)+  def from_bits (x: u16) : f16 = intrinsics.from_bits16 (intrinsics.sign_i16 x)    def num_bits = 16i32   def get_bit (bit: i32) (x: t) = u16m.get_bit bit (to_bits x)

@@ -8,33 +8,35 @@ open import "ad"  -- | Create single-precision float from integer.-def r32 (x: i32): f32 = f32.i32 x+def r32 (x: i32) : f32 = f32.i32 x+ -- | Create integer from single-precision float.-def t32 (x: f32): i32 = i32.f32 x+def t32 (x: f32) : i32 = i32.f32 x  -- | Create double-precision float from integer.-def r64 (x: i32): f64 = f64.i32 x+def r64 (x: i32) : f64 = f64.i32 x+ -- | Create integer from double-precision float.-def t64 (x: f64): i32 = i32.f64 x+def t64 (x: f64) : i32 = i32.f64 x  -- | Negate a boolean.  `not x` is the same as `!x`.  This function is -- mostly useful for passing to `map`.-def not (x: bool): bool = !x+def not (x: bool) : bool = !x  -- | Semantically just identity, but serves as an optimisation -- inhibitor.  The compiler will treat this function as a black box. -- You can use this to work around optimisation deficiencies (or -- bugs), although it should hopefully rarely be necessary. -- Deprecated: use `#[opaque]` attribute instead.-def opaque 't (x: t): t =+def opaque 't (x: t) : t =   #[opaque] x  -- | Semantically just identity, but at runtime, the argument value -- will be printed.  Deprecated: use `#[trace]` attribute instead.-def trace 't (x: t): t =+def trace 't (x: t) : t =   #[trace(trace)] x  -- | Semantically just identity, but acts as a break point in -- `futhark repl`.  Deprecated: use `#[break]` attribute instead.-def break 't (x: t): t =+def break 't (x: t) : t =   #[break] x

@@ -9,7 +9,8 @@ -- We need a map to define some of the zip variants, but this file is -- depended upon by soacs.fut.  So we just define a quick-and-dirty -- internal one here that uses the intrinsic version.-local def internal_map 'a [n] 'x (f: a -> x) (as: [n]a) : *[n]x =+local+def internal_map 'a [n] 'x (f: a -> x) (as: [n]a) : *[n]x =   intrinsics.map f as  -- | Construct an array of pairs from two arrays.

@@ -266,7 +266,7 @@  SCALAR_FUN_ATTR int64_t atomic_xchg_i64_global(volatile __global int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicExch((uint64_t*)p, x);+  return atomicExch((unsigned long long*)p, x); #else   return atom_xor(p, x); #endif@@ -274,7 +274,7 @@  SCALAR_FUN_ATTR int64_t atomic_xchg_i64_shared(volatile __local int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicExch((uint64_t*)p, x);+  return atomicExch((unsigned long long*)p, x); #else   return atom_xor(p, x); #endif@@ -283,7 +283,7 @@ SCALAR_FUN_ATTR int64_t atomic_cmpxchg_i64_global(volatile __global int64_t *p,                                                          int64_t cmp, int64_t val) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicCAS((uint64_t*)p, cmp, val);+  return atomicCAS((unsigned long long*)p, cmp, val); #else   return atom_cmpxchg(p, cmp, val); #endif@@ -292,7 +292,7 @@ SCALAR_FUN_ATTR int64_t atomic_cmpxchg_i64_shared(volatile __local int64_t *p,                                                         int64_t cmp, int64_t val) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicCAS((uint64_t*)p, cmp, val);+  return atomicCAS((unsigned long long*)p, cmp, val); #else   return atom_cmpxchg(p, cmp, val); #endif@@ -300,7 +300,7 @@  SCALAR_FUN_ATTR int64_t atomic_add_i64_global(volatile __global int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicAdd((uint64_t*)p, x);+  return atomicAdd((unsigned long long*)p, x); #else   return atom_add(p, x); #endif@@ -308,7 +308,7 @@  SCALAR_FUN_ATTR int64_t atomic_add_i64_shared(volatile __local int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicAdd((uint64_t*)p, x);+  return atomicAdd((unsigned long long*)p, x); #else   return atom_add(p, x); #endif@@ -368,7 +368,7 @@  SCALAR_FUN_ATTR int64_t atomic_smax_i64_global(volatile __global int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA)-  return atomicMax((int64_t*)p, x);+  return atomicMax((long long*)p, x); #elif defined(FUTHARK_HIP)   // Currentely missing in HIP; probably a temporary oversight.   int64_t old = *p, assumed;@@ -385,7 +385,7 @@  SCALAR_FUN_ATTR int64_t atomic_smax_i64_shared(volatile __local int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA)-  return atomicMax((int64_t*)p, x);+  return atomicMax((long long*)p, x); #elif defined(FUTHARK_HIP)   // Currentely missing in HIP; probably a temporary oversight.   int64_t old = *p, assumed;@@ -402,7 +402,7 @@  SCALAR_FUN_ATTR int64_t atomic_smin_i64_global(volatile __global int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA)-  return atomicMin((int64_t*)p, x);+  return atomicMin((long long*)p, x); #elif defined(FUTHARK_HIP)   // Currentely missing in HIP; probably a temporary oversight.   int64_t old = *p, assumed;@@ -419,7 +419,7 @@  SCALAR_FUN_ATTR int64_t atomic_smin_i64_shared(volatile __local int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA)-  return atomicMin((int64_t*)p, x);+  return atomicMin((long long*)p, x); #elif defined(FUTHARK_HIP)   // Currentely missing in HIP; probably a temporary oversight.   int64_t old = *p, assumed;@@ -436,7 +436,7 @@  SCALAR_FUN_ATTR uint64_t atomic_umax_i64_global(volatile __global uint64_t *p, uint64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicMax((uint64_t*)p, x);+  return atomicMax((unsigned long long*)p, x); #else   return atom_max(p, x); #endif@@ -444,7 +444,7 @@  SCALAR_FUN_ATTR uint64_t atomic_umax_i64_shared(volatile __local uint64_t *p, uint64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicMax((uint64_t*)p, x);+  return atomicMax((unsigned long long*)p, x); #else   return atom_max(p, x); #endif@@ -452,7 +452,7 @@  SCALAR_FUN_ATTR uint64_t atomic_umin_i64_global(volatile __global uint64_t *p, uint64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicMin((uint64_t*)p, x);+  return atomicMin((unsigned long long*)p, x); #else   return atom_min(p, x); #endif@@ -460,7 +460,7 @@  SCALAR_FUN_ATTR uint64_t atomic_umin_i64_shared(volatile __local uint64_t *p, uint64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicMin((uint64_t*)p, x);+  return atomicMin((unsigned long long*)p, x); #else   return atom_min(p, x); #endif@@ -468,7 +468,7 @@  SCALAR_FUN_ATTR int64_t atomic_and_i64_global(volatile __global int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicAnd((uint64_t*)p, x);+  return atomicAnd((unsigned long long*)p, x); #else   return atom_and(p, x); #endif@@ -476,7 +476,7 @@  SCALAR_FUN_ATTR int64_t atomic_and_i64_shared(volatile __local int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicAnd((uint64_t*)p, x);+  return atomicAnd((unsigned long long*)p, x); #else   return atom_and(p, x); #endif@@ -484,7 +484,7 @@  SCALAR_FUN_ATTR int64_t atomic_or_i64_global(volatile __global int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicOr((uint64_t*)p, x);+  return atomicOr((unsigned long long*)p, x); #else   return atom_or(p, x); #endif@@ -492,7 +492,7 @@  SCALAR_FUN_ATTR int64_t atomic_or_i64_shared(volatile __local int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicOr((uint64_t*)p, x);+  return atomicOr((unsigned long long*)p, x); #else   return atom_or(p, x); #endif@@ -500,7 +500,7 @@  SCALAR_FUN_ATTR int64_t atomic_xor_i64_global(volatile __global int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicXor((uint64_t*)p, x);+  return atomicXor((unsigned long long*)p, x); #else   return atom_xor(p, x); #endif@@ -508,7 +508,7 @@  SCALAR_FUN_ATTR int64_t atomic_xor_i64_shared(volatile __local int64_t *p, int64_t x) { #if defined(FUTHARK_CUDA) || defined(FUTHARK_HIP)-  return atomicXor((uint64_t*)p, x);+  return atomicXor((unsigned long long*)p, x); #else   return atom_xor(p, x); #endif

@@ -17,3032 +17,1851 @@ // Double-precision definitions are only included if the preprocessor // macro FUTHARK_F64_ENABLED is set. -SCALAR_FUN_ATTR int32_t futrts_to_bits32(float x);-SCALAR_FUN_ATTR float futrts_from_bits32(int32_t x);--SCALAR_FUN_ATTR uint8_t add8(uint8_t x, uint8_t y) {-  return x + y;-}--SCALAR_FUN_ATTR uint16_t add16(uint16_t x, uint16_t y) {-  return x + y;-}--SCALAR_FUN_ATTR uint32_t add32(uint32_t x, uint32_t y) {-  return x + y;-}--SCALAR_FUN_ATTR uint64_t add64(uint64_t x, uint64_t y) {-  return x + y;-}--SCALAR_FUN_ATTR uint8_t sub8(uint8_t x, uint8_t y) {-  return x - y;-}--SCALAR_FUN_ATTR uint16_t sub16(uint16_t x, uint16_t y) {-  return x - y;-}--SCALAR_FUN_ATTR uint32_t sub32(uint32_t x, uint32_t y) {-  return x - y;-}--SCALAR_FUN_ATTR uint64_t sub64(uint64_t x, uint64_t y) {-  return x - y;-}--SCALAR_FUN_ATTR uint8_t mul8(uint8_t x, uint8_t y) {-  return x * y;-}--SCALAR_FUN_ATTR uint16_t mul16(uint16_t x, uint16_t y) {-  return x * y;-}--SCALAR_FUN_ATTR uint32_t mul32(uint32_t x, uint32_t y) {-  return x * y;-}--SCALAR_FUN_ATTR uint64_t mul64(uint64_t x, uint64_t y) {-  return x * y;-}--#if defined(ISPC)--SCALAR_FUN_ATTR uint8_t udiv8(uint8_t x, uint8_t y) {-  // This strange pattern is used to prevent the ISPC compiler from-  // causing SIGFPEs and bogus results on divisions where inactive lanes-  // have 0-valued divisors. It ensures that any inactive lane instead-  // has a divisor of 1. https://github.com/ispc/ispc/issues/2292-  uint8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x / ys;-}--SCALAR_FUN_ATTR uint16_t udiv16(uint16_t x, uint16_t y) {-  uint16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x / ys;-}--SCALAR_FUN_ATTR uint32_t udiv32(uint32_t x, uint32_t y) {-  uint32_t ys = 1;-  foreach_active(i){-    ys = y;-  }---  return x / ys;-}--SCALAR_FUN_ATTR uint64_t udiv64(uint64_t x, uint64_t y) {-  uint64_t ys = 1;-  foreach_active(i){-    ys = y;-  }---  return x / ys;-}--SCALAR_FUN_ATTR uint8_t udiv_up8(uint8_t x, uint8_t y) {-  uint8_t ys = 1;-  foreach_active(i){-    ys = y;-  }---  return (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint16_t udiv_up16(uint16_t x, uint16_t y) {-  uint16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint32_t udiv_up32(uint32_t x, uint32_t y) {-  uint32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint64_t udiv_up64(uint64_t x, uint64_t y) {-  uint64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint8_t umod8(uint8_t x, uint8_t y) {-  uint8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x % ys;-}--SCALAR_FUN_ATTR uint16_t umod16(uint16_t x, uint16_t y) {-  uint16_t ys = 1;-  foreach_active(i){-    ys = y;-  }---  return x % ys;-}--SCALAR_FUN_ATTR uint32_t umod32(uint32_t x, uint32_t y) {-  uint32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x % ys;-}--SCALAR_FUN_ATTR uint64_t umod64(uint64_t x, uint64_t y) {-  uint64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x % ys;-}--SCALAR_FUN_ATTR uint8_t udiv_safe8(uint8_t x, uint8_t y) {-  uint8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR uint16_t udiv_safe16(uint16_t x, uint16_t y) {-  uint16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR uint32_t udiv_safe32(uint32_t x, uint32_t y) {-  uint32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR uint64_t udiv_safe64(uint64_t x, uint64_t y) {-  uint64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR uint8_t udiv_up_safe8(uint8_t x, uint8_t y) {-  uint8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint16_t udiv_up_safe16(uint16_t x, uint16_t y) {-  uint16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint32_t udiv_up_safe32(uint32_t x, uint32_t y) {-  uint32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint64_t udiv_up_safe64(uint64_t x, uint64_t y) {-  uint64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : (x + y - 1) / ys;-}--SCALAR_FUN_ATTR uint8_t umod_safe8(uint8_t x, uint8_t y) {-  uint8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--SCALAR_FUN_ATTR uint16_t umod_safe16(uint16_t x, uint16_t y) {-  uint16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--SCALAR_FUN_ATTR uint32_t umod_safe32(uint32_t x, uint32_t y) {-  uint32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--SCALAR_FUN_ATTR uint64_t umod_safe64(uint64_t x, uint64_t y) {-  uint64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--SCALAR_FUN_ATTR int8_t sdiv8(int8_t x, int8_t y) {-  int8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  int8_t q = x / ys;-  int8_t r = x % ys;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int16_t sdiv16(int16_t x, int16_t y) {-  int16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  int16_t q = x / ys;-  int16_t r = x % ys;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int32_t sdiv32(int32_t x, int32_t y) {-  int32_t ys = 1;-  foreach_active(i){-    ys = y;-  }-  int32_t q = x / ys;-  int32_t r = x % ys;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int64_t sdiv64(int64_t x, int64_t y) {-  int64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  int64_t q = x / ys;-  int64_t r = x % ys;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int8_t sdiv_up8(int8_t x, int8_t y) {-  return sdiv8(x + y - 1, y);-}--SCALAR_FUN_ATTR int16_t sdiv_up16(int16_t x, int16_t y) {-  return sdiv16(x + y - 1, y);-}--SCALAR_FUN_ATTR int32_t sdiv_up32(int32_t x, int32_t y) {-  return sdiv32(x + y - 1, y);-}--SCALAR_FUN_ATTR int64_t sdiv_up64(int64_t x, int64_t y) {-  return sdiv64(x + y - 1, y);-}--SCALAR_FUN_ATTR int8_t smod8(int8_t x, int8_t y) {-  int8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  int8_t r = x % ys;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int16_t smod16(int16_t x, int16_t y) {-  int16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  int16_t r = x % ys;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int32_t smod32(int32_t x, int32_t y) {-  int32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  int32_t r = x % ys;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int64_t smod64(int64_t x, int64_t y) {-  int64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  int64_t r = x % ys;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int8_t sdiv_safe8(int8_t x, int8_t y) {-  return y == 0 ? 0 : sdiv8(x, y);-}--SCALAR_FUN_ATTR int16_t sdiv_safe16(int16_t x, int16_t y) {-  return y == 0 ? 0 : sdiv16(x, y);-}--SCALAR_FUN_ATTR int32_t sdiv_safe32(int32_t x, int32_t y) {-  return y == 0 ? 0 : sdiv32(x, y);-}--SCALAR_FUN_ATTR int64_t sdiv_safe64(int64_t x, int64_t y) {-  return y == 0 ? 0 : sdiv64(x, y);-}--SCALAR_FUN_ATTR int8_t sdiv_up_safe8(int8_t x, int8_t y) {-  return sdiv_safe8(x + y - 1, y);-}--SCALAR_FUN_ATTR int16_t sdiv_up_safe16(int16_t x, int16_t y) {-  return sdiv_safe16(x + y - 1, y);-}--SCALAR_FUN_ATTR int32_t sdiv_up_safe32(int32_t x, int32_t y) {-  return sdiv_safe32(x + y - 1, y);-}--SCALAR_FUN_ATTR int64_t sdiv_up_safe64(int64_t x, int64_t y) {-  return sdiv_safe64(x + y - 1, y);-}--SCALAR_FUN_ATTR int8_t smod_safe8(int8_t x, int8_t y) {-  return y == 0 ? 0 : smod8(x, y);-}--SCALAR_FUN_ATTR int16_t smod_safe16(int16_t x, int16_t y) {-  return y == 0 ? 0 : smod16(x, y);-}--SCALAR_FUN_ATTR int32_t smod_safe32(int32_t x, int32_t y) {-  return y == 0 ? 0 : smod32(x, y);-}--SCALAR_FUN_ATTR int64_t smod_safe64(int64_t x, int64_t y) {-  return y == 0 ? 0 : smod64(x, y);-}--SCALAR_FUN_ATTR int8_t squot8(int8_t x, int8_t y) {-  int8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x / ys;-}--SCALAR_FUN_ATTR int16_t squot16(int16_t x, int16_t y) {-  int16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x / ys;-}--SCALAR_FUN_ATTR int32_t squot32(int32_t x, int32_t y) {-  int32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x / ys;-}--SCALAR_FUN_ATTR int64_t squot64(int64_t x, int64_t y) {-  int64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x / ys;-}--SCALAR_FUN_ATTR int8_t srem8(int8_t x, int8_t y) {-  int8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x % ys;-}--SCALAR_FUN_ATTR int16_t srem16(int16_t x, int16_t y) {-  int16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x % ys;-}--SCALAR_FUN_ATTR int32_t srem32(int32_t x, int32_t y) {-  int32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x % ys;-}--SCALAR_FUN_ATTR int64_t srem64(int64_t x, int64_t y) {-  int8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return x % ys;-}--SCALAR_FUN_ATTR int8_t squot_safe8(int8_t x, int8_t y) {-  int8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR int16_t squot_safe16(int16_t x, int16_t y) {-  int16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR int32_t squot_safe32(int32_t x, int32_t y) {-  int32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR int64_t squot_safe64(int64_t x, int64_t y) {-  int64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x / ys;-}--SCALAR_FUN_ATTR int8_t srem_safe8(int8_t x, int8_t y) {-  int8_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--SCALAR_FUN_ATTR int16_t srem_safe16(int16_t x, int16_t y) {-  int16_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--SCALAR_FUN_ATTR int32_t srem_safe32(int32_t x, int32_t y) {-  int32_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--SCALAR_FUN_ATTR int64_t srem_safe64(int64_t x, int64_t y) {-  int64_t ys = 1;-  foreach_active(i){-    ys = y;-  }--  return y == 0 ? 0 : x % ys;-}--#else--SCALAR_FUN_ATTR uint8_t udiv8(uint8_t x, uint8_t y) {-  return x / y;-}--SCALAR_FUN_ATTR uint16_t udiv16(uint16_t x, uint16_t y) {-  return x / y;-}--SCALAR_FUN_ATTR uint32_t udiv32(uint32_t x, uint32_t y) {-  return x / y;-}--SCALAR_FUN_ATTR uint64_t udiv64(uint64_t x, uint64_t y) {-  return x / y;-}--SCALAR_FUN_ATTR uint8_t udiv_up8(uint8_t x, uint8_t y) {-  return (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint16_t udiv_up16(uint16_t x, uint16_t y) {-  return (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint32_t udiv_up32(uint32_t x, uint32_t y) {-  return (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint64_t udiv_up64(uint64_t x, uint64_t y) {-  return (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint8_t umod8(uint8_t x, uint8_t y) {-  return x % y;-}--SCALAR_FUN_ATTR uint16_t umod16(uint16_t x, uint16_t y) {-  return x % y;-}--SCALAR_FUN_ATTR uint32_t umod32(uint32_t x, uint32_t y) {-  return x % y;-}--SCALAR_FUN_ATTR uint64_t umod64(uint64_t x, uint64_t y) {-  return x % y;-}--SCALAR_FUN_ATTR uint8_t udiv_safe8(uint8_t x, uint8_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR uint16_t udiv_safe16(uint16_t x, uint16_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR uint32_t udiv_safe32(uint32_t x, uint32_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR uint64_t udiv_safe64(uint64_t x, uint64_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR uint8_t udiv_up_safe8(uint8_t x, uint8_t y) {-  return y == 0 ? 0 : (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint16_t udiv_up_safe16(uint16_t x, uint16_t y) {-  return y == 0 ? 0 : (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint32_t udiv_up_safe32(uint32_t x, uint32_t y) {-  return y == 0 ? 0 : (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint64_t udiv_up_safe64(uint64_t x, uint64_t y) {-  return y == 0 ? 0 : (x + y - 1) / y;-}--SCALAR_FUN_ATTR uint8_t umod_safe8(uint8_t x, uint8_t y) {-  return y == 0 ? 0 : x % y;-}--SCALAR_FUN_ATTR uint16_t umod_safe16(uint16_t x, uint16_t y) {-  return y == 0 ? 0 : x % y;-}--SCALAR_FUN_ATTR uint32_t umod_safe32(uint32_t x, uint32_t y) {-  return y == 0 ? 0 : x % y;-}--SCALAR_FUN_ATTR uint64_t umod_safe64(uint64_t x, uint64_t y) {-  return y == 0 ? 0 : x % y;-}--SCALAR_FUN_ATTR int8_t sdiv8(int8_t x, int8_t y) {-  int8_t q = x / y;-  int8_t r = x % y;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int16_t sdiv16(int16_t x, int16_t y) {-  int16_t q = x / y;-  int16_t r = x % y;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int32_t sdiv32(int32_t x, int32_t y) {-  int32_t q = x / y;-  int32_t r = x % y;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int64_t sdiv64(int64_t x, int64_t y) {-  int64_t q = x / y;-  int64_t r = x % y;--  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);-}--SCALAR_FUN_ATTR int8_t sdiv_up8(int8_t x, int8_t y) {-  return sdiv8(x + y - 1, y);-}--SCALAR_FUN_ATTR int16_t sdiv_up16(int16_t x, int16_t y) {-  return sdiv16(x + y - 1, y);-}--SCALAR_FUN_ATTR int32_t sdiv_up32(int32_t x, int32_t y) {-  return sdiv32(x + y - 1, y);-}--SCALAR_FUN_ATTR int64_t sdiv_up64(int64_t x, int64_t y) {-  return sdiv64(x + y - 1, y);-}--SCALAR_FUN_ATTR int8_t smod8(int8_t x, int8_t y) {-  int8_t r = x % y;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int16_t smod16(int16_t x, int16_t y) {-  int16_t r = x % y;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int32_t smod32(int32_t x, int32_t y) {-  int32_t r = x % y;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int64_t smod64(int64_t x, int64_t y) {-  int64_t r = x % y;--  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);-}--SCALAR_FUN_ATTR int8_t sdiv_safe8(int8_t x, int8_t y) {-  return y == 0 ? 0 : sdiv8(x, y);-}--SCALAR_FUN_ATTR int16_t sdiv_safe16(int16_t x, int16_t y) {-  return y == 0 ? 0 : sdiv16(x, y);-}--SCALAR_FUN_ATTR int32_t sdiv_safe32(int32_t x, int32_t y) {-  return y == 0 ? 0 : sdiv32(x, y);-}--SCALAR_FUN_ATTR int64_t sdiv_safe64(int64_t x, int64_t y) {-  return y == 0 ? 0 : sdiv64(x, y);-}--SCALAR_FUN_ATTR int8_t sdiv_up_safe8(int8_t x, int8_t y) {-  return sdiv_safe8(x + y - 1, y);-}--SCALAR_FUN_ATTR int16_t sdiv_up_safe16(int16_t x, int16_t y) {-  return sdiv_safe16(x + y - 1, y);-}--SCALAR_FUN_ATTR int32_t sdiv_up_safe32(int32_t x, int32_t y) {-  return sdiv_safe32(x + y - 1, y);-}--SCALAR_FUN_ATTR int64_t sdiv_up_safe64(int64_t x, int64_t y) {-  return sdiv_safe64(x + y - 1, y);-}--SCALAR_FUN_ATTR int8_t smod_safe8(int8_t x, int8_t y) {-  return y == 0 ? 0 : smod8(x, y);-}--SCALAR_FUN_ATTR int16_t smod_safe16(int16_t x, int16_t y) {-  return y == 0 ? 0 : smod16(x, y);-}--SCALAR_FUN_ATTR int32_t smod_safe32(int32_t x, int32_t y) {-  return y == 0 ? 0 : smod32(x, y);-}--SCALAR_FUN_ATTR int64_t smod_safe64(int64_t x, int64_t y) {-  return y == 0 ? 0 : smod64(x, y);-}--SCALAR_FUN_ATTR int8_t squot8(int8_t x, int8_t y) {-  return x / y;-}--SCALAR_FUN_ATTR int16_t squot16(int16_t x, int16_t y) {-  return x / y;-}--SCALAR_FUN_ATTR int32_t squot32(int32_t x, int32_t y) {-  return x / y;-}--SCALAR_FUN_ATTR int64_t squot64(int64_t x, int64_t y) {-  return x / y;-}--SCALAR_FUN_ATTR int8_t srem8(int8_t x, int8_t y) {-  return x % y;-}--SCALAR_FUN_ATTR int16_t srem16(int16_t x, int16_t y) {-  return x % y;-}--SCALAR_FUN_ATTR int32_t srem32(int32_t x, int32_t y) {-  return x % y;-}--SCALAR_FUN_ATTR int64_t srem64(int64_t x, int64_t y) {-  return x % y;-}--SCALAR_FUN_ATTR int8_t squot_safe8(int8_t x, int8_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR int16_t squot_safe16(int16_t x, int16_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR int32_t squot_safe32(int32_t x, int32_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR int64_t squot_safe64(int64_t x, int64_t y) {-  return y == 0 ? 0 : x / y;-}--SCALAR_FUN_ATTR int8_t srem_safe8(int8_t x, int8_t y) {-  return y == 0 ? 0 : x % y;-}--SCALAR_FUN_ATTR int16_t srem_safe16(int16_t x, int16_t y) {-  return y == 0 ? 0 : x % y;-}--SCALAR_FUN_ATTR int32_t srem_safe32(int32_t x, int32_t y) {-  return y == 0 ? 0 : x % y;-}--SCALAR_FUN_ATTR int64_t srem_safe64(int64_t x, int64_t y) {-  return y == 0 ? 0 : x % y;-}--#endif--SCALAR_FUN_ATTR int8_t smin8(int8_t x, int8_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR int16_t smin16(int16_t x, int16_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR int32_t smin32(int32_t x, int32_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR int64_t smin64(int64_t x, int64_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR uint8_t umin8(uint8_t x, uint8_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR uint16_t umin16(uint16_t x, uint16_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR uint32_t umin32(uint32_t x, uint32_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR uint64_t umin64(uint64_t x, uint64_t y) {-  return x < y ? x : y;-}--SCALAR_FUN_ATTR int8_t smax8(int8_t x, int8_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR int16_t smax16(int16_t x, int16_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR int32_t smax32(int32_t x, int32_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR int64_t smax64(int64_t x, int64_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR uint8_t umax8(uint8_t x, uint8_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR uint16_t umax16(uint16_t x, uint16_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR uint32_t umax32(uint32_t x, uint32_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR uint64_t umax64(uint64_t x, uint64_t y) {-  return x < y ? y : x;-}--SCALAR_FUN_ATTR uint8_t shl8(uint8_t x, uint8_t y) {-  return (uint8_t)(x << y);-}--SCALAR_FUN_ATTR uint16_t shl16(uint16_t x, uint16_t y) {-  return (uint16_t)(x << y);-}--SCALAR_FUN_ATTR uint32_t shl32(uint32_t x, uint32_t y) {-  return x << y;-}--SCALAR_FUN_ATTR uint64_t shl64(uint64_t x, uint64_t y) {-  return x << y;-}--SCALAR_FUN_ATTR uint8_t lshr8(uint8_t x, uint8_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR uint16_t lshr16(uint16_t x, uint16_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR uint32_t lshr32(uint32_t x, uint32_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR uint64_t lshr64(uint64_t x, uint64_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR int8_t ashr8(int8_t x, int8_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR int16_t ashr16(int16_t x, int16_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR int32_t ashr32(int32_t x, int32_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR int64_t ashr64(int64_t x, int64_t y) {-  return x >> y;-}--SCALAR_FUN_ATTR uint8_t and8(uint8_t x, uint8_t y) {-  return x & y;-}--SCALAR_FUN_ATTR uint16_t and16(uint16_t x, uint16_t y) {-  return x & y;-}--SCALAR_FUN_ATTR uint32_t and32(uint32_t x, uint32_t y) {-  return x & y;-}--SCALAR_FUN_ATTR uint64_t and64(uint64_t x, uint64_t y) {-  return x & y;-}--SCALAR_FUN_ATTR uint8_t or8(uint8_t x, uint8_t y) {-  return x | y;-}--SCALAR_FUN_ATTR uint16_t or16(uint16_t x, uint16_t y) {-  return x | y;-}--SCALAR_FUN_ATTR uint32_t or32(uint32_t x, uint32_t y) {-  return x | y;-}--SCALAR_FUN_ATTR uint64_t or64(uint64_t x, uint64_t y) {-  return x | y;-}--SCALAR_FUN_ATTR uint8_t xor8(uint8_t x, uint8_t y) {-  return x ^ y;-}--SCALAR_FUN_ATTR uint16_t xor16(uint16_t x, uint16_t y) {-  return x ^ y;-}--SCALAR_FUN_ATTR uint32_t xor32(uint32_t x, uint32_t y) {-  return x ^ y;-}--SCALAR_FUN_ATTR uint64_t xor64(uint64_t x, uint64_t y) {-  return x ^ y;-}--SCALAR_FUN_ATTR bool ult8(uint8_t x, uint8_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool ult16(uint16_t x, uint16_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool ult32(uint32_t x, uint32_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool ult64(uint64_t x, uint64_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool ule8(uint8_t x, uint8_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR bool ule16(uint16_t x, uint16_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR bool ule32(uint32_t x, uint32_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR bool ule64(uint64_t x, uint64_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR bool slt8(int8_t x, int8_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool slt16(int16_t x, int16_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool slt32(int32_t x, int32_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool slt64(int64_t x, int64_t y) {-  return x < y;-}--SCALAR_FUN_ATTR bool sle8(int8_t x, int8_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR bool sle16(int16_t x, int16_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR bool sle32(int32_t x, int32_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR bool sle64(int64_t x, int64_t y) {-  return x <= y;-}--SCALAR_FUN_ATTR uint8_t pow8(uint8_t x, uint8_t y) {-  uint8_t res = 1, rem = y;--  while (rem != 0) {-    if (rem & 1)-      res *= x;-    rem >>= 1;-    x *= x;-  }-  return res;-}--SCALAR_FUN_ATTR uint16_t pow16(uint16_t x, uint16_t y) {-  uint16_t res = 1, rem = y;--  while (rem != 0) {-    if (rem & 1)-      res *= x;-    rem >>= 1;-    x *= x;-  }-  return res;-}--SCALAR_FUN_ATTR uint32_t pow32(uint32_t x, uint32_t y) {-  uint32_t res = 1, rem = y;--  while (rem != 0) {-    if (rem & 1)-      res *= x;-    rem >>= 1;-    x *= x;-  }-  return res;-}--SCALAR_FUN_ATTR uint64_t pow64(uint64_t x, uint64_t y) {-  uint64_t res = 1, rem = y;--  while (rem != 0) {-    if (rem & 1)-      res *= x;-    rem >>= 1;-    x *= x;-  }-  return res;-}--SCALAR_FUN_ATTR bool itob_i8_bool(int8_t x) {-  return x != 0;-}--SCALAR_FUN_ATTR bool itob_i16_bool(int16_t x) {-  return x != 0;-}--SCALAR_FUN_ATTR bool itob_i32_bool(int32_t x) {-  return x != 0;-}--SCALAR_FUN_ATTR bool itob_i64_bool(int64_t x) {-  return x != 0;-}--SCALAR_FUN_ATTR int8_t btoi_bool_i8(bool x) {-  return x;-}--SCALAR_FUN_ATTR int16_t btoi_bool_i16(bool x) {-  return x;-}--SCALAR_FUN_ATTR int32_t btoi_bool_i32(bool x) {-  return x;-}--SCALAR_FUN_ATTR int64_t btoi_bool_i64(bool x) {-  return x;-}--#define sext_i8_i8(x) ((int8_t) (int8_t) (x))-#define sext_i8_i16(x) ((int16_t) (int8_t) (x))-#define sext_i8_i32(x) ((int32_t) (int8_t) (x))-#define sext_i8_i64(x) ((int64_t) (int8_t) (x))-#define sext_i16_i8(x) ((int8_t) (int16_t) (x))-#define sext_i16_i16(x) ((int16_t) (int16_t) (x))-#define sext_i16_i32(x) ((int32_t) (int16_t) (x))-#define sext_i16_i64(x) ((int64_t) (int16_t) (x))-#define sext_i32_i8(x) ((int8_t) (int32_t) (x))-#define sext_i32_i16(x) ((int16_t) (int32_t) (x))-#define sext_i32_i32(x) ((int32_t) (int32_t) (x))-#define sext_i32_i64(x) ((int64_t) (int32_t) (x))-#define sext_i64_i8(x) ((int8_t) (int64_t) (x))-#define sext_i64_i16(x) ((int16_t) (int64_t) (x))-#define sext_i64_i32(x) ((int32_t) (int64_t) (x))-#define sext_i64_i64(x) ((int64_t) (int64_t) (x))-#define zext_i8_i8(x) ((int8_t) (uint8_t) (x))-#define zext_i8_i16(x) ((int16_t) (uint8_t) (x))-#define zext_i8_i32(x) ((int32_t) (uint8_t) (x))-#define zext_i8_i64(x) ((int64_t) (uint8_t) (x))-#define zext_i16_i8(x) ((int8_t) (uint16_t) (x))-#define zext_i16_i16(x) ((int16_t) (uint16_t) (x))-#define zext_i16_i32(x) ((int32_t) (uint16_t) (x))-#define zext_i16_i64(x) ((int64_t) (uint16_t) (x))-#define zext_i32_i8(x) ((int8_t) (uint32_t) (x))-#define zext_i32_i16(x) ((int16_t) (uint32_t) (x))-#define zext_i32_i32(x) ((int32_t) (uint32_t) (x))-#define zext_i32_i64(x) ((int64_t) (uint32_t) (x))-#define zext_i64_i8(x) ((int8_t) (uint64_t) (x))-#define zext_i64_i16(x) ((int16_t) (uint64_t) (x))-#define zext_i64_i32(x) ((int32_t) (uint64_t) (x))-#define zext_i64_i64(x) ((int64_t) (uint64_t) (x))--SCALAR_FUN_ATTR int8_t abs8(int8_t x) {-  return (int8_t)abs(x);-}--SCALAR_FUN_ATTR int16_t abs16(int16_t x) {-  return (int16_t)abs(x);-}--SCALAR_FUN_ATTR int32_t abs32(int32_t x) {-  return abs(x);-}--SCALAR_FUN_ATTR int64_t abs64(int64_t x) {-#if defined(__OPENCL_VERSION__) || defined(ISPC)-  return abs(x);-#else-  return llabs(x);-#endif-}--#if defined(__OPENCL_VERSION__)-SCALAR_FUN_ATTR int32_t futrts_popc8(int8_t x) {-  return popcount(x);-}--SCALAR_FUN_ATTR int32_t futrts_popc16(int16_t x) {-  return popcount(x);-}--SCALAR_FUN_ATTR int32_t futrts_popc32(int32_t x) {-  return popcount(x);-}--SCALAR_FUN_ATTR int32_t futrts_popc64(int64_t x) {-  return popcount(x);-}-#elif defined(__CUDA_ARCH__)--SCALAR_FUN_ATTR int32_t futrts_popc8(int8_t x) {-  return __popc(zext_i8_i32(x));-}--SCALAR_FUN_ATTR int32_t futrts_popc16(int16_t x) {-  return __popc(zext_i16_i32(x));-}--SCALAR_FUN_ATTR int32_t futrts_popc32(int32_t x) {-  return __popc(x);-}--SCALAR_FUN_ATTR int32_t futrts_popc64(int64_t x) {-  return __popcll(x);-}--#else // Not OpenCL or CUDA, but plain C.--SCALAR_FUN_ATTR int32_t futrts_popc8(uint8_t x) {-  int c = 0;-  for (; x; ++c) { x &= x - 1; }-  return c;-}--SCALAR_FUN_ATTR int32_t futrts_popc16(uint16_t x) {-  int c = 0;-  for (; x; ++c) { x &= x - 1; }-  return c;-}--SCALAR_FUN_ATTR int32_t futrts_popc32(uint32_t x) {-  int c = 0;-  for (; x; ++c) { x &= x - 1; }-  return c;-}--SCALAR_FUN_ATTR int32_t futrts_popc64(uint64_t x) {-  int c = 0;-  for (; x; ++c) { x &= x - 1; }-  return c;-}-#endif--#if defined(__OPENCL_VERSION__)-SCALAR_FUN_ATTR uint8_t  futrts_umul_hi8 ( uint8_t a,  uint8_t b) { return mul_hi(a, b); }-SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return mul_hi(a, b); }-SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return mul_hi(a, b); }-SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return mul_hi(a, b); }-SCALAR_FUN_ATTR uint8_t  futrts_smul_hi8 ( int8_t a,  int8_t b) { return mul_hi(a, b); }-SCALAR_FUN_ATTR uint16_t futrts_smul_hi16(int16_t a, int16_t b) { return mul_hi(a, b); }-SCALAR_FUN_ATTR uint32_t futrts_smul_hi32(int32_t a, int32_t b) { return mul_hi(a, b); }-SCALAR_FUN_ATTR uint64_t futrts_smul_hi64(int64_t a, int64_t b) { return mul_hi(a, b); }-#elif defined(__CUDA_ARCH__)-SCALAR_FUN_ATTR  uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }-SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }-SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return __umulhi(a, b); }-SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return __umul64hi(a, b); }-SCALAR_FUN_ATTR  uint8_t futrts_smul_hi8 ( int8_t a, int8_t b) { return ((int16_t)a) * ((int16_t)b) >> 8; }-SCALAR_FUN_ATTR uint16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((int32_t)a) * ((int32_t)b) >> 16; }-SCALAR_FUN_ATTR uint32_t futrts_smul_hi32(int32_t a, int32_t b) { return __mulhi(a, b); }-SCALAR_FUN_ATTR uint64_t futrts_smul_hi64(int64_t a, int64_t b) { return __mul64hi(a, b); }-#elif defined(ISPC)-SCALAR_FUN_ATTR uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }-SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }-SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }-SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) {-  uint64_t ah = a >> 32;-  uint64_t al = a & 0xffffffff;-  uint64_t bh = b >> 32;-  uint64_t bl = b & 0xffffffff;--  uint64_t p1 = al * bl;-  uint64_t p2 = al * bh;-  uint64_t p3 = ah * bl;-  uint64_t p4 = ah * bh;--  uint64_t p1h = p1 >> 32;-  uint64_t p2h = p2 >> 32;-  uint64_t p3h = p3 >> 32;-  uint64_t p2l = p2 & 0xffffffff;-  uint64_t p3l = p3 & 0xffffffff;--  uint64_t l = p1h + p2l + p3l;-  uint64_t m = (p2 >> 32) + (p3 >> 32);-  uint64_t h = (l >> 32) + m + p4;--  return h;-}-SCALAR_FUN_ATTR  int8_t futrts_smul_hi8 ( int8_t a,  int8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }-SCALAR_FUN_ATTR int16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }-SCALAR_FUN_ATTR int32_t futrts_smul_hi32(int32_t a, int32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }-SCALAR_FUN_ATTR int64_t futrts_smul_hi64(int64_t a, int64_t b) {-  uint64_t ah = a >> 32;-  uint64_t al = a & 0xffffffff;-  uint64_t bh = b >> 32;-  uint64_t bl = b & 0xffffffff;--  uint64_t p1 =  al * bl;-  int64_t  p2 = al * bh;-  int64_t  p3 = ah * bl;-  uint64_t p4 =  ah * bh;--  uint64_t p1h = p1 >> 32;-  uint64_t p2h = p2 >> 32;-  uint64_t p3h = p3 >> 32;-  uint64_t p2l = p2 & 0xffffffff;-  uint64_t p3l = p3 & 0xffffffff;--  uint64_t l = p1h + p2l + p3l;-  uint64_t m = (p2 >> 32) + (p3 >> 32);-  uint64_t h = (l >> 32) + m + p4;--  return h;-}--#else // Not OpenCL, ISPC, or CUDA, but plain C.-SCALAR_FUN_ATTR uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }-SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }-SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }-SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return ((__uint128_t)a) * ((__uint128_t)b) >> 64; }-SCALAR_FUN_ATTR int8_t futrts_smul_hi8(int8_t a, int8_t b) { return ((int16_t)a) * ((int16_t)b) >> 8; }-SCALAR_FUN_ATTR int16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((int32_t)a) * ((int32_t)b) >> 16; }-SCALAR_FUN_ATTR int32_t futrts_smul_hi32(int32_t a, int32_t b) { return ((int64_t)a) * ((int64_t)b) >> 32; }-SCALAR_FUN_ATTR int64_t futrts_smul_hi64(int64_t a, int64_t b) { return ((__int128_t)a) * ((__int128_t)b) >> 64; }-#endif--#if defined(__OPENCL_VERSION__)-SCALAR_FUN_ATTR  uint8_t futrts_umad_hi8 ( uint8_t a,  uint8_t b,  uint8_t c) { return mad_hi(a, b, c); }-SCALAR_FUN_ATTR uint16_t futrts_umad_hi16(uint16_t a, uint16_t b, uint16_t c) { return mad_hi(a, b, c); }-SCALAR_FUN_ATTR uint32_t futrts_umad_hi32(uint32_t a, uint32_t b, uint32_t c) { return mad_hi(a, b, c); }-SCALAR_FUN_ATTR uint64_t futrts_umad_hi64(uint64_t a, uint64_t b, uint64_t c) { return mad_hi(a, b, c); }-SCALAR_FUN_ATTR  uint8_t futrts_smad_hi8( int8_t a,  int8_t b,   int8_t c) { return mad_hi(a, b, c); }-SCALAR_FUN_ATTR uint16_t futrts_smad_hi16(int16_t a, int16_t b, int16_t c) { return mad_hi(a, b, c); }-SCALAR_FUN_ATTR uint32_t futrts_smad_hi32(int32_t a, int32_t b, int32_t c) { return mad_hi(a, b, c); }-SCALAR_FUN_ATTR uint64_t futrts_smad_hi64(int64_t a, int64_t b, int64_t c) { return mad_hi(a, b, c); }-#else // Not OpenCL--SCALAR_FUN_ATTR  uint8_t futrts_umad_hi8( uint8_t a,  uint8_t b,  uint8_t c) { return futrts_umul_hi8(a, b) + c; }-SCALAR_FUN_ATTR uint16_t futrts_umad_hi16(uint16_t a, uint16_t b, uint16_t c) { return futrts_umul_hi16(a, b) + c; }-SCALAR_FUN_ATTR uint32_t futrts_umad_hi32(uint32_t a, uint32_t b, uint32_t c) { return futrts_umul_hi32(a, b) + c; }-SCALAR_FUN_ATTR uint64_t futrts_umad_hi64(uint64_t a, uint64_t b, uint64_t c) { return futrts_umul_hi64(a, b) + c; }-SCALAR_FUN_ATTR  uint8_t futrts_smad_hi8 ( int8_t a,  int8_t b,  int8_t c) { return futrts_smul_hi8(a, b) + c; }-SCALAR_FUN_ATTR uint16_t futrts_smad_hi16(int16_t a, int16_t b, int16_t c) { return futrts_smul_hi16(a, b) + c; }-SCALAR_FUN_ATTR uint32_t futrts_smad_hi32(int32_t a, int32_t b, int32_t c) { return futrts_smul_hi32(a, b) + c; }-SCALAR_FUN_ATTR uint64_t futrts_smad_hi64(int64_t a, int64_t b, int64_t c) { return futrts_smul_hi64(a, b) + c; }-#endif--#if defined(__OPENCL_VERSION__)-SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x) {-  return clz(x);-}--SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) {-  return clz(x);-}--SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) {-  return clz(x);-}--SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) {-  return clz(x);-}--#elif defined(__CUDA_ARCH__)--SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x) {-  return __clz(zext_i8_i32(x)) - 24;-}--SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) {-  return __clz(zext_i16_i32(x)) - 16;-}--SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) {-  return __clz(x);-}--SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) {-  return __clzll(x);-}--#elif defined(ISPC)--SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x) {-  return count_leading_zeros((int32_t)(uint8_t)x)-24;-}--SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) {-  return count_leading_zeros((int32_t)(uint16_t)x)-16;-}--SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) {-  return count_leading_zeros(x);-}--SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) {-  return count_leading_zeros(x);-}--#else // Not OpenCL, ISPC or CUDA, but plain C.--SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x) {-  return x == 0 ? 8 : __builtin_clz((uint32_t)zext_i8_i32(x)) - 24;-}--SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) {-  return x == 0 ? 16 : __builtin_clz((uint32_t)zext_i16_i32(x)) - 16;-}--SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) {-  return x == 0 ? 32 : __builtin_clz((uint32_t)x);-}--SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) {-  return x == 0 ? 64 : __builtin_clzll((uint64_t)x);-}-#endif--#if defined(__OPENCL_VERSION__)-SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {-  int i = 0;-  for (; i < 8 && (x & 1) == 0; i++, x >>= 1)-    ;-  return i;-}--SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {-  int i = 0;-  for (; i < 16 && (x & 1) == 0; i++, x >>= 1)-    ;-  return i;-}--SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {-  int i = 0;-  for (; i < 32 && (x & 1) == 0; i++, x >>= 1)-    ;-  return i;-}--SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {-  int i = 0;-  for (; i < 64 && (x & 1) == 0; i++, x >>= 1)-    ;-  return i;-}--#elif defined(__CUDA_ARCH__)--SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {-  int y = __ffs(x);-  return y == 0 ? 8 : y - 1;-}--SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {-  int y = __ffs(x);-  return y == 0 ? 16 : y - 1;-}--SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {-  int y = __ffs(x);-  return y == 0 ? 32 : y - 1;-}--SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {-  int y = __ffsll(x);-  return y == 0 ? 64 : y - 1;-}--#elif defined(ISPC)--SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {-  return x == 0 ? 8 : count_trailing_zeros((int32_t)x);-}--SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {-  return x == 0 ? 16 : count_trailing_zeros((int32_t)x);-}--SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {-  return count_trailing_zeros(x);-}--SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {-  return count_trailing_zeros(x);-}--#else // Not OpenCL or CUDA, but plain C.--SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {-  return x == 0 ? 8 : __builtin_ctz((uint32_t)x);-}--SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {-  return x == 0 ? 16 : __builtin_ctz((uint32_t)x);-}--SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {-  return x == 0 ? 32 : __builtin_ctz((uint32_t)x);-}--SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {-  return x == 0 ? 64 : __builtin_ctzll((uint64_t)x);-}-#endif--SCALAR_FUN_ATTR float fdiv32(float x, float y) {-  return x / y;-}--SCALAR_FUN_ATTR float fadd32(float x, float y) {-  return x + y;-}--SCALAR_FUN_ATTR float fsub32(float x, float y) {-  return x - y;-}--SCALAR_FUN_ATTR float fmul32(float x, float y) {-  return x * y;-}--SCALAR_FUN_ATTR bool cmplt32(float x, float y) {-  return x < y;-}--SCALAR_FUN_ATTR bool cmple32(float x, float y) {-  return x <= y;-}--SCALAR_FUN_ATTR float sitofp_i8_f32(int8_t x) {-  return (float) x;-}--SCALAR_FUN_ATTR float sitofp_i16_f32(int16_t x) {-  return (float) x;-}--SCALAR_FUN_ATTR float sitofp_i32_f32(int32_t x) {-  return (float) x;-}--SCALAR_FUN_ATTR float sitofp_i64_f32(int64_t x) {-  return (float) x;-}--SCALAR_FUN_ATTR float uitofp_i8_f32(uint8_t x) {-  return (float) x;-}--SCALAR_FUN_ATTR float uitofp_i16_f32(uint16_t x) {-  return (float) x;-}--SCALAR_FUN_ATTR float uitofp_i32_f32(uint32_t x) {-  return (float) x;-}--SCALAR_FUN_ATTR float uitofp_i64_f32(uint64_t x) {-  return (float) x;-}--#ifdef __OPENCL_VERSION__-SCALAR_FUN_ATTR float fabs32(float x) {-  return fabs(x);-}--SCALAR_FUN_ATTR float fmax32(float x, float y) {-  return fmax(x, y);-}--SCALAR_FUN_ATTR float fmin32(float x, float y) {-  return fmin(x, y);-}--SCALAR_FUN_ATTR float fpow32(float x, float y) {-  return pow(x, y);-}--#elif defined(ISPC)--SCALAR_FUN_ATTR float fabs32(float x) {-  return abs(x);-}--SCALAR_FUN_ATTR float fmax32(float x, float y) {-  return isnan(x) ? y : isnan(y) ? x : max(x, y);-}--SCALAR_FUN_ATTR float fmin32(float x, float y) {-  return isnan(x) ? y : isnan(y) ? x : min(x, y);-}--SCALAR_FUN_ATTR float fpow32(float a, float b) {-  float ret;-  foreach_active (i) {-      uniform float r = pow(extract(a, i), extract(b, i));-      ret = insert(ret, i, r);-  }-  return ret;-}--#else // Not OpenCL, but CUDA or plain C.--SCALAR_FUN_ATTR float fabs32(float x) {-  return fabsf(x);-}--SCALAR_FUN_ATTR float fmax32(float x, float y) {-  return fmaxf(x, y);-}--SCALAR_FUN_ATTR float fmin32(float x, float y) {-  return fminf(x, y);-}--SCALAR_FUN_ATTR float fpow32(float x, float y) {-  return powf(x, y);-}-#endif--SCALAR_FUN_ATTR bool futrts_isnan32(float x) {-  return isnan(x);-}--#if defined(ISPC)--SCALAR_FUN_ATTR bool futrts_isinf32(float x) {-  return !isnan(x) && isnan(x - x);-}--SCALAR_FUN_ATTR bool futrts_isfinite32(float x) {-  return !isnan(x) && !futrts_isinf32(x);-}--#else--SCALAR_FUN_ATTR bool futrts_isinf32(float x) {-  return isinf(x);-}--#endif--SCALAR_FUN_ATTR int8_t fptosi_f32_i8(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (int8_t) x;-  }-}--SCALAR_FUN_ATTR int16_t fptosi_f32_i16(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (int16_t) x;-  }-}--SCALAR_FUN_ATTR int32_t fptosi_f32_i32(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (int32_t) x;-  }-}--SCALAR_FUN_ATTR int64_t fptosi_f32_i64(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (int64_t) x;-  };-}--SCALAR_FUN_ATTR uint8_t fptoui_f32_i8(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (uint8_t) (int8_t) x;-  }-}--SCALAR_FUN_ATTR uint16_t fptoui_f32_i16(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (uint16_t) (int16_t) x;-  }-}--SCALAR_FUN_ATTR uint32_t fptoui_f32_i32(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (uint32_t) (int32_t) x;-  }-}--SCALAR_FUN_ATTR uint64_t fptoui_f32_i64(float x) {-  if (futrts_isnan32(x) || futrts_isinf32(x)) {-    return 0;-  } else {-    return (uint64_t) (int64_t) x;-  }-}--SCALAR_FUN_ATTR bool ftob_f32_bool(float x) {-  return x != 0;-}--SCALAR_FUN_ATTR float btof_bool_f32(bool x) {-  return x ? 1 : 0;-}--#ifdef __OPENCL_VERSION__-SCALAR_FUN_ATTR float futrts_log32(float x) {-  return log(x);-}--SCALAR_FUN_ATTR float futrts_log2_32(float x) {-  return log2(x);-}--SCALAR_FUN_ATTR float futrts_log10_32(float x) {-  return log10(x);-}--SCALAR_FUN_ATTR float futrts_log1p_32(float x) {-  return log1p(x);-}--SCALAR_FUN_ATTR float futrts_sqrt32(float x) {-  return sqrt(x);-}--SCALAR_FUN_ATTR float futrts_cbrt32(float x) {-  return cbrt(x);-}--SCALAR_FUN_ATTR float futrts_exp32(float x) {-  return exp(x);-}--SCALAR_FUN_ATTR float futrts_cos32(float x) {-  return cos(x);-}--SCALAR_FUN_ATTR float futrts_sin32(float x) {-  return sin(x);-}--SCALAR_FUN_ATTR float futrts_tan32(float x) {-  return tan(x);-}--SCALAR_FUN_ATTR float futrts_acos32(float x) {-  return acos(x);-}--SCALAR_FUN_ATTR float futrts_asin32(float x) {-  return asin(x);-}--SCALAR_FUN_ATTR float futrts_atan32(float x) {-  return atan(x);-}--SCALAR_FUN_ATTR float futrts_cosh32(float x) {-  return cosh(x);-}--SCALAR_FUN_ATTR float futrts_sinh32(float x) {-  return sinh(x);-}--SCALAR_FUN_ATTR float futrts_tanh32(float x) {-  return tanh(x);-}--SCALAR_FUN_ATTR float futrts_acosh32(float x) {-  return acosh(x);-}--SCALAR_FUN_ATTR float futrts_asinh32(float x) {-  return asinh(x);-}--SCALAR_FUN_ATTR float futrts_atanh32(float x) {-  return atanh(x);-}--SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y) {-  return atan2(x, y);-}--SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) {-  return hypot(x, y);-}--SCALAR_FUN_ATTR float futrts_gamma32(float x) {-  return tgamma(x);-}--SCALAR_FUN_ATTR float futrts_lgamma32(float x) {-  return lgamma(x);-}--SCALAR_FUN_ATTR float futrts_erf32(float x) {-  return erf(x);-}--SCALAR_FUN_ATTR float futrts_erfc32(float x) {-  return erfc(x);-}--SCALAR_FUN_ATTR float fmod32(float x, float y) {-  return fmod(x, y);-}--SCALAR_FUN_ATTR float futrts_round32(float x) {-  return rint(x);-}--SCALAR_FUN_ATTR float futrts_floor32(float x) {-  return floor(x);-}--SCALAR_FUN_ATTR float futrts_ceil32(float x) {-  return ceil(x);-}--SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) {-  return nextafter(x, y);-}--SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) {-  return mix(v0, v1, t);-}--SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) {-  return ldexp(x, y);-}--SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) {-  return copysign(x, y);-}--SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) {-  return mad(a, b, c);-}--SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) {-  return fma(a, b, c);-}--#elif defined(ISPC)--SCALAR_FUN_ATTR float futrts_log32(float x) {-  return futrts_isfinite32(x) || (futrts_isinf32(x) && x < 0)? log(x) : x;-}--SCALAR_FUN_ATTR float futrts_log2_32(float x) {-  return futrts_log32(x) / log(2.0f);-}--SCALAR_FUN_ATTR float futrts_log10_32(float x) {-  return futrts_log32(x) / log(10.0f);-}--SCALAR_FUN_ATTR float futrts_log1p_32(float x) {-  if(x == -1.0f || (futrts_isinf32(x) && x > 0.0f)) return x / 0.0f;-  float y = 1.0f + x;-  float z = y - 1.0f;-  return log(y) - (z-x)/y;-}--SCALAR_FUN_ATTR float futrts_sqrt32(float x) {-  return sqrt(x);-}--extern "C" unmasked uniform float cbrtf(uniform float);-SCALAR_FUN_ATTR float futrts_cbrt32(float x) {-  float res;-  foreach_active (i) {-    uniform float r = cbrtf(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR float futrts_exp32(float x) {-  return exp(x);-}--SCALAR_FUN_ATTR float futrts_cos32(float x) {-  return cos(x);-}--SCALAR_FUN_ATTR float futrts_sin32(float x) {-  return sin(x);-}--SCALAR_FUN_ATTR float futrts_tan32(float x) {-  return tan(x);-}--SCALAR_FUN_ATTR float futrts_acos32(float x) {-  return acos(x);-}--SCALAR_FUN_ATTR float futrts_asin32(float x) {-  return asin(x);-}--SCALAR_FUN_ATTR float futrts_atan32(float x) {-  return atan(x);-}--SCALAR_FUN_ATTR float futrts_cosh32(float x) {-  return (exp(x)+exp(-x)) / 2.0f;-}--SCALAR_FUN_ATTR float futrts_sinh32(float x) {-  return (exp(x)-exp(-x)) / 2.0f;-}--SCALAR_FUN_ATTR float futrts_tanh32(float x) {-  return futrts_sinh32(x)/futrts_cosh32(x);-}--SCALAR_FUN_ATTR float futrts_acosh32(float x) {-  float f = x+sqrt(x*x-1);-  if(futrts_isfinite32(f)) return log(f);-  return f;-}--SCALAR_FUN_ATTR float futrts_asinh32(float x) {-  float f = x+sqrt(x*x+1);-  if(futrts_isfinite32(f)) return log(f);-  return f;--}--SCALAR_FUN_ATTR float futrts_atanh32(float x) {-  float f = (1+x)/(1-x);-  if(futrts_isfinite32(f)) return log(f)/2.0f;-  return f;--}--SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y) {-  return (x == 0.0f && y == 0.0f) ? 0.0f : atan2(x, y);-}--SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) {-  if (futrts_isfinite32(x) && futrts_isfinite32(y)) {-    x = abs(x);-    y = abs(y);-    float a;-    float b;-    if (x >= y){-        a = x;-        b = y;-    } else {-        a = y;-        b = x;-    }-    if(b == 0){-      return a;-    }--    int e;-    float an;-    float bn;-    an = frexp (a, &e);-    bn = ldexp (b, - e);-    float cn;-    cn = sqrt (an * an + bn * bn);-    return ldexp (cn, e);-  } else {-    if (futrts_isinf32(x) || futrts_isinf32(y)) return INFINITY;-    else return x + y;-  }--}--extern "C" unmasked uniform float tgammaf(uniform float x);-SCALAR_FUN_ATTR float futrts_gamma32(float x) {-  float res;-  foreach_active (i) {-    uniform float r = tgammaf(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--extern "C" unmasked uniform float lgammaf(uniform float x);-SCALAR_FUN_ATTR float futrts_lgamma32(float x) {-  float res;-  foreach_active (i) {-    uniform float r = lgammaf(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--extern "C" unmasked uniform float erff(uniform float x);-SCALAR_FUN_ATTR float futrts_erf32(float x) {-  float res;-  foreach_active (i) {-    uniform float r = erff(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--extern "C" unmasked uniform float erfcf(uniform float x);-SCALAR_FUN_ATTR float futrts_erfc32(float x) {-  float res;-  foreach_active (i) {-    uniform float r = erfcf(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR float fmod32(float x, float y) {-  return x - y * trunc(x/y);-}--SCALAR_FUN_ATTR float futrts_round32(float x) {-  return round(x);-}--SCALAR_FUN_ATTR float futrts_floor32(float x) {-  return floor(x);-}--SCALAR_FUN_ATTR float futrts_ceil32(float x) {-  return ceil(x);-}--extern "C" unmasked uniform float nextafterf(uniform float x, uniform float y);-SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) {-  float res;-  foreach_active (i) {-    uniform float r = nextafterf(extract(x, i), extract(y, i));-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) {-  return v0 + (v1 - v0) * t;-}--SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) {-  return x * pow((uniform float)2.0, (float)y);-}--SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) {-  int32_t xb = futrts_to_bits32(x);-  int32_t yb = futrts_to_bits32(y);-  return futrts_from_bits32((xb & ~(1<<31)) | (yb & (1<<31)));-}--SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) {-  return a * b + c;-}--SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) {-  return a * b + c;-}--#else // Not OpenCL or ISPC, but CUDA or plain C.--SCALAR_FUN_ATTR float futrts_log32(float x) {-  return logf(x);-}--SCALAR_FUN_ATTR float futrts_log2_32(float x) {-  return log2f(x);-}--SCALAR_FUN_ATTR float futrts_log10_32(float x) {-  return log10f(x);-}--SCALAR_FUN_ATTR float futrts_log1p_32(float x) {-  return log1pf(x);-}--SCALAR_FUN_ATTR float futrts_sqrt32(float x) {-  return sqrtf(x);-}--SCALAR_FUN_ATTR float futrts_cbrt32(float x) {-  return cbrtf(x);-}--SCALAR_FUN_ATTR float futrts_exp32(float x) {-  return expf(x);-}--SCALAR_FUN_ATTR float futrts_cos32(float x) {-  return cosf(x);-}--SCALAR_FUN_ATTR float futrts_sin32(float x) {-  return sinf(x);-}--SCALAR_FUN_ATTR float futrts_tan32(float x) {-  return tanf(x);-}--SCALAR_FUN_ATTR float futrts_acos32(float x) {-  return acosf(x);-}--SCALAR_FUN_ATTR float futrts_asin32(float x) {-  return asinf(x);-}--SCALAR_FUN_ATTR float futrts_atan32(float x) {-  return atanf(x);-}--SCALAR_FUN_ATTR float futrts_cosh32(float x) {-  return coshf(x);-}--SCALAR_FUN_ATTR float futrts_sinh32(float x) {-  return sinhf(x);-}--SCALAR_FUN_ATTR float futrts_tanh32(float x) {-  return tanhf(x);-}--SCALAR_FUN_ATTR float futrts_acosh32(float x) {-  return acoshf(x);-}--SCALAR_FUN_ATTR float futrts_asinh32(float x) {-  return asinhf(x);-}--SCALAR_FUN_ATTR float futrts_atanh32(float x) {-  return atanhf(x);-}--SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y) {-  return atan2f(x, y);-}--SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) {-  return hypotf(x, y);-}--SCALAR_FUN_ATTR float futrts_gamma32(float x) {-  return tgammaf(x);-}--SCALAR_FUN_ATTR float futrts_lgamma32(float x) {-  return lgammaf(x);-}--SCALAR_FUN_ATTR float futrts_erf32(float x) {-  return erff(x);-}--SCALAR_FUN_ATTR float futrts_erfc32(float x) {-  return erfcf(x);-}--SCALAR_FUN_ATTR float fmod32(float x, float y) {-  return fmodf(x, y);-}--SCALAR_FUN_ATTR float futrts_round32(float x) {-  return rintf(x);-}--SCALAR_FUN_ATTR float futrts_floor32(float x) {-  return floorf(x);-}--SCALAR_FUN_ATTR float futrts_ceil32(float x) {-  return ceilf(x);-}--SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) {-  return nextafterf(x, y);-}--SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) {-  return v0 + (v1 - v0) * t;-}--SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) {-  return ldexpf(x, y);-}--SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) {-  return copysignf(x, y);-}--SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) {-  return a * b + c;-}--SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) {-  return fmaf(a, b, c);-}-#endif--#if defined(ISPC)-SCALAR_FUN_ATTR int32_t futrts_to_bits32(float x) {-  return intbits(x);-}--SCALAR_FUN_ATTR float futrts_from_bits32(int32_t x) {-  return floatbits(x);-}-#else-SCALAR_FUN_ATTR int32_t futrts_to_bits32(float x) {-  union {-    float f;-    int32_t t;-  } p;--  p.f = x;-  return p.t;-}--SCALAR_FUN_ATTR float futrts_from_bits32(int32_t x) {-  union {-    int32_t f;-    float t;-  } p;--  p.f = x;-  return p.t;-}-#endif--SCALAR_FUN_ATTR float fsignum32(float x) {-  return futrts_isnan32(x) ? x : (x > 0 ? 1 : 0) - (x < 0 ? 1 : 0);-}--#ifdef FUTHARK_F64_ENABLED--SCALAR_FUN_ATTR double futrts_from_bits64(int64_t x);-SCALAR_FUN_ATTR int64_t futrts_to_bits64(double x);--#if defined(ISPC)-SCALAR_FUN_ATTR bool futrts_isinf64(float x) {-  return !isnan(x) && isnan(x - x);-}--SCALAR_FUN_ATTR bool futrts_isfinite64(float x) {-  return !isnan(x) && !futrts_isinf64(x);-}--SCALAR_FUN_ATTR double fdiv64(double x, double y) {-  return x / y;-}--SCALAR_FUN_ATTR double fadd64(double x, double y) {-  return x + y;-}--SCALAR_FUN_ATTR double fsub64(double x, double y) {-  return x - y;-}--SCALAR_FUN_ATTR double fmul64(double x, double y) {-  return x * y;-}--SCALAR_FUN_ATTR bool cmplt64(double x, double y) {-  return x < y;-}--SCALAR_FUN_ATTR bool cmple64(double x, double y) {-  return x <= y;-}--SCALAR_FUN_ATTR double sitofp_i8_f64(int8_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double sitofp_i16_f64(int16_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double sitofp_i32_f64(int32_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double sitofp_i64_f64(int64_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i8_f64(uint8_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i16_f64(uint16_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i32_f64(uint32_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i64_f64(uint64_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double fabs64(double x) {-  return abs(x);-}--SCALAR_FUN_ATTR double fmax64(double x, double y) {-  return isnan(x) ? y : isnan(y) ? x : max(x, y);-}--SCALAR_FUN_ATTR double fmin64(double x, double y) {-  return isnan(x) ? y : isnan(y) ? x : min(x, y);-}--SCALAR_FUN_ATTR double fpow64(double a, double b) {-  float ret;-  foreach_active (i) {-      uniform float r = pow(extract(a, i), extract(b, i));-      ret = insert(ret, i, r);-  }-  return ret;-}--SCALAR_FUN_ATTR double futrts_log64(double x) {-  return futrts_isfinite64(x) || (futrts_isinf64(x) && x < 0)? log(x) : x;-}--SCALAR_FUN_ATTR double futrts_log2_64(double x) {-  return futrts_log64(x)/log(2.0d);-}--SCALAR_FUN_ATTR double futrts_log10_64(double x) {-  return futrts_log64(x)/log(10.0d);-}--SCALAR_FUN_ATTR double futrts_log1p_64(double x) {-  if(x == -1.0d || (futrts_isinf64(x) && x > 0.0d)) return x / 0.0d;-  double y = 1.0d + x;-  double z = y - 1.0d;-  return log(y) - (z-x)/y;-}--SCALAR_FUN_ATTR double futrts_sqrt64(double x) {-  return sqrt(x);-}--extern "C" unmasked uniform double cbrt(uniform double);-SCALAR_FUN_ATTR double futrts_cbrt64(double x) {-  double res;-  foreach_active (i) {-    uniform double r = cbrtf(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR double futrts_exp64(double x) {-  return exp(x);-}--SCALAR_FUN_ATTR double futrts_cos64(double x) {-  return cos(x);-}--SCALAR_FUN_ATTR double futrts_sin64(double x) {-  return sin(x);-}--SCALAR_FUN_ATTR double futrts_tan64(double x) {-  return tan(x);-}--SCALAR_FUN_ATTR double futrts_acos64(double x) {-  return acos(x);-}--SCALAR_FUN_ATTR double futrts_asin64(double x) {-  return asin(x);-}--SCALAR_FUN_ATTR double futrts_atan64(double x) {-  return atan(x);-}--SCALAR_FUN_ATTR double futrts_cosh64(double x) {-  return (exp(x)+exp(-x)) / 2.0d;-}--SCALAR_FUN_ATTR double futrts_sinh64(double x) {-  return (exp(x)-exp(-x)) / 2.0d;-}--SCALAR_FUN_ATTR double futrts_tanh64(double x) {-  return futrts_sinh64(x)/futrts_cosh64(x);-}--SCALAR_FUN_ATTR double futrts_acosh64(double x) {-  double f = x+sqrt(x*x-1.0d);-  if(futrts_isfinite64(f)) return log(f);-  return f;-}--SCALAR_FUN_ATTR double futrts_asinh64(double x) {-  double f = x+sqrt(x*x+1.0d);-  if(futrts_isfinite64(f)) return log(f);-  return f;-}--SCALAR_FUN_ATTR double futrts_atanh64(double x) {-  double f = (1.0d+x)/(1.0d-x);-  if(futrts_isfinite64(f)) return log(f)/2.0d;-  return f;--}--SCALAR_FUN_ATTR double futrts_atan2_64(double x, double y) {-  return atan2(x, y);-}--extern "C" unmasked uniform double hypot(uniform double x, uniform double y);-SCALAR_FUN_ATTR double futrts_hypot64(double x, double y) {-  double res;-  foreach_active (i) {-    uniform double r = hypot(extract(x, i), extract(y, i));-    res = insert(res, i, r);-  }-  return res;-}--extern "C" unmasked uniform double tgamma(uniform double x);-SCALAR_FUN_ATTR double futrts_gamma64(double x) {-  double res;-  foreach_active (i) {-    uniform double r = tgamma(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--extern "C" unmasked uniform double lgamma(uniform double x);-SCALAR_FUN_ATTR double futrts_lgamma64(double x) {-  double res;-  foreach_active (i) {-    uniform double r = lgamma(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--extern "C" unmasked uniform double erf(uniform double x);-SCALAR_FUN_ATTR double futrts_erf64(double x) {-  double res;-  foreach_active (i) {-    uniform double r = erf(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--extern "C" unmasked uniform double erfc(uniform double x);-SCALAR_FUN_ATTR double futrts_erfc64(double x) {-  double res;-  foreach_active (i) {-    uniform double r = erfc(extract(x, i));-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR double futrts_fma64(double a, double b, double c) {-  return a * b + c;-}--SCALAR_FUN_ATTR double futrts_round64(double x) {-  return round(x);-}--SCALAR_FUN_ATTR double futrts_ceil64(double x) {-  return ceil(x);-}--extern "C" unmasked uniform double nextafter(uniform float x, uniform double y);-SCALAR_FUN_ATTR float futrts_nextafter64(double x, double y) {-  double res;-  foreach_active (i) {-    uniform double r = nextafter(extract(x, i), extract(y, i));-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR double futrts_floor64(double x) {-  return floor(x);-}--SCALAR_FUN_ATTR bool futrts_isnan64(double x) {-  return isnan(x);-}--SCALAR_FUN_ATTR int8_t fptosi_f64_i8(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int8_t) x;-  }-}--SCALAR_FUN_ATTR int16_t fptosi_f64_i16(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int16_t) x;-  }-}--SCALAR_FUN_ATTR int32_t fptosi_f64_i32(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int32_t) x;-  }-}--SCALAR_FUN_ATTR int64_t fptosi_f64_i64(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int64_t) x;-  }-}--SCALAR_FUN_ATTR uint8_t fptoui_f64_i8(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint8_t) (int8_t) x;-  }-}--SCALAR_FUN_ATTR uint16_t fptoui_f64_i16(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint16_t) (int16_t) x;-  }-}--SCALAR_FUN_ATTR uint32_t fptoui_f64_i32(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint32_t) (int32_t) x;-  }-}--SCALAR_FUN_ATTR uint64_t fptoui_f64_i64(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint64_t) (int64_t) x;-  }-}--SCALAR_FUN_ATTR bool ftob_f64_bool(double x) {-  return x != 0.0;-}--SCALAR_FUN_ATTR double btof_bool_f64(bool x) {-  return x ? 1.0 : 0.0;-}--SCALAR_FUN_ATTR int64_t futrts_to_bits64(double x) {-  int64_t res;-  foreach_active (i) {-    uniform double tmp = extract(x, i);-    uniform int64_t r = *((uniform int64_t* uniform)&tmp);-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR double futrts_from_bits64(int64_t x) {-  double res;-  foreach_active (i) {-    uniform int64_t tmp = extract(x, i);-    uniform double r = *((uniform double* uniform)&tmp);-    res = insert(res, i, r);-  }-  return res;-}--SCALAR_FUN_ATTR double fmod64(double x, double y) {-  return x - y * trunc(x/y);-}--SCALAR_FUN_ATTR double fsignum64(double x) {-  return futrts_isnan64(x) ? x : (x > 0 ? 1.0d : 0.0d) - (x < 0 ? 1.0d : 0.0d);-}--SCALAR_FUN_ATTR double futrts_lerp64(double v0, double v1, double t) {-  return v0 + (v1 - v0) * t;-}--SCALAR_FUN_ATTR double futrts_ldexp64(double x, int32_t y) {-  return x * pow((uniform double)2.0, (double)y);-}--SCALAR_FUN_ATTR double futrts_copysign64(double x, double y) {-  int64_t xb = futrts_to_bits64(x);-  int64_t yb = futrts_to_bits64(y);-  return futrts_from_bits64((xb & ~(((int64_t)1)<<63)) | (yb & (((int64_t)1)<<63)));-}--SCALAR_FUN_ATTR double futrts_mad64(double a, double b, double c) {-  return a * b + c;-}--SCALAR_FUN_ATTR float fpconv_f32_f32(float x) {-  return (float) x;-}--SCALAR_FUN_ATTR double fpconv_f32_f64(float x) {-  return (double) x;-}--SCALAR_FUN_ATTR float fpconv_f64_f32(double x) {-  return (float) x;-}--SCALAR_FUN_ATTR double fpconv_f64_f64(double x) {-  return (double) x;-}--#else--SCALAR_FUN_ATTR double fdiv64(double x, double y) {-  return x / y;-}--SCALAR_FUN_ATTR double fadd64(double x, double y) {-  return x + y;-}--SCALAR_FUN_ATTR double fsub64(double x, double y) {-  return x - y;-}--SCALAR_FUN_ATTR double fmul64(double x, double y) {-  return x * y;-}--SCALAR_FUN_ATTR bool cmplt64(double x, double y) {-  return x < y;-}--SCALAR_FUN_ATTR bool cmple64(double x, double y) {-  return x <= y;-}--SCALAR_FUN_ATTR double sitofp_i8_f64(int8_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double sitofp_i16_f64(int16_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double sitofp_i32_f64(int32_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double sitofp_i64_f64(int64_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i8_f64(uint8_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i16_f64(uint16_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i32_f64(uint32_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double uitofp_i64_f64(uint64_t x) {-  return (double) x;-}--SCALAR_FUN_ATTR double fabs64(double x) {-  return fabs(x);-}--SCALAR_FUN_ATTR double fmax64(double x, double y) {-  return fmax(x, y);-}--SCALAR_FUN_ATTR double fmin64(double x, double y) {-  return fmin(x, y);-}--SCALAR_FUN_ATTR double fpow64(double x, double y) {-  return pow(x, y);-}--SCALAR_FUN_ATTR double futrts_log64(double x) {-  return log(x);-}--SCALAR_FUN_ATTR double futrts_log2_64(double x) {-  return log2(x);-}--SCALAR_FUN_ATTR double futrts_log10_64(double x) {-  return log10(x);-}--SCALAR_FUN_ATTR double futrts_log1p_64(double x) {-  return log1p(x);-}--SCALAR_FUN_ATTR double futrts_sqrt64(double x) {-  return sqrt(x);-}--SCALAR_FUN_ATTR double futrts_cbrt64(double x) {-  return cbrt(x);-}--SCALAR_FUN_ATTR double futrts_exp64(double x) {-  return exp(x);-}--SCALAR_FUN_ATTR double futrts_cos64(double x) {-  return cos(x);-}--SCALAR_FUN_ATTR double futrts_sin64(double x) {-  return sin(x);-}--SCALAR_FUN_ATTR double futrts_tan64(double x) {-  return tan(x);-}--SCALAR_FUN_ATTR double futrts_acos64(double x) {-  return acos(x);-}--SCALAR_FUN_ATTR double futrts_asin64(double x) {-  return asin(x);-}--SCALAR_FUN_ATTR double futrts_atan64(double x) {-  return atan(x);-}--SCALAR_FUN_ATTR double futrts_cosh64(double x) {-  return cosh(x);-}--SCALAR_FUN_ATTR double futrts_sinh64(double x) {-  return sinh(x);-}--SCALAR_FUN_ATTR double futrts_tanh64(double x) {-  return tanh(x);-}--SCALAR_FUN_ATTR double futrts_acosh64(double x) {-  return acosh(x);-}--SCALAR_FUN_ATTR double futrts_asinh64(double x) {-  return asinh(x);-}--SCALAR_FUN_ATTR double futrts_atanh64(double x) {-  return atanh(x);-}--SCALAR_FUN_ATTR double futrts_atan2_64(double x, double y) {-  return atan2(x, y);-}--SCALAR_FUN_ATTR double futrts_hypot64(double x, double y) {-  return hypot(x, y);-}--SCALAR_FUN_ATTR double futrts_gamma64(double x) {-  return tgamma(x);-}--SCALAR_FUN_ATTR double futrts_lgamma64(double x) {-  return lgamma(x);-}--SCALAR_FUN_ATTR double futrts_erf64(double x) {-  return erf(x);-}--SCALAR_FUN_ATTR double futrts_erfc64(double x) {-  return erfc(x);-}--SCALAR_FUN_ATTR double futrts_fma64(double a, double b, double c) {-  return fma(a, b, c);-}--SCALAR_FUN_ATTR double futrts_round64(double x) {-  return rint(x);-}--SCALAR_FUN_ATTR double futrts_ceil64(double x) {-  return ceil(x);-}--SCALAR_FUN_ATTR float futrts_nextafter64(float x, float y) {-  return nextafter(x, y);-}--SCALAR_FUN_ATTR double futrts_floor64(double x) {-  return floor(x);-}--SCALAR_FUN_ATTR bool futrts_isnan64(double x) {-  return isnan(x);-}--SCALAR_FUN_ATTR bool futrts_isinf64(double x) {-  return isinf(x);-}--SCALAR_FUN_ATTR int8_t fptosi_f64_i8(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int8_t) x;-  }-}--SCALAR_FUN_ATTR int16_t fptosi_f64_i16(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int16_t) x;-  }-}--SCALAR_FUN_ATTR int32_t fptosi_f64_i32(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int32_t) x;-  }-}--SCALAR_FUN_ATTR int64_t fptosi_f64_i64(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (int64_t) x;-  }-}--SCALAR_FUN_ATTR uint8_t fptoui_f64_i8(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint8_t) (int8_t) x;-  }-}--SCALAR_FUN_ATTR uint16_t fptoui_f64_i16(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint16_t) (int16_t) x;-  }-}--SCALAR_FUN_ATTR uint32_t fptoui_f64_i32(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint32_t) (int32_t) x;-  }-}--SCALAR_FUN_ATTR uint64_t fptoui_f64_i64(double x) {-  if (futrts_isnan64(x) || futrts_isinf64(x)) {-    return 0;-  } else {-    return (uint64_t) (int64_t) x;-  }-}--SCALAR_FUN_ATTR bool ftob_f64_bool(double x) {-  return x != 0;-}--SCALAR_FUN_ATTR double btof_bool_f64(bool x) {-  return x ? 1 : 0;-}--SCALAR_FUN_ATTR int64_t futrts_to_bits64(double x) {-  union {-    double f;-    int64_t t;-  } p;--  p.f = x;-  return p.t;-}--SCALAR_FUN_ATTR double futrts_from_bits64(int64_t x) {-  union {-    int64_t f;-    double t;-  } p;--  p.f = x;-  return p.t;-}--SCALAR_FUN_ATTR double fmod64(double x, double y) {-  return fmod(x, y);-}--SCALAR_FUN_ATTR double fsignum64(double x) {-  return futrts_isnan64(x) ? x : (x > 0) - (x < 0);-}--SCALAR_FUN_ATTR double futrts_lerp64(double v0, double v1, double t) {-#ifdef __OPENCL_VERSION__-  return mix(v0, v1, t);-#else-  return v0 + (v1 - v0) * t;-#endif-}--SCALAR_FUN_ATTR double futrts_ldexp64(double x, int32_t y) {-  return ldexp(x, y);-}--SCALAR_FUN_ATTR float futrts_copysign64(double x, double y) {-  return copysign(x, y);-}--SCALAR_FUN_ATTR double futrts_mad64(double a, double b, double c) {-#ifdef __OPENCL_VERSION__-  return mad(a, b, c);-#else-  return a * b + c;-#endif-}--SCALAR_FUN_ATTR float fpconv_f32_f32(float x) {-  return (float) x;-}--SCALAR_FUN_ATTR double fpconv_f32_f64(float x) {-  return (double) x;-}--SCALAR_FUN_ATTR float fpconv_f64_f32(double x) {-  return (float) x;-}--SCALAR_FUN_ATTR double fpconv_f64_f64(double x) {-  return (double) x;-}+#ifndef M_PI+#define M_PI 3.141592653589793+#endif++SCALAR_FUN_ATTR int32_t futrts_to_bits32(float x);+SCALAR_FUN_ATTR float futrts_from_bits32(int32_t x);++SCALAR_FUN_ATTR uint8_t   add8(uint8_t x, uint8_t y)   { return x + y; }+SCALAR_FUN_ATTR uint16_t add16(uint16_t x, uint16_t y) { return x + y; }+SCALAR_FUN_ATTR uint32_t add32(uint32_t x, uint32_t y) { return x + y; }+SCALAR_FUN_ATTR uint64_t add64(uint64_t x, uint64_t y) { return x + y; }++SCALAR_FUN_ATTR uint8_t   sub8(uint8_t x, uint8_t y)   { return x - y; }+SCALAR_FUN_ATTR uint16_t sub16(uint16_t x, uint16_t y) { return x - y; }+SCALAR_FUN_ATTR uint32_t sub32(uint32_t x, uint32_t y) { return x - y; }+SCALAR_FUN_ATTR uint64_t sub64(uint64_t x, uint64_t y) { return x - y; }++SCALAR_FUN_ATTR uint8_t   mul8(uint8_t x, uint8_t y)   { return x * y; }+SCALAR_FUN_ATTR uint16_t mul16(uint16_t x, uint16_t y) { return x * y; }+SCALAR_FUN_ATTR uint32_t mul32(uint32_t x, uint32_t y) { return x * y; }+SCALAR_FUN_ATTR uint64_t mul64(uint64_t x, uint64_t y) { return x * y; }++#if defined(ISPC)++SCALAR_FUN_ATTR uint8_t udiv8(uint8_t x, uint8_t y) {+  // This strange pattern is used to prevent the ISPC compiler from+  // causing SIGFPEs and bogus results on divisions where inactive lanes+  // have 0-valued divisors. It ensures that any inactive lane instead+  // has a divisor of 1. https://github.com/ispc/ispc/issues/2292+  uint8_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR uint16_t udiv16(uint16_t x, uint16_t y) {+  uint16_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR uint32_t udiv32(uint32_t x, uint32_t y) {+  uint32_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR uint64_t udiv64(uint64_t x, uint64_t y) {+  uint64_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR uint8_t udiv_up8(uint8_t x, uint8_t y) {+  uint8_t ys = 1;+  foreach_active(i) { ys = y; }+  return (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint16_t udiv_up16(uint16_t x, uint16_t y) {+  uint16_t ys = 1;+  foreach_active(i) { ys = y; }+  return (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint32_t udiv_up32(uint32_t x, uint32_t y) {+  uint32_t ys = 1;+  foreach_active(i) { ys = y; }+  return (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint64_t udiv_up64(uint64_t x, uint64_t y) {+  uint64_t ys = 1;+  foreach_active(i) { ys = y; }+  return (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint8_t umod8(uint8_t x, uint8_t y) {+  uint8_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR uint16_t umod16(uint16_t x, uint16_t y) {+  uint16_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR uint32_t umod32(uint32_t x, uint32_t y) {+  uint32_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR uint64_t umod64(uint64_t x, uint64_t y) {+  uint64_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR uint8_t udiv_safe8(uint8_t x, uint8_t y) {+  uint8_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR uint16_t udiv_safe16(uint16_t x, uint16_t y) {+  uint16_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR uint32_t udiv_safe32(uint32_t x, uint32_t y) {+  uint32_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR uint64_t udiv_safe64(uint64_t x, uint64_t y) {+  uint64_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR uint8_t udiv_up_safe8(uint8_t x, uint8_t y) {+  uint8_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint16_t udiv_up_safe16(uint16_t x, uint16_t y) {+  uint16_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint32_t udiv_up_safe32(uint32_t x, uint32_t y) {+  uint32_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint64_t udiv_up_safe64(uint64_t x, uint64_t y) {+  uint64_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : (x + y - 1) / ys;+}++SCALAR_FUN_ATTR uint8_t umod_safe8(uint8_t x, uint8_t y) {+  uint8_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++SCALAR_FUN_ATTR uint16_t umod_safe16(uint16_t x, uint16_t y) {+  uint16_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++SCALAR_FUN_ATTR uint32_t umod_safe32(uint32_t x, uint32_t y) {+  uint32_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++SCALAR_FUN_ATTR uint64_t umod_safe64(uint64_t x, uint64_t y) {+  uint64_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++SCALAR_FUN_ATTR int8_t sdiv8(int8_t x, int8_t y) {+  int8_t ys = 1;+  foreach_active(i) { ys = y; }+  int8_t q = x / ys;+  int8_t r = x % ys;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int16_t sdiv16(int16_t x, int16_t y) {+  int16_t ys = 1;+  foreach_active(i) { ys = y; }+  int16_t q = x / ys;+  int16_t r = x % ys;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int32_t sdiv32(int32_t x, int32_t y) {+  int32_t ys = 1;+  foreach_active(i) { ys = y; }+  int32_t q = x / ys;+  int32_t r = x % ys;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int64_t sdiv64(int64_t x, int64_t y) {+  int64_t ys = 1;+  foreach_active(i) { ys = y; }+  int64_t q = x / ys;+  int64_t r = x % ys;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int8_t sdiv_up8(int8_t x, int8_t y) { return sdiv8(x + y - 1, y); }+SCALAR_FUN_ATTR int16_t sdiv_up16(int16_t x, int16_t y) { return sdiv16(x + y - 1, y); }+SCALAR_FUN_ATTR int32_t sdiv_up32(int32_t x, int32_t y) { return sdiv32(x + y - 1, y); }+SCALAR_FUN_ATTR int64_t sdiv_up64(int64_t x, int64_t y) { return sdiv64(x + y - 1, y); }++SCALAR_FUN_ATTR int8_t smod8(int8_t x, int8_t y) {+  int8_t ys = 1;+  foreach_active(i) { ys = y; }+  int8_t r = x % ys;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int16_t smod16(int16_t x, int16_t y) {+  int16_t ys = 1;+  foreach_active(i) { ys = y; }+  int16_t r = x % ys;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int32_t smod32(int32_t x, int32_t y) {+  int32_t ys = 1;+  foreach_active(i) { ys = y; }+  int32_t r = x % ys;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int64_t smod64(int64_t x, int64_t y) {+  int64_t ys = 1;+  foreach_active(i) { ys = y; }+  int64_t r = x % ys;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int8_t   sdiv_safe8(int8_t x, int8_t y)   { return y == 0 ? 0 : sdiv8(x, y); }+SCALAR_FUN_ATTR int16_t sdiv_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : sdiv16(x, y); }+SCALAR_FUN_ATTR int32_t sdiv_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : sdiv32(x, y); }+SCALAR_FUN_ATTR int64_t sdiv_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : sdiv64(x, y); }++SCALAR_FUN_ATTR int8_t sdiv_up_safe8(int8_t x, int8_t y)     { return sdiv_safe8(x + y - 1, y); }+SCALAR_FUN_ATTR int16_t sdiv_up_safe16(int16_t x, int16_t y) { return sdiv_safe16(x + y - 1, y); }+SCALAR_FUN_ATTR int32_t sdiv_up_safe32(int32_t x, int32_t y) { return sdiv_safe32(x + y - 1, y); }+SCALAR_FUN_ATTR int64_t sdiv_up_safe64(int64_t x, int64_t y) { return sdiv_safe64(x + y - 1, y); }++SCALAR_FUN_ATTR int8_t   smod_safe8(int8_t x, int8_t y)   { return y == 0 ? 0 : smod8(x, y); }+SCALAR_FUN_ATTR int16_t smod_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : smod16(x, y); }+SCALAR_FUN_ATTR int32_t smod_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : smod32(x, y); }+SCALAR_FUN_ATTR int64_t smod_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : smod64(x, y); }++SCALAR_FUN_ATTR int8_t squot8(int8_t x, int8_t y) {+  int8_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR int16_t squot16(int16_t x, int16_t y) {+  int16_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR int32_t squot32(int32_t x, int32_t y) {+  int32_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR int64_t squot64(int64_t x, int64_t y) {+  int64_t ys = 1;+  foreach_active(i) { ys = y; }+  return x / ys;+}++SCALAR_FUN_ATTR int8_t srem8(int8_t x, int8_t y) {+  int8_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR int16_t srem16(int16_t x, int16_t y) {+  int16_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR int32_t srem32(int32_t x, int32_t y) {+  int32_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR int64_t srem64(int64_t x, int64_t y) {+  int8_t ys = 1;+  foreach_active(i) { ys = y; }+  return x % ys;+}++SCALAR_FUN_ATTR int8_t squot_safe8(int8_t x, int8_t y) {+  int8_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR int16_t squot_safe16(int16_t x, int16_t y) {+  int16_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR int32_t squot_safe32(int32_t x, int32_t y) {+  int32_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR int64_t squot_safe64(int64_t x, int64_t y) {+  int64_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x / ys;+}++SCALAR_FUN_ATTR int8_t srem_safe8(int8_t x, int8_t y) {+  int8_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++SCALAR_FUN_ATTR int16_t srem_safe16(int16_t x, int16_t y) {+  int16_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++SCALAR_FUN_ATTR int32_t srem_safe32(int32_t x, int32_t y) {+  int32_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++SCALAR_FUN_ATTR int64_t srem_safe64(int64_t x, int64_t y) {+  int64_t ys = 1;+  foreach_active(i) { ys = y; }+  return y == 0 ? 0 : x % ys;+}++#else++SCALAR_FUN_ATTR uint8_t   udiv8(uint8_t x, uint8_t y)   { return x / y; }+SCALAR_FUN_ATTR uint16_t udiv16(uint16_t x, uint16_t y) { return x / y; }+SCALAR_FUN_ATTR uint32_t udiv32(uint32_t x, uint32_t y) { return x / y; }+SCALAR_FUN_ATTR uint64_t udiv64(uint64_t x, uint64_t y) { return x / y; }++SCALAR_FUN_ATTR uint8_t   udiv_up8(uint8_t x, uint8_t y)   { return (x + y - 1) / y; }+SCALAR_FUN_ATTR uint16_t udiv_up16(uint16_t x, uint16_t y) { return (x + y - 1) / y; }+SCALAR_FUN_ATTR uint32_t udiv_up32(uint32_t x, uint32_t y) { return (x + y - 1) / y; }+SCALAR_FUN_ATTR uint64_t udiv_up64(uint64_t x, uint64_t y) { return (x + y - 1) / y; }++SCALAR_FUN_ATTR uint8_t   umod8(uint8_t x, uint8_t y)   { return x % y; }+SCALAR_FUN_ATTR uint16_t umod16(uint16_t x, uint16_t y) { return x % y; }+SCALAR_FUN_ATTR uint32_t umod32(uint32_t x, uint32_t y) { return x % y; }+SCALAR_FUN_ATTR uint64_t umod64(uint64_t x, uint64_t y) { return x % y; }++SCALAR_FUN_ATTR uint8_t   udiv_safe8(uint8_t x, uint8_t y)   { return y == 0 ? 0 : x / y; }+SCALAR_FUN_ATTR uint16_t udiv_safe16(uint16_t x, uint16_t y) { return y == 0 ? 0 : x / y; }+SCALAR_FUN_ATTR uint32_t udiv_safe32(uint32_t x, uint32_t y) { return y == 0 ? 0 : x / y; }+SCALAR_FUN_ATTR uint64_t udiv_safe64(uint64_t x, uint64_t y) { return y == 0 ? 0 : x / y; }++SCALAR_FUN_ATTR uint8_t   udiv_up_safe8(uint8_t x, uint8_t y)   { return y == 0 ? 0 : (x + y - 1) / y; }+SCALAR_FUN_ATTR uint16_t udiv_up_safe16(uint16_t x, uint16_t y) { return y == 0 ? 0 : (x + y - 1) / y; }+SCALAR_FUN_ATTR uint32_t udiv_up_safe32(uint32_t x, uint32_t y) { return y == 0 ? 0 : (x + y - 1) / y; }+SCALAR_FUN_ATTR uint64_t udiv_up_safe64(uint64_t x, uint64_t y) { return y == 0 ? 0 : (x + y - 1) / y; }++SCALAR_FUN_ATTR uint8_t   umod_safe8(uint8_t x, uint8_t y)   { return y == 0 ? 0 : x % y; }+SCALAR_FUN_ATTR uint16_t umod_safe16(uint16_t x, uint16_t y) { return y == 0 ? 0 : x % y; }+SCALAR_FUN_ATTR uint32_t umod_safe32(uint32_t x, uint32_t y) { return y == 0 ? 0 : x % y; }+SCALAR_FUN_ATTR uint64_t umod_safe64(uint64_t x, uint64_t y) { return y == 0 ? 0 : x % y; }++SCALAR_FUN_ATTR int8_t sdiv8(int8_t x, int8_t y) {+  int8_t q = x / y;+  int8_t r = x % y;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int16_t sdiv16(int16_t x, int16_t y) {+  int16_t q = x / y;+  int16_t r = x % y;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int32_t sdiv32(int32_t x, int32_t y) {+  int32_t q = x / y;+  int32_t r = x % y;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int64_t sdiv64(int64_t x, int64_t y) {+  int64_t q = x / y;+  int64_t r = x % y;+  return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);+}++SCALAR_FUN_ATTR int8_t   sdiv_up8(int8_t x, int8_t y)   { return sdiv8(x + y - 1, y); }+SCALAR_FUN_ATTR int16_t sdiv_up16(int16_t x, int16_t y) { return sdiv16(x + y - 1, y); }+SCALAR_FUN_ATTR int32_t sdiv_up32(int32_t x, int32_t y) { return sdiv32(x + y - 1, y); }+SCALAR_FUN_ATTR int64_t sdiv_up64(int64_t x, int64_t y) { return sdiv64(x + y - 1, y); }++SCALAR_FUN_ATTR int8_t smod8(int8_t x, int8_t y) {+  int8_t r = x % y;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int16_t smod16(int16_t x, int16_t y) {+  int16_t r = x % y;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int32_t smod32(int32_t x, int32_t y) {+  int32_t r = x % y;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int64_t smod64(int64_t x, int64_t y) {+  int64_t r = x % y;+  return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);+}++SCALAR_FUN_ATTR int8_t   sdiv_safe8(int8_t x, int8_t y)   { return y == 0 ? 0 : sdiv8(x, y); }+SCALAR_FUN_ATTR int16_t sdiv_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : sdiv16(x, y); }+SCALAR_FUN_ATTR int32_t sdiv_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : sdiv32(x, y); }+SCALAR_FUN_ATTR int64_t sdiv_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : sdiv64(x, y); }++SCALAR_FUN_ATTR int8_t   sdiv_up_safe8(int8_t x, int8_t y)   { return sdiv_safe8(x + y - 1, y);}+SCALAR_FUN_ATTR int16_t sdiv_up_safe16(int16_t x, int16_t y) { return sdiv_safe16(x + y - 1, y); }+SCALAR_FUN_ATTR int32_t sdiv_up_safe32(int32_t x, int32_t y) { return sdiv_safe32(x + y - 1, y); }+SCALAR_FUN_ATTR int64_t sdiv_up_safe64(int64_t x, int64_t y) { return sdiv_safe64(x + y - 1, y); }++SCALAR_FUN_ATTR int8_t   smod_safe8(int8_t x, int8_t y)   { return y == 0 ? 0 : smod8(x, y); }+SCALAR_FUN_ATTR int16_t smod_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : smod16(x, y); }+SCALAR_FUN_ATTR int32_t smod_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : smod32(x, y); }+SCALAR_FUN_ATTR int64_t smod_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : smod64(x, y); }++SCALAR_FUN_ATTR int8_t   squot8(int8_t x, int8_t y)   { return x / y; }+SCALAR_FUN_ATTR int16_t squot16(int16_t x, int16_t y) { return x / y; }+SCALAR_FUN_ATTR int32_t squot32(int32_t x, int32_t y) { return x / y; }+SCALAR_FUN_ATTR int64_t squot64(int64_t x, int64_t y) { return x / y; }++SCALAR_FUN_ATTR int8_t   srem8(int8_t x, int8_t y)   { return x % y; }+SCALAR_FUN_ATTR int16_t srem16(int16_t x, int16_t y) { return x % y; }+SCALAR_FUN_ATTR int32_t srem32(int32_t x, int32_t y) { return x % y; }+SCALAR_FUN_ATTR int64_t srem64(int64_t x, int64_t y) { return x % y; }++SCALAR_FUN_ATTR int8_t   squot_safe8(int8_t x, int8_t y)   { return y == 0 ? 0 : x / y; }+SCALAR_FUN_ATTR int16_t squot_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : x / y; }+SCALAR_FUN_ATTR int32_t squot_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : x / y; }+SCALAR_FUN_ATTR int64_t squot_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : x / y; }++SCALAR_FUN_ATTR int8_t   srem_safe8(int8_t x, int8_t y)   { return y == 0 ? 0 : x % y; }+SCALAR_FUN_ATTR int16_t srem_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : x % y; }+SCALAR_FUN_ATTR int32_t srem_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : x % y; }+SCALAR_FUN_ATTR int64_t srem_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : x % y; }++#endif++SCALAR_FUN_ATTR int8_t   smin8(int8_t x, int8_t y)   { return x < y ? x : y; }+SCALAR_FUN_ATTR int16_t smin16(int16_t x, int16_t y) { return x < y ? x : y; }+SCALAR_FUN_ATTR int32_t smin32(int32_t x, int32_t y) { return x < y ? x : y; }+SCALAR_FUN_ATTR int64_t smin64(int64_t x, int64_t y) { return x < y ? x : y; }++SCALAR_FUN_ATTR uint8_t   umin8(uint8_t x, uint8_t y)   { return x < y ? x : y; }+SCALAR_FUN_ATTR uint16_t umin16(uint16_t x, uint16_t y) { return x < y ? x : y; }+SCALAR_FUN_ATTR uint32_t umin32(uint32_t x, uint32_t y) { return x < y ? x : y; }+SCALAR_FUN_ATTR uint64_t umin64(uint64_t x, uint64_t y) { return x < y ? x : y; }++SCALAR_FUN_ATTR int8_t  smax8(int8_t x, int8_t y)    { return x < y ? y : x; }+SCALAR_FUN_ATTR int16_t smax16(int16_t x, int16_t y) { return x < y ? y : x; }+SCALAR_FUN_ATTR int32_t smax32(int32_t x, int32_t y) { return x < y ? y : x; }+SCALAR_FUN_ATTR int64_t smax64(int64_t x, int64_t y) { return x < y ? y : x; }++SCALAR_FUN_ATTR uint8_t   umax8(uint8_t x, uint8_t y)   { return x < y ? y : x; }+SCALAR_FUN_ATTR uint16_t umax16(uint16_t x, uint16_t y) { return x < y ? y : x; }+SCALAR_FUN_ATTR uint32_t umax32(uint32_t x, uint32_t y) { return x < y ? y : x; }+SCALAR_FUN_ATTR uint64_t umax64(uint64_t x, uint64_t y) { return x < y ? y : x; }++SCALAR_FUN_ATTR uint8_t   shl8(uint8_t x, uint8_t y)   { return (uint8_t)(x << y); }+SCALAR_FUN_ATTR uint16_t shl16(uint16_t x, uint16_t y) { return (uint16_t)(x << y); }+SCALAR_FUN_ATTR uint32_t shl32(uint32_t x, uint32_t y) { return x << y; }+SCALAR_FUN_ATTR uint64_t shl64(uint64_t x, uint64_t y) { return x << y; }++SCALAR_FUN_ATTR uint8_t   lshr8(uint8_t x, uint8_t y)   { return x >> y; }+SCALAR_FUN_ATTR uint16_t lshr16(uint16_t x, uint16_t y) { return x >> y; }+SCALAR_FUN_ATTR uint32_t lshr32(uint32_t x, uint32_t y) { return x >> y; }+SCALAR_FUN_ATTR uint64_t lshr64(uint64_t x, uint64_t y) { return x >> y; }++SCALAR_FUN_ATTR int8_t   ashr8(int8_t x, int8_t y)   { return x >> y; }+SCALAR_FUN_ATTR int16_t ashr16(int16_t x, int16_t y) { return x >> y; }+SCALAR_FUN_ATTR int32_t ashr32(int32_t x, int32_t y) { return x >> y; }+SCALAR_FUN_ATTR int64_t ashr64(int64_t x, int64_t y) { return x >> y; }++SCALAR_FUN_ATTR uint8_t   and8(uint8_t x, uint8_t y)   { return x & y; }+SCALAR_FUN_ATTR uint16_t and16(uint16_t x, uint16_t y) { return x & y; }+SCALAR_FUN_ATTR uint32_t and32(uint32_t x, uint32_t y) { return x & y; }+SCALAR_FUN_ATTR uint64_t and64(uint64_t x, uint64_t y) { return x & y; }++SCALAR_FUN_ATTR uint8_t    or8(uint8_t x, uint8_t y)  { return x | y; }+SCALAR_FUN_ATTR uint16_t or16(uint16_t x, uint16_t y) { return x | y; }+SCALAR_FUN_ATTR uint32_t or32(uint32_t x, uint32_t y) { return x | y; }+SCALAR_FUN_ATTR uint64_t or64(uint64_t x, uint64_t y) { return x | y; }++SCALAR_FUN_ATTR uint8_t   xor8(uint8_t x, uint8_t y)   { return x ^ y; }+SCALAR_FUN_ATTR uint16_t xor16(uint16_t x, uint16_t y) { return x ^ y; }+SCALAR_FUN_ATTR uint32_t xor32(uint32_t x, uint32_t y) { return x ^ y; }+SCALAR_FUN_ATTR uint64_t xor64(uint64_t x, uint64_t y) { return x ^ y; }++SCALAR_FUN_ATTR bool ult8(uint8_t x, uint8_t y)    { return x < y; }+SCALAR_FUN_ATTR bool ult16(uint16_t x, uint16_t y) { return x < y; }+SCALAR_FUN_ATTR bool ult32(uint32_t x, uint32_t y) { return x < y; }+SCALAR_FUN_ATTR bool ult64(uint64_t x, uint64_t y) { return x < y; }++SCALAR_FUN_ATTR bool ule8(uint8_t x, uint8_t y)    { return x <= y; }+SCALAR_FUN_ATTR bool ule16(uint16_t x, uint16_t y) { return x <= y; }+SCALAR_FUN_ATTR bool ule32(uint32_t x, uint32_t y) { return x <= y; }+SCALAR_FUN_ATTR bool ule64(uint64_t x, uint64_t y) { return x <= y; }++SCALAR_FUN_ATTR bool  slt8(int8_t x, int8_t y)   { return x < y; }+SCALAR_FUN_ATTR bool slt16(int16_t x, int16_t y) { return x < y; }+SCALAR_FUN_ATTR bool slt32(int32_t x, int32_t y) { return x < y; }+SCALAR_FUN_ATTR bool slt64(int64_t x, int64_t y) { return x < y; }++SCALAR_FUN_ATTR bool  sle8(int8_t x, int8_t y)   { return x <= y; }+SCALAR_FUN_ATTR bool sle16(int16_t x, int16_t y) { return x <= y; }+SCALAR_FUN_ATTR bool sle32(int32_t x, int32_t y) { return x <= y; }+SCALAR_FUN_ATTR bool sle64(int64_t x, int64_t y) { return x <= y; }++SCALAR_FUN_ATTR uint8_t pow8(uint8_t x, uint8_t y) {+  uint8_t res = 1, rem = y;+  while (rem != 0) {+    if (rem & 1)+      res *= x;+    rem >>= 1;+    x *= x;+  }+  return res;+}++SCALAR_FUN_ATTR uint16_t pow16(uint16_t x, uint16_t y) {+  uint16_t res = 1, rem = y;+  while (rem != 0) {+    if (rem & 1)+      res *= x;+    rem >>= 1;+    x *= x;+  }+  return res;+}++SCALAR_FUN_ATTR uint32_t pow32(uint32_t x, uint32_t y) {+  uint32_t res = 1, rem = y;+  while (rem != 0) {+    if (rem & 1)+      res *= x;+    rem >>= 1;+    x *= x;+  }+  return res;+}++SCALAR_FUN_ATTR uint64_t pow64(uint64_t x, uint64_t y) {+  uint64_t res = 1, rem = y;+  while (rem != 0) {+    if (rem & 1)+      res *= x;+    rem >>= 1;+    x *= x;+  }+  return res;+}++SCALAR_FUN_ATTR bool  itob_i8_bool(int8_t x)  { return x != 0; }+SCALAR_FUN_ATTR bool itob_i16_bool(int16_t x) { return x != 0; }+SCALAR_FUN_ATTR bool itob_i32_bool(int32_t x) { return x != 0; }+SCALAR_FUN_ATTR bool itob_i64_bool(int64_t x) { return x != 0; }++SCALAR_FUN_ATTR int8_t btoi_bool_i8(bool x)   { return x; }+SCALAR_FUN_ATTR int16_t btoi_bool_i16(bool x) { return x; }+SCALAR_FUN_ATTR int32_t btoi_bool_i32(bool x) { return x; }+SCALAR_FUN_ATTR int64_t btoi_bool_i64(bool x) { return x; }++#define sext_i8_i8(x) ((int8_t) (int8_t) (x))+#define sext_i8_i16(x) ((int16_t) (int8_t) (x))+#define sext_i8_i32(x) ((int32_t) (int8_t) (x))+#define sext_i8_i64(x) ((int64_t) (int8_t) (x))+#define sext_i16_i8(x) ((int8_t) (int16_t) (x))+#define sext_i16_i16(x) ((int16_t) (int16_t) (x))+#define sext_i16_i32(x) ((int32_t) (int16_t) (x))+#define sext_i16_i64(x) ((int64_t) (int16_t) (x))+#define sext_i32_i8(x) ((int8_t) (int32_t) (x))+#define sext_i32_i16(x) ((int16_t) (int32_t) (x))+#define sext_i32_i32(x) ((int32_t) (int32_t) (x))+#define sext_i32_i64(x) ((int64_t) (int32_t) (x))+#define sext_i64_i8(x) ((int8_t) (int64_t) (x))+#define sext_i64_i16(x) ((int16_t) (int64_t) (x))+#define sext_i64_i32(x) ((int32_t) (int64_t) (x))+#define sext_i64_i64(x) ((int64_t) (int64_t) (x))+#define zext_i8_i8(x) ((int8_t) (uint8_t) (x))+#define zext_i8_i16(x) ((int16_t) (uint8_t) (x))+#define zext_i8_i32(x) ((int32_t) (uint8_t) (x))+#define zext_i8_i64(x) ((int64_t) (uint8_t) (x))+#define zext_i16_i8(x) ((int8_t) (uint16_t) (x))+#define zext_i16_i16(x) ((int16_t) (uint16_t) (x))+#define zext_i16_i32(x) ((int32_t) (uint16_t) (x))+#define zext_i16_i64(x) ((int64_t) (uint16_t) (x))+#define zext_i32_i8(x) ((int8_t) (uint32_t) (x))+#define zext_i32_i16(x) ((int16_t) (uint32_t) (x))+#define zext_i32_i32(x) ((int32_t) (uint32_t) (x))+#define zext_i32_i64(x) ((int64_t) (uint32_t) (x))+#define zext_i64_i8(x) ((int8_t) (uint64_t) (x))+#define zext_i64_i16(x) ((int16_t) (uint64_t) (x))+#define zext_i64_i32(x) ((int32_t) (uint64_t) (x))+#define zext_i64_i64(x) ((int64_t) (uint64_t) (x))++SCALAR_FUN_ATTR int8_t   abs8(int8_t x)  { return (int8_t)abs(x); }+SCALAR_FUN_ATTR int16_t abs16(int16_t x) { return (int16_t)abs(x); }+SCALAR_FUN_ATTR int32_t abs32(int32_t x) { return abs(x); }+SCALAR_FUN_ATTR int64_t abs64(int64_t x) {+#if defined(__OPENCL_VERSION__) || defined(ISPC)+  return abs(x);+#else+  return llabs(x);+#endif+}++#if defined(__OPENCL_VERSION__)++SCALAR_FUN_ATTR int32_t  futrts_popc8(int8_t x)  { return popcount(x); }+SCALAR_FUN_ATTR int32_t futrts_popc16(int16_t x) { return popcount(x); }+SCALAR_FUN_ATTR int32_t futrts_popc32(int32_t x) { return popcount(x); }+SCALAR_FUN_ATTR int32_t futrts_popc64(int64_t x) { return popcount(x); }++#elif defined(__CUDA_ARCH__)++SCALAR_FUN_ATTR int32_t  futrts_popc8(int8_t x)  { return __popc(zext_i8_i32(x)); }+SCALAR_FUN_ATTR int32_t futrts_popc16(int16_t x) { return __popc(zext_i16_i32(x)); }+SCALAR_FUN_ATTR int32_t futrts_popc32(int32_t x) { return __popc(x); }+SCALAR_FUN_ATTR int32_t futrts_popc64(int64_t x) { return __popcll(x); }++#else // Not OpenCL or CUDA, but plain C.++SCALAR_FUN_ATTR int32_t futrts_popc8(uint8_t x) {+  int c = 0;+  for (; x; ++c) { x &= x - 1; }+  return c;+}++SCALAR_FUN_ATTR int32_t futrts_popc16(uint16_t x) {+  int c = 0;+  for (; x; ++c) { x &= x - 1; }+  return c;+}++SCALAR_FUN_ATTR int32_t futrts_popc32(uint32_t x) {+  int c = 0;+  for (; x; ++c) { x &= x - 1; }+  return c;+}++SCALAR_FUN_ATTR int32_t futrts_popc64(uint64_t x) {+  int c = 0;+  for (; x; ++c) { x &= x - 1; }+  return c;+}+#endif++#if defined(__OPENCL_VERSION__)+SCALAR_FUN_ATTR uint8_t  futrts_umul_hi8 ( uint8_t a,  uint8_t b) { return mul_hi(a, b); }+SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return mul_hi(a, b); }+SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return mul_hi(a, b); }+SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return mul_hi(a, b); }+SCALAR_FUN_ATTR uint8_t  futrts_smul_hi8 ( int8_t a,  int8_t b) { return mul_hi(a, b); }+SCALAR_FUN_ATTR uint16_t futrts_smul_hi16(int16_t a, int16_t b) { return mul_hi(a, b); }+SCALAR_FUN_ATTR uint32_t futrts_smul_hi32(int32_t a, int32_t b) { return mul_hi(a, b); }+SCALAR_FUN_ATTR uint64_t futrts_smul_hi64(int64_t a, int64_t b) { return mul_hi(a, b); }+#elif defined(__CUDA_ARCH__)+SCALAR_FUN_ATTR  uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }+SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }+SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return __umulhi(a, b); }+SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return __umul64hi(a, b); }+SCALAR_FUN_ATTR  uint8_t futrts_smul_hi8 ( int8_t a, int8_t b) { return ((int16_t)a) * ((int16_t)b) >> 8; }+SCALAR_FUN_ATTR uint16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((int32_t)a) * ((int32_t)b) >> 16; }+SCALAR_FUN_ATTR uint32_t futrts_smul_hi32(int32_t a, int32_t b) { return __mulhi(a, b); }+SCALAR_FUN_ATTR uint64_t futrts_smul_hi64(int64_t a, int64_t b) { return __mul64hi(a, b); }+#elif defined(ISPC)+SCALAR_FUN_ATTR uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }+SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }+SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }+SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) {+  uint64_t ah = a >> 32;+  uint64_t al = a & 0xffffffff;+  uint64_t bh = b >> 32;+  uint64_t bl = b & 0xffffffff;++  uint64_t p1 = al * bl;+  uint64_t p2 = al * bh;+  uint64_t p3 = ah * bl;+  uint64_t p4 = ah * bh;++  uint64_t p1h = p1 >> 32;+  uint64_t p2h = p2 >> 32;+  uint64_t p3h = p3 >> 32;+  uint64_t p2l = p2 & 0xffffffff;+  uint64_t p3l = p3 & 0xffffffff;++  uint64_t l = p1h + p2l + p3l;+  uint64_t m = (p2 >> 32) + (p3 >> 32);+  uint64_t h = (l >> 32) + m + p4;++  return h;+}+SCALAR_FUN_ATTR  int8_t futrts_smul_hi8 ( int8_t a,  int8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }+SCALAR_FUN_ATTR int16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }+SCALAR_FUN_ATTR int32_t futrts_smul_hi32(int32_t a, int32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }+SCALAR_FUN_ATTR int64_t futrts_smul_hi64(int64_t a, int64_t b) {+  uint64_t ah = a >> 32;+  uint64_t al = a & 0xffffffff;+  uint64_t bh = b >> 32;+  uint64_t bl = b & 0xffffffff;++  uint64_t p1 =  al * bl;+  int64_t  p2 = al * bh;+  int64_t  p3 = ah * bl;+  uint64_t p4 =  ah * bh;++  uint64_t p1h = p1 >> 32;+  uint64_t p2h = p2 >> 32;+  uint64_t p3h = p3 >> 32;+  uint64_t p2l = p2 & 0xffffffff;+  uint64_t p3l = p3 & 0xffffffff;++  uint64_t l = p1h + p2l + p3l;+  uint64_t m = (p2 >> 32) + (p3 >> 32);+  uint64_t h = (l >> 32) + m + p4;++  return h;+}++#else // Not OpenCL, ISPC, or CUDA, but plain C.+SCALAR_FUN_ATTR uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }+SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }+SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }+SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return ((__uint128_t)a) * ((__uint128_t)b) >> 64; }+SCALAR_FUN_ATTR int8_t futrts_smul_hi8(int8_t a, int8_t b) { return ((int16_t)a) * ((int16_t)b) >> 8; }+SCALAR_FUN_ATTR int16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((int32_t)a) * ((int32_t)b) >> 16; }+SCALAR_FUN_ATTR int32_t futrts_smul_hi32(int32_t a, int32_t b) { return ((int64_t)a) * ((int64_t)b) >> 32; }+SCALAR_FUN_ATTR int64_t futrts_smul_hi64(int64_t a, int64_t b) { return ((__int128_t)a) * ((__int128_t)b) >> 64; }+#endif++#if defined(__OPENCL_VERSION__)+SCALAR_FUN_ATTR  uint8_t futrts_umad_hi8 ( uint8_t a,  uint8_t b,  uint8_t c) { return mad_hi(a, b, c); }+SCALAR_FUN_ATTR uint16_t futrts_umad_hi16(uint16_t a, uint16_t b, uint16_t c) { return mad_hi(a, b, c); }+SCALAR_FUN_ATTR uint32_t futrts_umad_hi32(uint32_t a, uint32_t b, uint32_t c) { return mad_hi(a, b, c); }+SCALAR_FUN_ATTR uint64_t futrts_umad_hi64(uint64_t a, uint64_t b, uint64_t c) { return mad_hi(a, b, c); }+SCALAR_FUN_ATTR  uint8_t futrts_smad_hi8( int8_t a,  int8_t b,   int8_t c) { return mad_hi(a, b, c); }+SCALAR_FUN_ATTR uint16_t futrts_smad_hi16(int16_t a, int16_t b, int16_t c) { return mad_hi(a, b, c); }+SCALAR_FUN_ATTR uint32_t futrts_smad_hi32(int32_t a, int32_t b, int32_t c) { return mad_hi(a, b, c); }+SCALAR_FUN_ATTR uint64_t futrts_smad_hi64(int64_t a, int64_t b, int64_t c) { return mad_hi(a, b, c); }+#else // Not OpenCL++SCALAR_FUN_ATTR  uint8_t futrts_umad_hi8( uint8_t a,  uint8_t b,  uint8_t c) { return futrts_umul_hi8(a, b) + c; }+SCALAR_FUN_ATTR uint16_t futrts_umad_hi16(uint16_t a, uint16_t b, uint16_t c) { return futrts_umul_hi16(a, b) + c; }+SCALAR_FUN_ATTR uint32_t futrts_umad_hi32(uint32_t a, uint32_t b, uint32_t c) { return futrts_umul_hi32(a, b) + c; }+SCALAR_FUN_ATTR uint64_t futrts_umad_hi64(uint64_t a, uint64_t b, uint64_t c) { return futrts_umul_hi64(a, b) + c; }+SCALAR_FUN_ATTR  uint8_t futrts_smad_hi8 ( int8_t a,  int8_t b,  int8_t c) { return futrts_smul_hi8(a, b) + c; }+SCALAR_FUN_ATTR uint16_t futrts_smad_hi16(int16_t a, int16_t b, int16_t c) { return futrts_smul_hi16(a, b) + c; }+SCALAR_FUN_ATTR uint32_t futrts_smad_hi32(int32_t a, int32_t b, int32_t c) { return futrts_smul_hi32(a, b) + c; }+SCALAR_FUN_ATTR uint64_t futrts_smad_hi64(int64_t a, int64_t b, int64_t c) { return futrts_smul_hi64(a, b) + c; }+#endif++#if defined(__OPENCL_VERSION__)+SCALAR_FUN_ATTR int32_t  futrts_clzz8(int8_t x)  { return clz(x); }+SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) { return clz(x); }+SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) { return clz(x); }+SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) { return clz(x); }++#elif defined(__CUDA_ARCH__)++SCALAR_FUN_ATTR int32_t  futrts_clzz8(int8_t x)  { return __clz(zext_i8_i32(x)) - 24; }+SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) { return __clz(zext_i16_i32(x)) - 16; }+SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) { return __clz(x); }+SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) { return __clzll(x); }++#elif defined(ISPC)++SCALAR_FUN_ATTR int32_t  futrts_clzz8(int8_t x)  { return count_leading_zeros((int32_t)(uint8_t)x)-24; }+SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) { return count_leading_zeros((int32_t)(uint16_t)x)-16; }+SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) { return count_leading_zeros(x); }+SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) { return count_leading_zeros(x); }++#else // Not OpenCL, ISPC or CUDA, but plain C.++SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x)+{ return x == 0 ? 8 : __builtin_clz((uint32_t)zext_i8_i32(x)) - 24; }+SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x)+{ return x == 0 ? 16 : __builtin_clz((uint32_t)zext_i16_i32(x)) - 16; }+SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x)+{ return x == 0 ? 32 : __builtin_clz((uint32_t)x); }+SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x)+{ return x == 0 ? 64 : __builtin_clzll((uint64_t)x); }+#endif++#if defined(__OPENCL_VERSION__)+SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {+  int i = 0;+  for (; i < 8 && (x & 1) == 0; i++, x >>= 1) ;+  return i;+}++SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {+  int i = 0;+  for (; i < 16 && (x & 1) == 0; i++, x >>= 1) ;+  return i;+}++SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {+  int i = 0;+  for (; i < 32 && (x & 1) == 0; i++, x >>= 1) ;+  return i;+}++SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {+  int i = 0;+  for (; i < 64 && (x & 1) == 0; i++, x >>= 1) ;+  return i;+}++#elif defined(__CUDA_ARCH__)++SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {+  int y = __ffs(x);+  return y == 0 ? 8 : y - 1;+}++SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {+  int y = __ffs(x);+  return y == 0 ? 16 : y - 1;+}++SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {+  int y = __ffs(x);+  return y == 0 ? 32 : y - 1;+}++SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {+  int y = __ffsll(x);+  return y == 0 ? 64 : y - 1;+}++#elif defined(ISPC)++SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) { return x == 0 ? 8 : count_trailing_zeros((int32_t)x); }+SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) { return x == 0 ? 16 : count_trailing_zeros((int32_t)x); }+SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) { return count_trailing_zeros(x); }+SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) { return count_trailing_zeros(x); }++#else // Not OpenCL or CUDA, but plain C.++SCALAR_FUN_ATTR int32_t  futrts_ctzz8(int8_t x)  { return x == 0 ? 8 : __builtin_ctz((uint32_t)x); }+SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) { return x == 0 ? 16 : __builtin_ctz((uint32_t)x); }+SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) { return x == 0 ? 32 : __builtin_ctz((uint32_t)x); }+SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) { return x == 0 ? 64 : __builtin_ctzll((uint64_t)x); }+#endif++SCALAR_FUN_ATTR float fdiv32(float x, float y) { return x / y; }+SCALAR_FUN_ATTR float fadd32(float x, float y) { return x + y; }+SCALAR_FUN_ATTR float fsub32(float x, float y) { return x - y; }+SCALAR_FUN_ATTR float fmul32(float x, float y) { return x * y; }+SCALAR_FUN_ATTR bool cmplt32(float x, float y) { return x < y; }+SCALAR_FUN_ATTR bool cmple32(float x, float y) { return x <= y; }+SCALAR_FUN_ATTR float sitofp_i8_f32(int8_t x)  { return (float) x; }++SCALAR_FUN_ATTR float sitofp_i16_f32(int16_t x) { return (float) x; }+SCALAR_FUN_ATTR float sitofp_i32_f32(int32_t x) { return (float) x; }+SCALAR_FUN_ATTR float sitofp_i64_f32(int64_t x) { return (float) x; }+SCALAR_FUN_ATTR float  uitofp_i8_f32(uint8_t x)  { return (float) x; }+SCALAR_FUN_ATTR float uitofp_i16_f32(uint16_t x) { return (float) x; }+SCALAR_FUN_ATTR float uitofp_i32_f32(uint32_t x) { return (float) x; }+SCALAR_FUN_ATTR float uitofp_i64_f32(uint64_t x) { return (float) x; }++#ifdef __OPENCL_VERSION__+SCALAR_FUN_ATTR float fabs32(float x)          { return fabs(x); }+SCALAR_FUN_ATTR float fmax32(float x, float y) { return fmax(x, y); }+SCALAR_FUN_ATTR float fmin32(float x, float y) { return fmin(x, y); }+SCALAR_FUN_ATTR float fpow32(float x, float y) { return pow(x, y); }++#elif defined(ISPC)++SCALAR_FUN_ATTR float fabs32(float x) { return abs(x); }+SCALAR_FUN_ATTR float fmax32(float x, float y) { return isnan(x) ? y : isnan(y) ? x : max(x, y); }+SCALAR_FUN_ATTR float fmin32(float x, float y) { return isnan(x) ? y : isnan(y) ? x : min(x, y); }+SCALAR_FUN_ATTR float fpow32(float a, float b) {+  float ret;+  foreach_active (i) {+      uniform float r = pow(extract(a, i), extract(b, i));+      ret = insert(ret, i, r);+  }+  return ret;+}++#else // Not OpenCL, but CUDA or plain C.++SCALAR_FUN_ATTR float fabs32(float x)          { return fabsf(x); }+SCALAR_FUN_ATTR float fmax32(float x, float y) { return fmaxf(x, y); }+SCALAR_FUN_ATTR float fmin32(float x, float y) { return fminf(x, y); }+SCALAR_FUN_ATTR float fpow32(float x, float y) { return powf(x, y); }+#endif++SCALAR_FUN_ATTR bool futrts_isnan32(float x) { return isnan(x); }++#if defined(ISPC)++SCALAR_FUN_ATTR bool futrts_isinf32(float x) { return !isnan(x) && isnan(x - x); }++SCALAR_FUN_ATTR bool futrts_isfinite32(float x) { return !isnan(x) && !futrts_isinf32(x); }++#else++SCALAR_FUN_ATTR bool futrts_isinf32(float x) { return isinf(x); }++#endif++SCALAR_FUN_ATTR int8_t fptosi_f32_i8(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (int8_t) x;+  }+}++SCALAR_FUN_ATTR int16_t fptosi_f32_i16(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (int16_t) x;+  }+}++SCALAR_FUN_ATTR int32_t fptosi_f32_i32(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (int32_t) x;+  }+}++SCALAR_FUN_ATTR int64_t fptosi_f32_i64(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (int64_t) x;+  };+}++SCALAR_FUN_ATTR uint8_t fptoui_f32_i8(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (uint8_t) (int8_t) x;+  }+}++SCALAR_FUN_ATTR uint16_t fptoui_f32_i16(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (uint16_t) (int16_t) x;+  }+}++SCALAR_FUN_ATTR uint32_t fptoui_f32_i32(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (uint32_t) (int32_t) x;+  }+}++SCALAR_FUN_ATTR uint64_t fptoui_f32_i64(float x) {+  if (futrts_isnan32(x) || futrts_isinf32(x)) {+    return 0;+  } else {+    return (uint64_t) (int64_t) x;+  }+}++SCALAR_FUN_ATTR bool ftob_f32_bool(float x) { return x != 0; }+SCALAR_FUN_ATTR float btof_bool_f32(bool x) { return x ? 1 : 0; }++#ifdef __OPENCL_VERSION__+SCALAR_FUN_ATTR float futrts_log32(float x) { return log(x); }+SCALAR_FUN_ATTR float futrts_log2_32(float x) { return log2(x); }+SCALAR_FUN_ATTR float futrts_log10_32(float x) { return log10(x); }+SCALAR_FUN_ATTR float futrts_log1p_32(float x) { return log1p(x); }+SCALAR_FUN_ATTR float futrts_sqrt32(float x) { return sqrt(x); }+SCALAR_FUN_ATTR float futrts_rsqrt32(float x) { return rsqrt(x); }+SCALAR_FUN_ATTR float futrts_cbrt32(float x) { return cbrt(x); }+SCALAR_FUN_ATTR float futrts_exp32(float x) { return exp(x); }+SCALAR_FUN_ATTR float futrts_cos32(float x) { return cos(x); }+SCALAR_FUN_ATTR float futrts_cospi32(float x) { return cospi(x); }+SCALAR_FUN_ATTR float futrts_sin32(float x) { return sin(x); }+SCALAR_FUN_ATTR float futrts_sinpi32(float x) { return sinpi(x); }+SCALAR_FUN_ATTR float futrts_tan32(float x) { return tan(x); }+SCALAR_FUN_ATTR float futrts_tanpi32(float x) { return tanpi(x); }+SCALAR_FUN_ATTR float futrts_acos32(float x) { return acos(x); }+SCALAR_FUN_ATTR float futrts_acospi32(float x) { return acospi(x); }+SCALAR_FUN_ATTR float futrts_asin32(float x) { return asin(x); }+SCALAR_FUN_ATTR float futrts_asinpi32(float x) { return asinpi(x); }+SCALAR_FUN_ATTR float futrts_atan32(float x) { return atan(x); }+SCALAR_FUN_ATTR float futrts_atanpi32(float x) { return atanpi(x); }+SCALAR_FUN_ATTR float futrts_cosh32(float x) { return cosh(x); }+SCALAR_FUN_ATTR float futrts_sinh32(float x) { return sinh(x); }+SCALAR_FUN_ATTR float futrts_tanh32(float x) { return tanh(x); }+SCALAR_FUN_ATTR float futrts_acosh32(float x) { return acosh(x); }+SCALAR_FUN_ATTR float futrts_asinh32(float x) { return asinh(x); }+SCALAR_FUN_ATTR float futrts_atanh32(float x) { return atanh(x); }+SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y) { return atan2(x, y); }+SCALAR_FUN_ATTR float futrts_atan2pi_32(float x, float y) { return atan2pi(x, y); }+SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) { return hypot(x, y); }+SCALAR_FUN_ATTR float futrts_gamma32(float x) { return tgamma(x); }+SCALAR_FUN_ATTR float futrts_lgamma32(float x) { return lgamma(x); }+SCALAR_FUN_ATTR float futrts_erf32(float x) { return erf(x); }+SCALAR_FUN_ATTR float futrts_erfc32(float x) { return erfc(x); }+SCALAR_FUN_ATTR float fmod32(float x, float y) { return fmod(x, y); }+SCALAR_FUN_ATTR float futrts_round32(float x) { return rint(x); }+SCALAR_FUN_ATTR float futrts_floor32(float x) { return floor(x); }+SCALAR_FUN_ATTR float futrts_ceil32(float x) { return ceil(x); }+SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) { return nextafter(x, y); }+SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) { return mix(v0, v1, t); }+SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) { return ldexp(x, y); }+SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) { return copysign(x, y); }+SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) { return mad(a, b, c); }+SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) { return fma(a, b, c); }++#elif defined(ISPC)++SCALAR_FUN_ATTR float futrts_log32(float x) { return futrts_isfinite32(x) || (futrts_isinf32(x) && x < 0)? log(x) : x; }+SCALAR_FUN_ATTR float futrts_log2_32(float x) { return futrts_log32(x) / log(2.0f); }+SCALAR_FUN_ATTR float futrts_log10_32(float x) { return futrts_log32(x) / log(10.0f); }++SCALAR_FUN_ATTR float futrts_log1p_32(float x) {+  if(x == -1.0f || (futrts_isinf32(x) && x > 0.0f)) return x / 0.0f;+  float y = 1.0f + x;+  float z = y - 1.0f;+  return log(y) - (z-x)/y;+}++SCALAR_FUN_ATTR float futrts_sqrt32(float x) { return sqrt(x); }+SCALAR_FUN_ATTR float futrts_rsqrt32(float x) { return 1/sqrt(x); }++extern "C" unmasked uniform float cbrtf(uniform float);+SCALAR_FUN_ATTR float futrts_cbrt32(float x) {+  float res;+  foreach_active (i) {+    uniform float r = cbrtf(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++SCALAR_FUN_ATTR float futrts_exp32(float x) { return exp(x); }+SCALAR_FUN_ATTR float futrts_cos32(float x) { return cos(x); }+SCALAR_FUN_ATTR float futrts_cospi32(float x) { return cos((float)M_PI*x); }+SCALAR_FUN_ATTR float futrts_sin32(float x) { return sin(x); }+SCALAR_FUN_ATTR float futrts_sinpi32(float x) { return sin(M_PI*x); }+SCALAR_FUN_ATTR float futrts_tan32(float x) { return tan(x); }+SCALAR_FUN_ATTR float futrts_tanpi32(float x) { return tan((float)M_PI*x); }+SCALAR_FUN_ATTR float futrts_acos32(float x) { return acos(x); }+SCALAR_FUN_ATTR float futrts_acospi32(float x) { return acos(x)/(float)M_PI; }+SCALAR_FUN_ATTR float futrts_asin32(float x) { return asin(x); }+SCALAR_FUN_ATTR float futrts_asinpi32(float x) { return asin(x)/(float)M_PI; }+SCALAR_FUN_ATTR float futrts_atan32(float x) { return atan(x); }+SCALAR_FUN_ATTR float futrts_atanpi32(float x) { return atan(x)/(float)M_PI; }+SCALAR_FUN_ATTR float futrts_cosh32(float x) { return (exp(x)+exp(-x)) / 2.0f; }+SCALAR_FUN_ATTR float futrts_sinh32(float x) { return (exp(x)-exp(-x)) / 2.0f; }+SCALAR_FUN_ATTR float futrts_tanh32(float x) { return futrts_sinh32(x)/futrts_cosh32(x); }++SCALAR_FUN_ATTR float futrts_acosh32(float x) {+  float f = x+sqrt(x*x-1);+  if (futrts_isfinite32(f)) return log(f);+  return f;+}++SCALAR_FUN_ATTR float futrts_asinh32(float x) {+  float f = x+sqrt(x*x+1);+  if (futrts_isfinite32(f)) return log(f);+  return f;+}++SCALAR_FUN_ATTR float futrts_atanh32(float x) {+  float f = (1+x)/(1-x);+  if (futrts_isfinite32(f)) return log(f)/2.0f;+  return f;+}++SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y)+{ return (x == 0.0f && y == 0.0f) ? 0.0f : atan2(x, y); }+SCALAR_FUN_ATTR float futrts_atan2pi_32(float x, float y)+{ return (x == 0.0f && y == 0.0f) ? 0.0f : atan2(x, y) / (float)M_PI; }++SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) {+  if (futrts_isfinite32(x) && futrts_isfinite32(y)) {+    x = abs(x);+    y = abs(y);+    float a;+    float b;+    if (x >= y){+        a = x;+        b = y;+    } else {+        a = y;+        b = x;+    }+    if(b == 0){+      return a;+    }++    int e;+    float an;+    float bn;+    an = frexp (a, &e);+    bn = ldexp (b, - e);+    float cn;+    cn = sqrt (an * an + bn * bn);+    return ldexp (cn, e);+  } else {+    if (futrts_isinf32(x) || futrts_isinf32(y)) return INFINITY;+    else return x + y;+  }++}++extern "C" unmasked uniform float tgammaf(uniform float x);+SCALAR_FUN_ATTR float futrts_gamma32(float x) {+  float res;+  foreach_active (i) {+    uniform float r = tgammaf(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++extern "C" unmasked uniform float lgammaf(uniform float x);+SCALAR_FUN_ATTR float futrts_lgamma32(float x) {+  float res;+  foreach_active (i) {+    uniform float r = lgammaf(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++extern "C" unmasked uniform float erff(uniform float x);+SCALAR_FUN_ATTR float futrts_erf32(float x) {+  float res;+  foreach_active (i) {+    uniform float r = erff(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++extern "C" unmasked uniform float erfcf(uniform float x);+SCALAR_FUN_ATTR float futrts_erfc32(float x) {+  float res;+  foreach_active (i) {+    uniform float r = erfcf(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++SCALAR_FUN_ATTR float fmod32(float x, float y) { return x - y * trunc(x/y); }+SCALAR_FUN_ATTR float futrts_round32(float x) { return round(x); }+SCALAR_FUN_ATTR float futrts_floor32(float x) { return floor(x); }+SCALAR_FUN_ATTR float futrts_ceil32(float x) { return ceil(x); }++extern "C" unmasked uniform float nextafterf(uniform float x, uniform float y);+SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) {+  float res;+  foreach_active (i) {+    uniform float r = nextafterf(extract(x, i), extract(y, i));+    res = insert(res, i, r);+  }+  return res;+}++SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) {+  return v0 + (v1 - v0) * t;+}++SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) {+  return x * pow((uniform float)2.0, (float)y);+}++SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) {+  int32_t xb = futrts_to_bits32(x);+  int32_t yb = futrts_to_bits32(y);+  return futrts_from_bits32((xb & ~(1<<31)) | (yb & (1<<31)));+}++SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) {+  return a * b + c;+}++SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) {+  return a * b + c;+}++#else // Not OpenCL or ISPC, but CUDA or plain C.++SCALAR_FUN_ATTR float futrts_log32(float x) { return logf(x); }+SCALAR_FUN_ATTR float futrts_log2_32(float x) { return log2f(x); }+SCALAR_FUN_ATTR float futrts_log10_32(float x) { return log10f(x); }+SCALAR_FUN_ATTR float futrts_log1p_32(float x) { return log1pf(x); }+SCALAR_FUN_ATTR float futrts_sqrt32(float x) { return sqrtf(x); }+SCALAR_FUN_ATTR float futrts_rsqrt32(float x) { return 1/sqrtf(x); }+SCALAR_FUN_ATTR float futrts_cbrt32(float x) { return cbrtf(x); }+SCALAR_FUN_ATTR float futrts_exp32(float x) { return expf(x); }+SCALAR_FUN_ATTR float futrts_cos32(float x) { return cosf(x); }++SCALAR_FUN_ATTR float futrts_cospi32(float x) {+#if defined(__CUDA_ARCH__)+  return cospif(x);+#else+  return cosf(((float)M_PI)*x);+#endif+}+SCALAR_FUN_ATTR float futrts_sin32(float x) { return sinf(x); }++SCALAR_FUN_ATTR float futrts_sinpi32(float x) {+#if defined(__CUDA_ARCH__)+  return sinpif(x);+#else+  return sinf((float)M_PI*x);+#endif+}++SCALAR_FUN_ATTR float futrts_tan32(float x) { return tanf(x); }+SCALAR_FUN_ATTR float futrts_tanpi32(float x) { return tanf((float)M_PI*x); }+SCALAR_FUN_ATTR float futrts_acos32(float x) { return acosf(x); }+SCALAR_FUN_ATTR float futrts_acospi32(float x) { return acosf(x)/(float)M_PI; }+SCALAR_FUN_ATTR float futrts_asin32(float x) { return asinf(x); }+SCALAR_FUN_ATTR float futrts_asinpi32(float x) { return asinf(x)/(float)M_PI; }+SCALAR_FUN_ATTR float futrts_atan32(float x) { return atanf(x); }+SCALAR_FUN_ATTR float futrts_atanpi32(float x) { return atanf(x)/(float)M_PI; }+SCALAR_FUN_ATTR float futrts_cosh32(float x) { return coshf(x); }+SCALAR_FUN_ATTR float futrts_sinh32(float x) { return sinhf(x); }+SCALAR_FUN_ATTR float futrts_tanh32(float x) { return tanhf(x); }+SCALAR_FUN_ATTR float futrts_acosh32(float x) { return acoshf(x); }+SCALAR_FUN_ATTR float futrts_asinh32(float x) { return asinhf(x); }+SCALAR_FUN_ATTR float futrts_atanh32(float x) { return atanhf(x); }+SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y) { return atan2f(x, y); }+SCALAR_FUN_ATTR float futrts_atan2pi_32(float x, float y) { return atan2f(x, y) / (float)M_PI; }+SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) { return hypotf(x, y); }+SCALAR_FUN_ATTR float futrts_gamma32(float x) { return tgammaf(x); }+SCALAR_FUN_ATTR float futrts_lgamma32(float x) { return lgammaf(x); }+SCALAR_FUN_ATTR float futrts_erf32(float x) { return erff(x); }+SCALAR_FUN_ATTR float futrts_erfc32(float x) { return erfcf(x); }+SCALAR_FUN_ATTR float fmod32(float x, float y) { return fmodf(x, y); }+SCALAR_FUN_ATTR float futrts_round32(float x) { return rintf(x); }+SCALAR_FUN_ATTR float futrts_floor32(float x) { return floorf(x); }+SCALAR_FUN_ATTR float futrts_ceil32(float x) { return ceilf(x); }+SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) { return nextafterf(x, y); }+SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) { return v0 + (v1 - v0) * t; }+SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) { return ldexpf(x, y); }+SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) { return copysignf(x, y); }+SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) { return a * b + c; }+SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) { return fmaf(a, b, c); }++#endif++#if defined(ISPC)++SCALAR_FUN_ATTR int32_t futrts_to_bits32(float x) { return intbits(x); }+SCALAR_FUN_ATTR float futrts_from_bits32(int32_t x) { return floatbits(x); }++#else++SCALAR_FUN_ATTR int32_t futrts_to_bits32(float x) {+  union {+    float f;+    int32_t t;+  } p;++  p.f = x;+  return p.t;+}++SCALAR_FUN_ATTR float futrts_from_bits32(int32_t x) {+  union {+    int32_t f;+    float t;+  } p;++  p.f = x;+  return p.t;+}+#endif++SCALAR_FUN_ATTR float fsignum32(float x) {+  return futrts_isnan32(x) ? x : (x > 0 ? 1 : 0) - (x < 0 ? 1 : 0);+}++#ifdef FUTHARK_F64_ENABLED++SCALAR_FUN_ATTR double futrts_from_bits64(int64_t x);+SCALAR_FUN_ATTR int64_t futrts_to_bits64(double x);++#if defined(ISPC)++SCALAR_FUN_ATTR bool futrts_isinf64(float x) { return !isnan(x) && isnan(x - x); }+SCALAR_FUN_ATTR bool futrts_isfinite64(float x) { return !isnan(x) && !futrts_isinf64(x); }+SCALAR_FUN_ATTR double fdiv64(double x, double y) { return x / y; }+SCALAR_FUN_ATTR double fadd64(double x, double y) { return x + y; }+SCALAR_FUN_ATTR double fsub64(double x, double y) { return x - y; }+SCALAR_FUN_ATTR double fmul64(double x, double y) { return x * y; }+SCALAR_FUN_ATTR bool cmplt64(double x, double y) { return x < y; }+SCALAR_FUN_ATTR bool cmple64(double x, double y) { return x <= y; }+SCALAR_FUN_ATTR double sitofp_i8_f64(int8_t x) { return (double) x; }+SCALAR_FUN_ATTR double sitofp_i16_f64(int16_t x) { return (double) x; }+SCALAR_FUN_ATTR double sitofp_i32_f64(int32_t x) { return (double) x; }+SCALAR_FUN_ATTR double sitofp_i64_f64(int64_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i8_f64(uint8_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i16_f64(uint16_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i32_f64(uint32_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i64_f64(uint64_t x) { return (double) x; }+SCALAR_FUN_ATTR double fabs64(double x) { return abs(x); }+SCALAR_FUN_ATTR double fmax64(double x, double y) { return isnan(x) ? y : isnan(y) ? x : max(x, y); }+SCALAR_FUN_ATTR double fmin64(double x, double y) { return isnan(x) ? y : isnan(y) ? x : min(x, y); }++SCALAR_FUN_ATTR double fpow64(double a, double b) {+  float ret;+  foreach_active (i) {+      uniform float r = pow(extract(a, i), extract(b, i));+      ret = insert(ret, i, r);+  }+  return ret;+}+SCALAR_FUN_ATTR double futrts_log64(double x) { return futrts_isfinite64(x) || (futrts_isinf64(x) && x < 0)? log(x) : x; }+SCALAR_FUN_ATTR double futrts_log2_64(double x) { return futrts_log64(x)/log(2.0d); }+SCALAR_FUN_ATTR double futrts_log10_64(double x) { return futrts_log64(x)/log(10.0d); }++SCALAR_FUN_ATTR double futrts_log1p_64(double x) {+  if(x == -1.0d || (futrts_isinf64(x) && x > 0.0d)) return x / 0.0d;+  double y = 1.0d + x;+  double z = y - 1.0d;+  return log(y) - (z-x)/y;+}++SCALAR_FUN_ATTR double futrts_sqrt64(double x) { return sqrt(x); }+SCALAR_FUN_ATTR double futrts_rsqrt64(double x) { return 1/sqrt(x); }++extern "C" unmasked uniform double cbrt(uniform double);+SCALAR_FUN_ATTR double futrts_cbrt64(double x) {+  double res;+  foreach_active (i) {+    uniform double r = cbrtf(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}+SCALAR_FUN_ATTR double futrts_exp64(double x) { return exp(x); }+SCALAR_FUN_ATTR double futrts_cos64(double x) { return cos(x); }+SCALAR_FUN_ATTR double futrts_cospi64(double x) { return cos(M_PI*x); }+SCALAR_FUN_ATTR double futrts_sin64(double x) { return sin(x); }+SCALAR_FUN_ATTR double futrts_sinpi64(double x) { return sin(M_PI*x); }+SCALAR_FUN_ATTR double futrts_tan64(double x) { return tan(x); }+SCALAR_FUN_ATTR double futrts_tanpi64(double x) { return tan(M_PI*x); }+SCALAR_FUN_ATTR double futrts_acos64(double x) { return acos(x); }+SCALAR_FUN_ATTR double futrts_acospi64(double x) { return acos(x)/M_PI; }+SCALAR_FUN_ATTR double futrts_asin64(double x) { return asin(x); }+SCALAR_FUN_ATTR double futrts_asinpi64(double x) { return asin(x)/M_PI; }+SCALAR_FUN_ATTR double futrts_atan64(double x) { return atan(x); }+SCALAR_FUN_ATTR double futrts_atanpi64(double x) { return atan(x)/M_PI; }+SCALAR_FUN_ATTR double futrts_cosh64(double x) { return (exp(x)+exp(-x)) / 2.0d; }+SCALAR_FUN_ATTR double futrts_sinh64(double x) { return (exp(x)-exp(-x)) / 2.0d; }+SCALAR_FUN_ATTR double futrts_tanh64(double x) { return futrts_sinh64(x)/futrts_cosh64(x); }++SCALAR_FUN_ATTR double futrts_acosh64(double x) {+  double f = x+sqrt(x*x-1.0d);+  if(futrts_isfinite64(f)) return log(f);+  return f;+}++SCALAR_FUN_ATTR double futrts_asinh64(double x) {+  double f = x+sqrt(x*x+1.0d);+  if(futrts_isfinite64(f)) return log(f);+  return f;+}++SCALAR_FUN_ATTR double futrts_atanh64(double x) {+  double f = (1.0d+x)/(1.0d-x);+  if(futrts_isfinite64(f)) return log(f)/2.0d;+  return f;+}+SCALAR_FUN_ATTR double futrts_atan2_64(double x, double y) { return atan2(x, y); }++SCALAR_FUN_ATTR double futrts_atan2pi_64(double x, double y) { return atan2(x, y) / M_PI; }++extern "C" unmasked uniform double hypot(uniform double x, uniform double y);+SCALAR_FUN_ATTR double futrts_hypot64(double x, double y) {+  double res;+  foreach_active (i) {+    uniform double r = hypot(extract(x, i), extract(y, i));+    res = insert(res, i, r);+  }+  return res;+}++extern "C" unmasked uniform double tgamma(uniform double x);+SCALAR_FUN_ATTR double futrts_gamma64(double x) {+  double res;+  foreach_active (i) {+    uniform double r = tgamma(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++extern "C" unmasked uniform double lgamma(uniform double x);+SCALAR_FUN_ATTR double futrts_lgamma64(double x) {+  double res;+  foreach_active (i) {+    uniform double r = lgamma(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++extern "C" unmasked uniform double erf(uniform double x);+SCALAR_FUN_ATTR double futrts_erf64(double x) {+  double res;+  foreach_active (i) {+    uniform double r = erf(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++extern "C" unmasked uniform double erfc(uniform double x);+SCALAR_FUN_ATTR double futrts_erfc64(double x) {+  double res;+  foreach_active (i) {+    uniform double r = erfc(extract(x, i));+    res = insert(res, i, r);+  }+  return res;+}++SCALAR_FUN_ATTR double futrts_fma64(double a, double b, double c) { return a * b + c; }+SCALAR_FUN_ATTR double futrts_round64(double x) { return round(x); }+SCALAR_FUN_ATTR double futrts_ceil64(double x) { return ceil(x); }++extern "C" unmasked uniform double nextafter(uniform float x, uniform double y);+SCALAR_FUN_ATTR float futrts_nextafter64(double x, double y) {+  double res;+  foreach_active (i) {+    uniform double r = nextafter(extract(x, i), extract(y, i));+    res = insert(res, i, r);+  }+  return res;+}++SCALAR_FUN_ATTR double futrts_floor64(double x) { return floor(x); }+SCALAR_FUN_ATTR bool futrts_isnan64(double x) { return isnan(x); }++SCALAR_FUN_ATTR int8_t fptosi_f64_i8(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int8_t) x;+  }+}++SCALAR_FUN_ATTR int16_t fptosi_f64_i16(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int16_t) x;+  }+}++SCALAR_FUN_ATTR int32_t fptosi_f64_i32(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int32_t) x;+  }+}++SCALAR_FUN_ATTR int64_t fptosi_f64_i64(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int64_t) x;+  }+}++SCALAR_FUN_ATTR uint8_t fptoui_f64_i8(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint8_t) (int8_t) x;+  }+}++SCALAR_FUN_ATTR uint16_t fptoui_f64_i16(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint16_t) (int16_t) x;+  }+}++SCALAR_FUN_ATTR uint32_t fptoui_f64_i32(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint32_t) (int32_t) x;+  }+}++SCALAR_FUN_ATTR uint64_t fptoui_f64_i64(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint64_t) (int64_t) x;+  }+}++SCALAR_FUN_ATTR bool ftob_f64_bool(double x) { return x != 0.0; }+SCALAR_FUN_ATTR double btof_bool_f64(bool x) { return x ? 1.0 : 0.0; }++SCALAR_FUN_ATTR int64_t futrts_to_bits64(double x) {+  int64_t res;+  foreach_active (i) {+    uniform double tmp = extract(x, i);+    uniform int64_t r = *((uniform int64_t* uniform)&tmp);+    res = insert(res, i, r);+  }+  return res;+}++SCALAR_FUN_ATTR double futrts_from_bits64(int64_t x) {+  double res;+  foreach_active (i) {+    uniform int64_t tmp = extract(x, i);+    uniform double r = *((uniform double* uniform)&tmp);+    res = insert(res, i, r);+  }+  return res;+}++SCALAR_FUN_ATTR double fmod64(double x, double y) {+  return x - y * trunc(x/y);+}++SCALAR_FUN_ATTR double fsignum64(double x) {+  return futrts_isnan64(x) ? x : (x > 0 ? 1.0d : 0.0d) - (x < 0 ? 1.0d : 0.0d);+}++SCALAR_FUN_ATTR double futrts_lerp64(double v0, double v1, double t) {+  return v0 + (v1 - v0) * t;+}++SCALAR_FUN_ATTR double futrts_ldexp64(double x, int32_t y) {+  return x * pow((uniform double)2.0, (double)y);+}++SCALAR_FUN_ATTR double futrts_copysign64(double x, double y) {+  int64_t xb = futrts_to_bits64(x);+  int64_t yb = futrts_to_bits64(y);+  return futrts_from_bits64((xb & ~(((int64_t)1)<<63)) | (yb & (((int64_t)1)<<63)));+}++SCALAR_FUN_ATTR double futrts_mad64(double a, double b, double c) { return a * b + c; }+SCALAR_FUN_ATTR float fpconv_f32_f32(float x) { return (float) x; }+SCALAR_FUN_ATTR double fpconv_f32_f64(float x) { return (double) x; }+SCALAR_FUN_ATTR float fpconv_f64_f32(double x) { return (float) x; }+SCALAR_FUN_ATTR double fpconv_f64_f64(double x) { return (double) x; }++#else++SCALAR_FUN_ATTR double fdiv64(double x, double y) { return x / y; }+SCALAR_FUN_ATTR double fadd64(double x, double y) { return x + y; }+SCALAR_FUN_ATTR double fsub64(double x, double y) { return x - y; }+SCALAR_FUN_ATTR double fmul64(double x, double y) { return x * y; }+SCALAR_FUN_ATTR bool cmplt64(double x, double y) { return x < y; }+SCALAR_FUN_ATTR bool cmple64(double x, double y) { return x <= y; }+SCALAR_FUN_ATTR double sitofp_i8_f64(int8_t x) { return (double) x; }+SCALAR_FUN_ATTR double sitofp_i16_f64(int16_t x) { return (double) x; }+SCALAR_FUN_ATTR double sitofp_i32_f64(int32_t x) { return (double) x; }+SCALAR_FUN_ATTR double sitofp_i64_f64(int64_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i8_f64(uint8_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i16_f64(uint16_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i32_f64(uint32_t x) { return (double) x; }+SCALAR_FUN_ATTR double uitofp_i64_f64(uint64_t x) { return (double) x; }+SCALAR_FUN_ATTR double fabs64(double x) { return fabs(x); }+SCALAR_FUN_ATTR double fmax64(double x, double y) { return fmax(x, y); }+SCALAR_FUN_ATTR double fmin64(double x, double y) { return fmin(x, y); }+SCALAR_FUN_ATTR double fpow64(double x, double y) { return pow(x, y); }+SCALAR_FUN_ATTR double futrts_log64(double x) { return log(x); }+SCALAR_FUN_ATTR double futrts_log2_64(double x) { return log2(x); }+SCALAR_FUN_ATTR double futrts_log10_64(double x) { return log10(x); }+SCALAR_FUN_ATTR double futrts_log1p_64(double x) { return log1p(x); }+SCALAR_FUN_ATTR double futrts_sqrt64(double x) { return sqrt(x); }+SCALAR_FUN_ATTR double futrts_rsqrt64(double x) { return 1/sqrt(x); }+SCALAR_FUN_ATTR double futrts_cbrt64(double x) { return cbrt(x); }+SCALAR_FUN_ATTR double futrts_exp64(double x) { return exp(x); }+SCALAR_FUN_ATTR double futrts_cos64(double x) { return cos(x); }++SCALAR_FUN_ATTR double futrts_cospi64(double x) {+#ifdef __OPENCL_VERSION__+  return cospi(x);+#elif defined(__CUDA_ARCH__)+  return cospi(x);+#else+  return cos(M_PI*x);+#endif+}++SCALAR_FUN_ATTR double futrts_sin64(double x) {+  return sin(x);+}++SCALAR_FUN_ATTR double futrts_sinpi64(double x) {+#ifdef __OPENCL_VERSION__+  return sinpi(x);+#elif defined(__CUDA_ARCH__)+  return sinpi(x);+#else+  return sin(M_PI*x);+#endif+}++SCALAR_FUN_ATTR double futrts_tan64(double x) {+  return tan(x);+}++SCALAR_FUN_ATTR double futrts_tanpi64(double x) {+#ifdef __OPENCL_VERSION__+  return tanpi(x);+#else+  return tan(M_PI*x);+#endif+}++SCALAR_FUN_ATTR double futrts_acos64(double x) {+  return acos(x);+}++SCALAR_FUN_ATTR double futrts_acospi64(double x) {+#ifdef __OPENCL_VERSION__+  return acospi(x);+#else+  return acos(x) / M_PI;+#endif+}++SCALAR_FUN_ATTR double futrts_asin64(double x) {+  return asin(x);+}++SCALAR_FUN_ATTR double futrts_asinpi64(double x) {+#ifdef __OPENCL_VERSION__+  return asinpi(x);+#else+  return asin(x) / M_PI;+#endif+}++SCALAR_FUN_ATTR double futrts_atan64(double x) {+  return atan(x);+}++SCALAR_FUN_ATTR double futrts_atanpi64(double x) {+#ifdef __OPENCL_VERSION__+  return atanpi(x);+#else+  return atan(x) / M_PI;+#endif+}++SCALAR_FUN_ATTR double futrts_cosh64(double x) { return cosh(x); }+SCALAR_FUN_ATTR double futrts_sinh64(double x) { return sinh(x); }+SCALAR_FUN_ATTR double futrts_tanh64(double x) { return tanh(x); }+SCALAR_FUN_ATTR double futrts_acosh64(double x) { return acosh(x); }+SCALAR_FUN_ATTR double futrts_asinh64(double x) { return asinh(x); }+SCALAR_FUN_ATTR double futrts_atanh64(double x) { return atanh(x); }+SCALAR_FUN_ATTR double futrts_atan2_64(double x, double y) { return atan2(x, y); }++SCALAR_FUN_ATTR double futrts_atan2pi_64(double x, double y) {+#ifdef __OPENCL_VERSION__+  return atan2pi(x, y);+#else+  return atan2(x, y) / M_PI;+#endif+}++SCALAR_FUN_ATTR double futrts_hypot64(double x, double y) { return hypot(x, y); }+SCALAR_FUN_ATTR double futrts_gamma64(double x) { return tgamma(x); }+SCALAR_FUN_ATTR double futrts_lgamma64(double x) { return lgamma(x); }+SCALAR_FUN_ATTR double futrts_erf64(double x) { return erf(x); }+SCALAR_FUN_ATTR double futrts_erfc64(double x) { return erfc(x); }+SCALAR_FUN_ATTR double futrts_fma64(double a, double b, double c) { return fma(a, b, c); }+SCALAR_FUN_ATTR double futrts_round64(double x) { return rint(x); }+SCALAR_FUN_ATTR double futrts_ceil64(double x) { return ceil(x); }+SCALAR_FUN_ATTR float futrts_nextafter64(float x, float y) { return nextafter(x, y); }+SCALAR_FUN_ATTR double futrts_floor64(double x) { return floor(x); }+SCALAR_FUN_ATTR bool futrts_isnan64(double x) { return isnan(x); }+SCALAR_FUN_ATTR bool futrts_isinf64(double x) { return isinf(x); }++SCALAR_FUN_ATTR int8_t fptosi_f64_i8(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int8_t) x;+  }+}++SCALAR_FUN_ATTR int16_t fptosi_f64_i16(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int16_t) x;+  }+}++SCALAR_FUN_ATTR int32_t fptosi_f64_i32(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int32_t) x;+  }+}++SCALAR_FUN_ATTR int64_t fptosi_f64_i64(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (int64_t) x;+  }+}++SCALAR_FUN_ATTR uint8_t fptoui_f64_i8(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint8_t) (int8_t) x;+  }+}++SCALAR_FUN_ATTR uint16_t fptoui_f64_i16(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint16_t) (int16_t) x;+  }+}++SCALAR_FUN_ATTR uint32_t fptoui_f64_i32(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint32_t) (int32_t) x;+  }+}++SCALAR_FUN_ATTR uint64_t fptoui_f64_i64(double x) {+  if (futrts_isnan64(x) || futrts_isinf64(x)) {+    return 0;+  } else {+    return (uint64_t) (int64_t) x;+  }+}++SCALAR_FUN_ATTR bool ftob_f64_bool(double x) { return x != 0; }+SCALAR_FUN_ATTR double btof_bool_f64(bool x) { return x ? 1 : 0; }++SCALAR_FUN_ATTR int64_t futrts_to_bits64(double x) {+  union {+    double f;+    int64_t t;+  } p;++  p.f = x;+  return p.t;+}++SCALAR_FUN_ATTR double futrts_from_bits64(int64_t x) {+  union {+    int64_t f;+    double t;+  } p;++  p.f = x;+  return p.t;+}++SCALAR_FUN_ATTR double fmod64(double x, double y) {+  return fmod(x, y);+}++SCALAR_FUN_ATTR double fsignum64(double x) {+  return futrts_isnan64(x) ? x : (x > 0) - (x < 0);+}++SCALAR_FUN_ATTR double futrts_lerp64(double v0, double v1, double t) {+#ifdef __OPENCL_VERSION__+  return mix(v0, v1, t);+#else+  return v0 + (v1 - v0) * t;+#endif+}++SCALAR_FUN_ATTR double futrts_ldexp64(double x, int32_t y) {+  return ldexp(x, y);+}++SCALAR_FUN_ATTR float futrts_copysign64(double x, double y) {+  return copysign(x, y);+}++SCALAR_FUN_ATTR double futrts_mad64(double a, double b, double c) {+#ifdef __OPENCL_VERSION__+  return mad(a, b, c);+#else+  return a * b + c;+#endif+}++SCALAR_FUN_ATTR float fpconv_f32_f32(float x) { return (float) x; }+SCALAR_FUN_ATTR double fpconv_f32_f64(float x) { return (double) x; }+SCALAR_FUN_ATTR float fpconv_f64_f32(double x) { return (float) x; }+SCALAR_FUN_ATTR double fpconv_f64_f64(double x) { return (double) x; }  #endif