pub const absolute: state.Builtin(p)

pub const add: state.Builtin(l)

pub const binary_fold: state.Builtin(ag)

pub const binary_from_integers: state.Builtin(af)

pub const divide: state.Builtin(o)

pub fn do_binary_from_integers(
  term: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_fixed(
  builder: value.Value(
    a,
    #(List(#(state.Kontinue(a), a)), state.Env(a)),
  ),
  arg: value.Value(
    a,
    #(List(#(state.Kontinue(a), a)), state.Env(a)),
  ),
  meta: a,
  env: state.Env(a),
  k: state.Stack(a),
) -> Result(
  #(state.Control(a), state.Env(a), state.Stack(a)),
  break.Reason(a, #(List(#(state.Kontinue(a), a)), state.Env(a))),
)

pub fn do_never(
  arg: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(f, break.Reason(a, b))

pub fn do_string_ends_with(
  value: value.Value(a, b),
  t: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_from_binary(
  in: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_length(
  value: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_lowercase(
  value: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_replace(
  in: value.Value(a, b),
  from: value.Value(a, b),
  to: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_split(
  s: value.Value(a, b),
  pattern: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_split_once(
  s: value.Value(a, b),
  pattern: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_starts_with(
  value: value.Value(a, b),
  t: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_to_binary(
  in: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub fn do_string_uppercase(
  value: value.Value(a, b),
  meta: c,
  env: d,
  k: e,
) -> Result(#(state.Control(f), d, e), break.Reason(a, b))

pub const equal: state.Builtin(g)

pub const fix: state.Builtin(h)

pub const fixed: state.Builtin(i)

pub const int_compare: state.Builtin(k)

pub const int_parse: state.Builtin(q)

pub const int_to_string: state.Builtin(r)

pub const list_fold: state.Builtin(ae)

pub const list_pop: state.Builtin(ad)

pub const multiply: state.Builtin(n)

pub const never: state.Builtin(j)

pub const string_append: state.Builtin(s)

pub const string_ends_with: state.Builtin(z)

pub const string_from_binary: state.Builtin(ac)

pub const string_length: state.Builtin(aa)

pub const string_lowercase: state.Builtin(x)

pub const string_replace: state.Builtin(v)

pub const string_split: state.Builtin(t)

pub const string_split_once: state.Builtin(u)

pub const string_starts_with: state.Builtin(y)

pub const string_to_binary: state.Builtin(ab)

pub const string_uppercase: state.Builtin(w)

pub const subtract: state.Builtin(m)