cdx 0.1.24

//! Floating Point expressions

use crate::column::get_col;
use crate::prelude::*;
use crate::shunting_yard::to_rpn;
use crate::tok2::{BinaryOp, Token, UnaryOp, tokenize};
use crate::util::find_close;
use crate::*;
use regex::Regex;
use std::f64::consts;
use std::fmt::Write;
use std::sync::LazyLock;

/// evaluate a constant arithmetic expression
pub fn calc(expr: &str, trig_mode: TrigMode) -> Result<f64> {
    let mut c = Expr::new(expr)?;
    c.set_trig_mode(trig_mode);
    c.eval_plain()
}

/// If input is 'Format,Expression' return that format and expression
/// else return supplied default format, and whole input slice
#[must_use]
pub fn parse_fmt_expr(dflt: NumFormat, spec: &str) -> (NumFormat, &str) {
    if let Some((a, b)) = spec.split_once(',') {
        let x = NumFormat::new(a);
        if let Ok(f) = x { (f, b) } else { (dflt, spec) }
    } else {
        (dflt, spec)
    }
}

fn find_const(x: &str) -> Option<f64> {
    for c in &CONSTS {
        if x == c.name {
            return Some(c.val);
        }
    }
    None
}

fn find_func(x: &str) -> Result<FuncOp> {
    for f in &FUNCTIONS {
        if f.name == x {
            return Ok(f.val);
        }
    }
    err!("No such function as {}", x)
}

#[derive(Debug, Copy, Clone)]
enum FuncOp {
    Abs,
    Acos,
    Acosh,
    Asin,
    Asinh,
    Atan,
    Atan2,
    Atanh,
    Cbrt,
    Ceil,
    Clamp,
    Copysign,
    Cos,
    Cosh,
    DivEuclid,
    Exp,
    Exp2,
    Expm1,
    Floor,
    MulAdd,
    Fract,
    Hypot,
    IsFinite,
    IsInfinite,
    IsNan,
    IsNormal,
    IsSignNegative,
    IsSignPositive,
    IsSubnormal,
    Ln,
    Ln1p,
    Log,
    Log2,
    Log10,
    Max,
    Midpoint,
    Min,
    NextUp,
    NextDown,
    PowF,
    PowI,
    Recip,
    RemEuclid,
    Round,
    RoundTiesEven,
    Signum,
    Sin,
    Sinh,
    Sqrt,
    Tan,
    Tanh,
    ToDegrees,
    ToRadians,
    TotalCmp,
    Trunc,
    If,
    Avg,
}

#[derive(Debug, Copy, Clone)]
struct ConstDef {
    name: &'static str,
    val: f64,
}

macro_rules! con {
    ($a:expr,$b:expr) => {
        ConstDef { name: $a, val: $b }
    };
}

const CONSTS: [ConstDef; 37] = [
    con!("pi", consts::PI),
    con!("e", consts::E),
    con!("E", consts::E),
    con!("EULER_GAMMA", consts::EULER_GAMMA),
    con!("FRAC_1_PI", consts::FRAC_1_PI),
    con!("FRAC_1_SQRT_2", consts::FRAC_1_SQRT_2),
    con!("FRAC_2_SQRT_PI", consts::FRAC_2_SQRT_PI),
    con!("FRAC_PI_2", consts::FRAC_PI_2),
    con!("FRAC_PI_3", consts::FRAC_PI_3),
    con!("FRAC_PI_4", consts::FRAC_PI_4),
    con!("FRAC_PI_6", consts::FRAC_PI_6),
    con!("FRAC_PI_8", consts::FRAC_PI_8),
    con!("FRAC_2_PI", consts::FRAC_2_PI),
    con!("GOLDEN_RATIO", consts::GOLDEN_RATIO),
    con!("LN_2", consts::LN_2),
    con!("LN_10", consts::LN_10),
    con!("LOG2_10", consts::LOG2_10),
    con!("LOG2_E", consts::LOG2_E),
    con!("LOG10_2", consts::LOG10_2),
    con!("LOG10_E", consts::LOG10_E),
    con!("PI", consts::PI),
    con!("SQRT_2", consts::SQRT_2),
    con!("TAU", consts::TAU),
    con!("DIGITS", f64::DIGITS as f64),
    con!("EPSILON", f64::EPSILON),
    con!("INFINITY", f64::INFINITY),
    con!("MANTISSA_DIGITS", f64::MANTISSA_DIGITS as f64),
    con!("MAX", f64::MAX),
    con!("MAX_10_EXP", f64::MAX_10_EXP as f64),
    con!("MAX_EXP", f64::MAX_EXP as f64),
    con!("MIN", f64::MIN),
    con!("MIN_10_EXP", f64::MIN_10_EXP as f64),
    con!("MIN_EXP", f64::MIN_EXP as f64),
    con!("MIN_POSITIVE", f64::MIN_POSITIVE),
    con!("NAN", f64::NAN),
    con!("NEG_INFINITY", f64::NEG_INFINITY),
    con!("RADIX", f64::RADIX as f64),
];

/// write all the constants to stdout
pub fn show_const() {
    for (i, x) in CONSTS.iter().enumerate() {
        print!("{:12}", x.name);
        if i % 4 == 3 {
            println!();
        }
    }
}

/// write all the constants to stdout
pub fn show_func() {
    for (i, x) in FUNCTIONS.iter().enumerate() {
        print!("{:12}", x.name);
        if i % 6 == 5 {
            println!();
        }
    }
}

#[derive(Debug, Copy, Clone)]
struct FuncDef {
    name: &'static str,
    val: FuncOp,
}

macro_rules! fun {
    ($a:expr,$b:expr) => {
        FuncDef { name: $a, val: $b }
    };
}

const FUNCTIONS: [FuncDef; 57] = [
    fun!("abs", FuncOp::Abs),
    fun!("acos", FuncOp::Acos),
    fun!("acosh", FuncOp::Acosh),
    fun!("asin", FuncOp::Asin),
    fun!("asinh", FuncOp::Asinh),
    fun!("atan", FuncOp::Atan),
    fun!("atan2", FuncOp::Atan2),
    fun!("atanh", FuncOp::Atanh),
    fun!("cbrt", FuncOp::Cbrt),
    fun!("ceil", FuncOp::Ceil),
    fun!("clamp", FuncOp::Clamp),
    fun!("copysign", FuncOp::Copysign),
    fun!("cos", FuncOp::Cos),
    fun!("cosh", FuncOp::Cosh),
    fun!("div_euclid", FuncOp::DivEuclid),
    fun!("exp", FuncOp::Exp),
    fun!("exp2", FuncOp::Exp2),
    fun!("exp_m1", FuncOp::Expm1),
    fun!("floor", FuncOp::Floor),
    fun!("fract", FuncOp::Fract),
    fun!("hypot", FuncOp::Hypot),
    fun!("is_finite", FuncOp::IsFinite),
    fun!("is_infinite", FuncOp::IsInfinite),
    fun!("is_nan", FuncOp::IsNan),
    fun!("is_normal", FuncOp::IsNormal),
    fun!("is_sign_negative", FuncOp::IsSignNegative),
    fun!("is_sign_positive", FuncOp::IsSignPositive),
    fun!("is_subnormal", FuncOp::IsSubnormal),
    fun!("ln", FuncOp::Ln),
    fun!("ln_1p", FuncOp::Ln1p),
    fun!("log", FuncOp::Log),
    fun!("log2", FuncOp::Log2),
    fun!("log10", FuncOp::Log10),
    fun!("max", FuncOp::Max),
    fun!("midpoint", FuncOp::Midpoint),
    fun!("min", FuncOp::Min),
    fun!("mul_add", FuncOp::MulAdd),
    fun!("next_down", FuncOp::NextDown),
    fun!("next_up", FuncOp::NextUp),
    fun!("powf", FuncOp::PowF),
    fun!("powi", FuncOp::PowI),
    fun!("recip", FuncOp::Recip),
    fun!("rem_euclid", FuncOp::RemEuclid),
    fun!("round", FuncOp::Round),
    fun!("round_ties_even", FuncOp::RoundTiesEven),
    fun!("signum", FuncOp::Signum),
    fun!("sin", FuncOp::Sin),
    fun!("sinh", FuncOp::Sinh),
    fun!("sqrt", FuncOp::Sqrt),
    fun!("tan", FuncOp::Tan),
    fun!("tanh", FuncOp::Tanh),
    fun!("trunc", FuncOp::Trunc),
    fun!("to_degrees", FuncOp::ToDegrees),
    fun!("to_radians", FuncOp::ToRadians),
    fun!("total_cmp", FuncOp::TotalCmp),
    fun!("if", FuncOp::If),
    fun!("avg", FuncOp::Avg),
];

const fn min_args(f: FuncOp) -> usize {
    match f {
        FuncOp::Atan2
        | FuncOp::Copysign
        | FuncOp::DivEuclid
        | FuncOp::Hypot
        | FuncOp::Log
        | FuncOp::Midpoint
        | FuncOp::PowF
        | FuncOp::PowI
        | FuncOp::RemEuclid
        | FuncOp::TotalCmp => 2,
        FuncOp::Clamp | FuncOp::MulAdd | FuncOp::If => 3,
        _ => 1,
    }
}

const fn max_args(f: FuncOp) -> usize {
    match f {
        FuncOp::Min | FuncOp::Max | FuncOp::Avg => 0,
        _ => min_args(f),
    }
}

#[derive(Debug, Copy, Clone)]
enum Node {
    Value(f64),
    Var(usize),
    Unary(UnaryOp),
    Binary(BinaryOp),
    Func(FuncOp, usize),
    Dice(usize, usize),
}

#[derive(Default, Debug, Clone)]
struct VarMap {
    name: String,
    val: f64,
    col: Option<usize>, //  associated column number
}
impl VarMap {
    fn new(name: &str) -> Self {
        Self { name: name.to_string(), val: 0.0, col: None }
    }
}

/// trigonometric mode for trig functions
#[derive(Debug, Copy, Clone, Default)]
pub enum TrigMode {
    /// interpret trig function arguments as radians, and return radians for inverse trig functions
    #[default]
    Radians,
    /// interpret trig function arguments as degrees, and return degrees for inverse trig functions
    Degrees,
}

#[derive(Default, Debug, Clone)]
/// A floating point expression
#[expect(clippy::struct_field_names)]
pub struct Expr {
    expr_str: String,
    expr: Vec<Node>,
    vars: Vec<VarMap>, // FIXME - Rc<RefCell<Vec<VarMap>>>, shared
    stack: Vec<f64>,   // temp space for eval
    trig_mode: TrigMode,
}

const fn to_f(x: bool) -> f64 {
    if x { 1.0 } else { 0.0 }
}

fn apply_unary(op: UnaryOp, x: f64) -> f64 {
    match op {
        UnaryOp::Plus => x,
        UnaryOp::Minus => -x,
        UnaryOp::Fact => factorial(x),
    }
}

fn apply_binary(op: BinaryOp, left: f64, right: f64) -> f64 {
    match op {
        BinaryOp::Plus => left + right,
        BinaryOp::Minus => left - right,
        BinaryOp::Times => left * right,
        BinaryOp::Div => left / right,
        BinaryOp::Rem => left % right,
        BinaryOp::Pow => left.powf(right),
        BinaryOp::LT => to_f(left < right),
        BinaryOp::GT => to_f(left > right),
        BinaryOp::EQ => to_f(left == right),
        BinaryOp::NE => to_f(left != right),
        BinaryOp::LE => to_f(left <= right),
        BinaryOp::GE => to_f(left >= right),
    }
}

#[expect(clippy::cast_precision_loss)]
fn roll_dice(x: usize, y: usize) -> f64 {
    let mut ret = 0usize;
    for _ in 0..x {
        ret += fastrand::usize(..y) + 1;
    }
    ret as f64
}

impl Expr {
    /// set trigonometric mode for trig functions
    pub const fn set_trig_mode(&mut self, mode: TrigMode) {
        self.trig_mode = mode;
    }

    #[expect(clippy::missing_asserts_for_indexing)]
    #[expect(clippy::cast_precision_loss)]
    fn apply_func(&self, op: FuncOp, args: &[f64]) -> f64 {
        match op {
            FuncOp::Acos => self.acos(args[0]),
            FuncOp::Acosh => args[0].acosh(),
            FuncOp::Asinh => args[0].asinh(),
            FuncOp::Asin => self.asin(args[0]),
            FuncOp::Atan => self.atan(args[0]),
            FuncOp::Atan2 => self.atan2(args[1], args[0]),
            FuncOp::Atanh => args[0].atanh(),
            FuncOp::Cbrt => args[0].cbrt(),
            FuncOp::Ceil => args[0].ceil(),
            FuncOp::Clamp => args[0].clamp(args[1], args[2]),
            FuncOp::Copysign => args[0].copysign(args[1]),
            FuncOp::Cos => self.cos(args[0]),
            FuncOp::Cosh => args[0].cosh(),
            FuncOp::DivEuclid => args[0].div_euclid(args[1]),
            FuncOp::Exp => args[0].exp(),
            FuncOp::Exp2 => args[0].exp2(),
            FuncOp::Expm1 => args[0].exp_m1(),
            FuncOp::Floor => args[0].floor(),
            FuncOp::Fract => args[0].fract(),
            FuncOp::Hypot => args[0].hypot(args[1]),
            FuncOp::IsFinite => to_f(args[0].is_finite()),
            FuncOp::IsInfinite => to_f(args[0].is_infinite()),
            FuncOp::IsNan => to_f(args[0].is_nan()),
            FuncOp::IsNormal => to_f(args[0].is_normal()),
            FuncOp::IsSignNegative => to_f(args[0].is_sign_negative()),
            FuncOp::IsSignPositive => to_f(args[0].is_sign_positive()),
            FuncOp::IsSubnormal => to_f(args[0].is_subnormal()),
            FuncOp::Ln => args[0].ln(),
            FuncOp::Ln1p => args[0].ln_1p(),
            FuncOp::Log => args[0].log(args[1]),
            FuncOp::Log2 => args[0].log2(),
            FuncOp::Log10 => args[0].log10(),
            FuncOp::Midpoint => args[0].midpoint(args[1]),
            FuncOp::MulAdd => args[0].mul_add(args[1], args[2]),
            FuncOp::NextDown => args[0].next_down(),
            FuncOp::NextUp => args[0].next_up(),
            FuncOp::PowF => args[0].powf(args[1]),
            FuncOp::PowI => args[0].powi(args[1].round() as i32),
            FuncOp::Recip => args[0].recip(),
            FuncOp::RemEuclid => args[0].rem_euclid(args[1]),
            FuncOp::Round => args[0].round(),
            FuncOp::RoundTiesEven => args[0].round_ties_even(),
            FuncOp::Signum => args[0].signum(),
            FuncOp::Sin => self.sin(args[0]),
            FuncOp::Sinh => args[0].sinh(),
            FuncOp::Sqrt => args[0].sqrt(),
            FuncOp::Tan => self.tan(args[0]),
            FuncOp::Tanh => args[0].tanh(),
            FuncOp::ToDegrees => args[0].to_degrees(),
            FuncOp::ToRadians => args[0].to_radians(),
            FuncOp::TotalCmp => f64::from(args[0].total_cmp(&args[1]) as i32),
            FuncOp::Trunc => args[0].trunc(),
            FuncOp::Abs => args[0].abs(),
            FuncOp::Max => {
                let mut v: f64 = args[0];
                for x in &args[1..] {
                    v = v.max(*x);
                }
                v
            }
            FuncOp::Min => {
                let mut v: f64 = args[0];
                for x in &args[1..] {
                    v = v.min(*x);
                }
                v
            }
            FuncOp::Avg => {
                let mut v: f64 = 0.0;
                for x in args {
                    v += *x;
                }
                v / (args.len() as f64)
            }
            FuncOp::If => {
                if args[0] == 0.0 {
                    args[2]
                } else {
                    args[1]
                }
            }
        }
    }

    fn sin(&self, x: f64) -> f64 {
        match self.trig_mode {
            TrigMode::Radians => x.sin(),
            TrigMode::Degrees => (x.to_radians()).sin(),
        }
    }
    fn cos(&self, x: f64) -> f64 {
        match self.trig_mode {
            TrigMode::Radians => x.cos(),
            TrigMode::Degrees => (x.to_radians()).cos(),
        }
    }
    fn tan(&self, x: f64) -> f64 {
        match self.trig_mode {
            TrigMode::Radians => x.tan(),
            TrigMode::Degrees => (x.to_radians()).tan(),
        }
    }
    fn atan(&self, x: f64) -> f64 {
        match self.trig_mode {
            TrigMode::Radians => x.atan(),
            TrigMode::Degrees => x.atan().to_degrees(),
        }
    }
    fn acos(&self, x: f64) -> f64 {
        match self.trig_mode {
            TrigMode::Radians => x.acos(),
            TrigMode::Degrees => x.acos().to_degrees(),
        }
    }
    fn asin(&self, x: f64) -> f64 {
        match self.trig_mode {
            TrigMode::Radians => x.asin(),
            TrigMode::Degrees => x.asin().to_degrees(),
        }
    }
    fn atan2(&self, y: f64, x: f64) -> f64 {
        match self.trig_mode {
            TrigMode::Radians => y.atan2(x),
            TrigMode::Degrees => y.atan2(x).to_degrees(),
        }
    }

    /// create Expr from expression
    pub fn new(expr: &str) -> Result<Self> {
        Ok(Self { expr_str: expr.to_string(), ..Self::default() })
    }
    /// which columns are in use
    pub fn used_cols(&self, v: &mut Vec<usize>) {
        for x in &self.vars {
            if let Some(c) = x.col {
                v.push(c);
            }
        }
    }
    /// original text string
    #[must_use]
    pub fn expr(&self) -> &str {
        &self.expr_str
    }
    fn parse(&mut self, exp: &str) -> Result<()> {
        let tokens = tokenize(exp)?;
        let rpn = to_rpn(&tokens)?;
        self.rpn_to_expr(&rpn)
    }
    fn parse_self(&mut self) -> Result<()> {
        let tokens = tokenize(&self.expr_str)?;
        let rpn = to_rpn(&tokens)?;
        self.rpn_to_expr(&rpn)
    }
    /// resolve named columns
    pub fn lookup(&mut self, field_names: &ColumnNamesRef) -> Result<()> {
        let mut n = self.expr_str.clone();
        while let Some(pos) = n.find('[') {
            let len = find_close(&n[pos..])?;
            let mut s = ColumnSet::new();
            s.add_yes(&n[pos + 1..pos + len - 1])?;
            s.lookup(field_names)?;
            let v = s.get_cols_num();
            let mut nval = String::new();
            if !v.is_empty() {
                write!(nval, "c{}", v[0] + 1)?;
            }
            for x in v.iter().skip(1) {
                write!(nval, ",c{}", x + 1)?;
            }
            n.replace_range(pos..pos + len, &nval);
        }
        let start_vars = self.vars.len();
        self.parse(&n)?;
        'outer: for y in self.vars.iter_mut().skip(start_vars) {
            static CN: LazyLock<Regex> = LazyLock::new(|| Regex::new("^c([0-9]+)$").unwrap());
            for (i, x) in field_names.iter().enumerate() {
                if *x == y.name {
                    y.col = Some(i);
                    continue 'outer;
                }
            }
            // lazy_static! {
            //     static ref CN: Regex = Regex::new("^c([0-9]+)$").unwrap();
            // }
            if let Some(cn) = CN.captures(&y.name) {
                y.col = Some(cn.get(1).unwrap().as_str().to_usize_whole(b"", "").unwrap() - 1);
                continue;
            }
            // FIXME - some way to declare other variables
            return err!("Undefined variable {}", y.name);
        }
        Ok(())
    }
    fn prepare(&mut self, t: &TextLine) {
        for x in &mut self.vars {
            if let Some(c) = x.col {
                x.val = t.get(c).to_f64_lossy();
            }
        }
    }
    fn prepare_line(&mut self, t: &[u8], delim: u8) {
        for x in &mut self.vars {
            if let Some(c) = x.col {
                x.val = get_col(t, c, delim).to_f64_lossy();
            }
        }
    }
    /// set the value of a variable
    pub fn set_var(&mut self, which: usize, val: f64) {
        self.vars[which].val = val;
    }
    /// return index of var, adding if necessary
    pub fn find_var(&mut self, name: &str) -> usize {
        for (i, x) in self.vars.iter().enumerate() {
            if x.name == name {
                return i;
            }
        }
        self.vars.push(VarMap::new(name));
        self.vars.len() - 1
    }
    fn rpn_to_expr(&mut self, rpn: &[Token]) -> Result<()> {
        let mut e = Vec::new();
        for x in rpn {
            match x {
                Token::Dice(x, y) => {
                    e.push(Node::Dice(*x, *y));
                }
                Token::Binary(op) => {
                    let top = e.len() - 1;
                    if let Node::Value(right) = e[top]
                        && let Node::Value(left) = e[top - 1]
                    {
                        e[top - 1] = Node::Value(apply_binary(*op, left, right));
                        e.pop();
                        continue;
                    }
                    e.push(Node::Binary(*op));
                }
                Token::Unary(op) => {
                    if *op != UnaryOp::Plus {
                        if let Node::Value(v) = e.last_mut().unwrap() {
                            *v = apply_unary(*op, *v);
                        } else {
                            e.push(Node::Unary(*op));
                        }
                    }
                }
                Token::LParen | Token::RParen | Token::Comma => {
                    eprintln!("Andy doesn't know what's going on");
                }
                Token::Number(n) => e.push(Node::Value(*n)),
                Token::Var(name) => {
                    if let Some(con) = find_const(name) {
                        e.push(Node::Value(con));
                    } else {
                        e.push(Node::Var(self.find_var(name)));
                    }
                }
                Token::Func(name, num) => {
                    if let Some(n) = num {
                        let f = find_func(name)?;
                        let min = min_args(f);
                        let max = max_args(f);
                        if *n < min {
                            return err!("Function {} requires at least {} parameters", name, min);
                        }
                        if (max > 0) && (*n > max) {
                            return err!("Function {} takes no more than {} parameters", name, max);
                        }
                        if *n == 1
                            && let Node::Value(v) = e.last_mut().unwrap()
                        {
                            *v = self.apply_func(f, &[*v]);
                            continue;
                        }
                        // FIXME -- hndle N args somehow?
                        e.push(Node::Func(f, *n));
                    } else {
                        eprintln!("Andy doesn't understand functions");
                    }
                }
            }
        }
        self.expr = e;
        Ok(())
    }
    /// evaluate constant expression
    pub fn eval_plain(&mut self) -> Result<f64> {
        // Error if variables?
        self.parse_self()?;
        Ok(self.do_eval())
    }
    /// evaluate expression with values from line
    pub fn eval(&mut self, line: &TextLine) -> f64 {
        self.prepare(line);
        self.do_eval()
    }
    /// evaluate expression with values from line
    pub fn eval_line(&mut self, line: &[u8], delim: u8) -> f64 {
        self.prepare_line(line, delim);
        self.do_eval()
    }
    fn do_eval(&mut self) -> f64 {
        self.stack.clear();
        for x in &self.expr {
            match x {
                Node::Dice(x, y) => self.stack.push(roll_dice(*x, *y)),
                Node::Value(v) => self.stack.push(*v),
                Node::Var(v) => self.stack.push(self.vars[*v].val),
                Node::Unary(op) => {
                    let top = self.stack.len() - 1;
                    self.stack[top] = apply_unary(*op, self.stack[top]);
                }
                Node::Binary(op) => {
                    let top = self.stack.len() - 2;
                    let left: f64 = self.stack[top];
                    let right: f64 = self.stack[top + 1];
                    self.stack.pop().unwrap();
                    self.stack[top] = apply_binary(*op, left, right);
                }
                Node::Func(op, num) => {
                    let v = self.apply_func(*op, &self.stack[self.stack.len() - num..]);
                    self.stack.resize(self.stack.len() - (num - 1), 0.0);
                    let pos = self.stack.len() - 1;
                    self.stack[pos] = v;
                }
            }
        }
        if self.stack.is_empty() { 0.0 } else { self.stack[0] }
    }
}

fn factorial(x: f64) -> f64 {
    if x < 0.0 {
        return 0.0;
    }
    let pos = x.round() as usize;
    if pos > 170 { f64::INFINITY } else { FACTORIAL[pos] }
}

const MAX_FACTORIAL: usize = 170;

// Initialization for pre-computed cache of 171 factorial
// values 0!...170!
#[expect(clippy::cast_precision_loss)]
const FACTORIAL: [f64; MAX_FACTORIAL + 1] = {
    let mut fcache = [1.0; MAX_FACTORIAL + 1];

    // `const` only allow while loops
    let mut i = 1;
    while i < MAX_FACTORIAL + 1 {
        fcache[i] = fcache[i - 1] * i as f64;
        i += 1;
    }

    fcache
};

// const FACTORIAL: [f64; 171] = [
//     0.0,
//     1.0,
//     2.0,
//     6.0,
//     24.0,
//     120.0,
//     720.0,
//     5.04e3,
//     4.032e4,
//     3.6288e5,
//     3.6288e6,
//     3.99168e7,
//     4.790_016e8,
//     6.227_020_8e9,
//     8.717_829_12e10,
//     1.307_674_368e12,
//     2.092_278_988_8e13,
//     3.556_874_280_96e14,
//     6.402_373_705_728e15,
//     1.216_451_004_088_32e17,
//     2.432_902_008_176_64e18,
//     5.109_094_217_170_944e19,
//     1.124_000_727_777_607_7e21,
//     2.585_201_673_888_498e22,
//     6.204_484_017_332_394e23,
//     1.551_121_004_333_098_6e25,
//     4.032_914_611_266_056_5e26,
//     1.088_886_945_041_835_2e28,
//     3.048_883_446_117_138_4e29,
//     8.841_761_993_739_701e30,
//     2.652_528_598_121_910_3e32,
//     8.222_838_654_177_922e33,
//     2.631_308_369_336_935e35,
//     8.683_317_618_811_886e36,
//     2.952_327_990_396_041_2e38,
//     1.033_314_796_638_614_4e40,
//     3.719_933_267_899_012e41,
//     1.376_375_309_122_634_3e43,
//     5.230_226_174_666_01e44,
//     2.039_788_208_119_744_2e46,
//     8.159_152_832_478_977e47,
//     3.345_252_661_316_380_3e49,
//     1.405_006_117_752_879_8e51,
//     6.041_526_306_337_383e52,
//     2.658_271_574_788_448_5e54,
//     1.196_222_208_654_801_9e56,
//     5.502_622_159_812_088_5e57,
//     2.586_232_415_111_681_8e59,
//     1.241_391_559_253_607_3e61,
//     6.082_818_640_342_675e62,
//     3.041_409_320_171_337_6e64,
//     1.551_118_753_287_382_2e66,
//     8.065_817_517_094_388e67,
//     4.274_883_284_060_025_5e69,
//     2.308_436_973_392_414e71,
//     1.269_640_335_365_827_6e73,
//     7.109_985_878_048_635e74,
//     4.052_691_950_487_722e76,
//     2.350_561_331_282_879e78,
//     1.386_831_185_456_898_6e80,
//     8.320_987_112_741_392e81,
//     5.075_802_138_772_248e83,
//     3.146_997_326_038_794e85,
//     1.982_608_315_404_44e87,
//     1.268_869_321_858_841_7e89,
//     8.247_650_592_082_472e90,
//     5.443_449_390_774_431e92,
//     3.647_111_091_818_868e94,
//     2.480_035_542_436_830_5e96,
//     1.711_224_524_281_413e98,
//     1.197_857_166_996_989e100,
//     8.504_785_885_678_622e101,
//     6.123_445_837_688_608e103,
//     4.470_115_461_512_683_4e105,
//     3.307_885_441_519_385_6e107,
//     2.480_914_081_139_539e109,
//     1.885_494_701_666_049_8e111,
//     1.451_830_920_282_858_4e113,
//     1.132_428_117_820_629_5e115,
//     8.946_182_130_782_973e116,
//     7.156_945_704_626_378e118,
//     5.797_126_020_747_366e120,
//     4.753_643_337_012_84e122,
//     3.945_523_969_720_657e124,
//     3.314_240_134_565_352e126,
//     2.817_104_114_380_549_4e128,
//     2.422_709_538_367_272_4e130,
//     2.107_757_298_379_527e132,
//     1.854_826_422_573_983_6e134,
//     1.650_795_516_090_845_2e136,
//     1.485_715_964_481_760_7e138,
//     1.352_001_527_678_402_3e140,
//     1.243_841_405_464_13e142,
//     1.156_772_507_081_640_9e144,
//     1.087_366_156_656_742_4e146,
//     1.032_997_848_823_905_2e148,
//     9.916_779_348_709_491e149,
//     9.619_275_968_248_206e151,
//     9.426_890_448_883_242e153,
//     9.332_621_544_394_41e155,
//     9.332_621_544_394_41e157,
//     9.425_947_759_838_354e159,
//     9.614_466_715_035_121e161,
//     9.902_900_716_486_175e163,
//     1.029_901_674_514_562_2e166,
//     1.081_396_758_240_290_3e168,
//     1.146_280_563_734_707_8e170,
//     1.226_520_203_196_137_3e172,
//     1.324_641_819_451_828_4e174,
//     1.443_859_583_202_492_8e176,
//     1.588_245_541_522_742_1e178,
//     1.762_952_551_090_243_7e180,
//     1.974_506_857_221_072_8e182,
//     2.231_192_748_659_812_3e184,
//     2.543_559_733_472_186e186,
//     2.925_093_693_493_014e188,
//     3.393_108_684_451_896_5e190,
//     3.969_937_160_808_719e192,
//     4.684_525_849_754_288_3e194,
//     5.574_585_761_207_603e196,
//     6.689_502_913_449_124e198,
//     8.094_298_525_273_44e200,
//     9.875_044_200_833_598e202,
//     1.214_630_436_702_532_5e205,
//     1.506_141_741_511_140_4e207,
//     1.882_677_176_888_925_4e209,
//     2.372_173_242_880_046e211,
//     3.012_660_018_457_658e213,
//     3.856_204_823_625_802_5e215,
//     4.974_504_222_477_285_5e217,
//     6.466_855_489_220_472e219,
//     8.471_580_690_878_817e221,
//     1.118_248_651_196_004e224,
//     1.487_270_706_090_685_2e226,
//     1.992_942_746_161_518e228,
//     2.690_472_707_318_049_5e230,
//     3.659_042_881_952_547e232,
//     5.012_888_748_274_99e234,
//     6.917_786_472_619_486e236,
//     9.615_723_196_941_086e238,
//     1.346_201_247_571_752e241,
//     1.898_143_759_076_17e243,
//     2.695_364_137_888_161_4e245,
//     3.854_370_717_180_070_6e247,
//     5.550_293_832_739_301e249,
//     8.047_926_057_471_987e251,
//     1.174_997_204_390_91e254,
//     1.727_245_890_454_637_6e256,
//     2.556_323_917_872_863_7e258,
//     3.808_922_637_630_567e260,
//     5.713_383_956_445_850_5e262,
//     8.627_209_774_233_235e264,
//     1.311_335_885_683_451_8e267,
//     2.006_343_905_095_681e269,
//     3.089_769_613_847_349e271,
//     4.789_142_901_463_391e273,
//     7.471_062_926_282_89e275,
//     1.172_956_879_426_413_8e278,
//     1.853_271_869_493_733_8e280,
//     2.946_702_272_495_037e282,
//     4.714_723_635_992_059e284,
//     7.590_705_053_947_215e286,
//     1.229_694_218_739_448_8e289,
//     2.004_401_576_545_301_5e291,
//     3.287_218_585_534_294_5e293,
//     5.423_910_666_131_586e295,
//     9.003_691_705_778_433e297,
//     1.503_616_514_864_998_3e300,
//     2.526_075_744_973_197e302,
//     4.269_068_009_004_702_7e304,
//     7.257_415_615_307_994e306,
// ];