(module math (export abs_i32 neg_i32 rem_i32 bit_and_i32 bit_or_i32 bit_xor_i32 is_even_i32 is_odd_i32 min_i32 max_i32 clamp_i32 square_i32 cube_i32 is_zero_i32 is_positive_i32 is_negative_i32 in_range_i32 abs_i64 neg_i64 rem_i64 bit_and_i64 bit_or_i64 bit_xor_i64 is_even_i64 is_odd_i64 min_i64 max_i64 clamp_i64 square_i64 cube_i64 is_zero_i64 is_positive_i64 is_negative_i64 in_range_i64 abs_f64 neg_f64 min_f64 max_f64 clamp_f64 square_f64 cube_f64 is_zero_f64 is_positive_f64 is_negative_f64 in_range_f64))

(fn abs_i32 ((value i32)) -> i32
  (if (< value 0)
    (- 0 value)
    value))

(fn neg_i32 ((value i32)) -> i32
  (- 0 value))

(fn rem_i32 ((left i32) (right i32)) -> i32
  (% left right))

(fn bit_and_i32 ((left i32) (right i32)) -> i32
  (bit_and left right))

(fn bit_or_i32 ((left i32) (right i32)) -> i32
  (bit_or left right))

(fn bit_xor_i32 ((left i32) (right i32)) -> i32
  (bit_xor left right))

(fn is_even_i32 ((value i32)) -> bool
  (= (rem_i32 value 2) 0))

(fn is_odd_i32 ((value i32)) -> bool
  (if (= (rem_i32 value 2) 0)
    false
    true))

(fn min_i32 ((left i32) (right i32)) -> i32
  (if (< left right)
    left
    right))

(fn max_i32 ((left i32) (right i32)) -> i32
  (if (> left right)
    left
    right))

(fn clamp_i32 ((value i32) (low i32) (high i32)) -> i32
  (max_i32 low (min_i32 value high)))

(fn square_i32 ((value i32)) -> i32
  (* value value))

(fn cube_i32 ((value i32)) -> i32
  (* (square_i32 value) value))

(fn is_zero_i32 ((value i32)) -> bool
  (= value 0))

(fn is_positive_i32 ((value i32)) -> bool
  (> value 0))

(fn is_negative_i32 ((value i32)) -> bool
  (< value 0))

(fn in_range_i32 ((value i32) (low i32) (high i32)) -> bool
  (if (>= value low)
    (<= value high)
    false))

(fn abs_i64 ((value i64)) -> i64
  (if (< value 0i64)
    (- 0i64 value)
    value))

(fn neg_i64 ((value i64)) -> i64
  (- 0i64 value))

(fn rem_i64 ((left i64) (right i64)) -> i64
  (% left right))

(fn bit_and_i64 ((left i64) (right i64)) -> i64
  (bit_and left right))

(fn bit_or_i64 ((left i64) (right i64)) -> i64
  (bit_or left right))

(fn bit_xor_i64 ((left i64) (right i64)) -> i64
  (bit_xor left right))

(fn is_even_i64 ((value i64)) -> bool
  (= (rem_i64 value 2i64) 0i64))

(fn is_odd_i64 ((value i64)) -> bool
  (if (= (rem_i64 value 2i64) 0i64)
    false
    true))

(fn min_i64 ((left i64) (right i64)) -> i64
  (if (< left right)
    left
    right))

(fn max_i64 ((left i64) (right i64)) -> i64
  (if (> left right)
    left
    right))

(fn clamp_i64 ((value i64) (low i64) (high i64)) -> i64
  (max_i64 low (min_i64 value high)))

(fn square_i64 ((value i64)) -> i64
  (* value value))

(fn cube_i64 ((value i64)) -> i64
  (* (square_i64 value) value))

(fn is_zero_i64 ((value i64)) -> bool
  (= value 0i64))

(fn is_positive_i64 ((value i64)) -> bool
  (> value 0i64))

(fn is_negative_i64 ((value i64)) -> bool
  (< value 0i64))

(fn in_range_i64 ((value i64) (low i64) (high i64)) -> bool
  (if (>= value low)
    (<= value high)
    false))

(fn abs_f64 ((value f64)) -> f64
  (if (< value 0.0)
    (- 0.0 value)
    value))

(fn neg_f64 ((value f64)) -> f64
  (- 0.0 value))

(fn min_f64 ((left f64) (right f64)) -> f64
  (if (< left right)
    left
    right))

(fn max_f64 ((left f64) (right f64)) -> f64
  (if (> left right)
    left
    right))

(fn clamp_f64 ((value f64) (low f64) (high f64)) -> f64
  (max_f64 low (min_f64 value high)))

(fn square_f64 ((value f64)) -> f64
  (* value value))

(fn cube_f64 ((value f64)) -> f64
  (* (square_f64 value) value))

(fn is_zero_f64 ((value f64)) -> bool
  (= value 0.0))

(fn is_positive_f64 ((value f64)) -> bool
  (> value 0.0))

(fn is_negative_f64 ((value f64)) -> bool
  (< value 0.0))

(fn in_range_f64 ((value f64) (low f64) (high f64)) -> bool
  (if (>= value low)
    (<= value high)
    false))