use self::Suffix::*;
use self::TargetFeature::*;
use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::io::{self, BufReader};
use std::path::PathBuf;

const IN: &str = "neon.spec";
const ARM_OUT: &str = "generated.rs";
const AARCH64_OUT: &str = "generated.rs";

const UINT_TYPES: [&str; 6] = [
    "uint8x8_t",
    "uint8x16_t",
    "uint16x4_t",
    "uint16x8_t",
    "uint32x2_t",
    "uint32x4_t",
];

const UINT_TYPES_64: [&str; 2] = ["uint64x1_t", "uint64x2_t"];

const INT_TYPES: [&str; 6] = [
    "int8x8_t",
    "int8x16_t",
    "int16x4_t",
    "int16x8_t",
    "int32x2_t",
    "int32x4_t",
];

const INT_TYPES_64: [&str; 2] = ["int64x1_t", "int64x2_t"];

const FLOAT_TYPES: [&str; 2] = [
    //"float8x8_t", not supported by rust
    //"float8x16_t", not supported by rust
    //"float16x4_t", not supported by rust
    //"float16x8_t", not supported by rust
    "float32x2_t",
    "float32x4_t",
];

const FLOAT_TYPES_64: [&str; 2] = [
    //"float8x8_t", not supported by rust
    //"float8x16_t", not supported by rust
    //"float16x4_t", not supported by rust
    //"float16x8_t", not supported by rust
    "float64x1_t",
    "float64x2_t",
];

fn type_len(t: &str) -> usize {
    let s: Vec<_> = t.split("x").collect();
    if s.len() == 2 {
        match &s[1][0..2] {
            "1_" => 1,
            "2_" => 2,
            "4_" => 4,
            "8_" => 8,
            "16" => 16,
            _ => panic!("unknown type: {}", t),
        }
    } else if s.len() == 3 {
        s[1].parse::<usize>().unwrap() * type_sub_len(t)
    } else {
        1
    }
}

fn type_sub_len(t: &str) -> usize {
    let s: Vec<_> = t.split('x').collect();
    if s.len() != 3 {
        1
    } else {
        match s[2] {
            "2_t" => 2,
            "3_t" => 3,
            "4_t" => 4,
            _ => panic!("unknown type len: {}", t),
        }
    }
}

fn type_bits(t: &str) -> usize {
    match t {
        "int8x8_t" | "int8x16_t" | "uint8x8_t" | "uint8x16_t" | "poly8x8_t" | "poly8x16_t"
        | "i8" | "u8" => 8,
        "int16x4_t" | "int16x8_t" | "uint16x4_t" | "uint16x8_t" | "poly16x4_t" | "poly16x8_t"
        | "i16" | "u16" => 16,
        "int32x2_t" | "int32x4_t" | "uint32x2_t" | "uint32x4_t" | "i32" | "u32" | "float32x2_t"
        | "float32x4_t" | "f32" => 32,
        "int64x1_t" | "int64x2_t" | "uint64x1_t" | "uint64x2_t" | "poly64x1_t" | "poly64x2_t"
        | "i64" | "u64" | "float64x1_t" | "float64x2_t" | "f64" => 64,
        _ => panic!("unknown type: {}", t),
    }
}

fn type_exp_len(t: &str, base_len: usize) -> usize {
    let t = type_to_sub_type(t);
    let len = type_len(&t) / base_len;
    match len {
        1 => 0,
        2 => 1,
        4 => 2,
        8 => 3,
        16 => 4,
        _ => panic!("unknown type: {}", t),
    }
}

fn type_bits_exp_len(t: &str) -> usize {
    match t {
        "int8x8_t" | "int8x16_t" | "uint8x8_t" | "uint8x16_t" | "poly8x8_t" | "poly8x16_t"
        | "i8" | "u8" => 3,
        "int16x4_t" | "int16x8_t" | "uint16x4_t" | "uint16x8_t" | "poly16x4_t" | "poly16x8_t"
        | "i16" | "u16" => 4,
        "int32x2_t" | "int32x4_t" | "uint32x2_t" | "uint32x4_t" | "i32" | "u32" => 5,
        "int64x1_t" | "int64x2_t" | "uint64x1_t" | "uint64x2_t" | "poly64x1_t" | "poly64x2_t"
        | "i64" | "u64" => 6,
        _ => panic!("unknown type: {}", t),
    }
}

fn type_to_suffix(t: &str) -> &str {
    match t {
        "int8x8_t" => "_s8",
        "int8x16_t" => "q_s8",
        "int16x4_t" => "_s16",
        "int16x8_t" => "q_s16",
        "int32x2_t" => "_s32",
        "int32x4_t" => "q_s32",
        "int64x1_t" => "_s64",
        "int64x2_t" => "q_s64",
        "uint8x8_t" => "_u8",
        "uint8x16_t" => "q_u8",
        "uint16x4_t" => "_u16",
        "uint16x8_t" => "q_u16",
        "uint32x2_t" => "_u32",
        "uint32x4_t" => "q_u32",
        "uint64x1_t" => "_u64",
        "uint64x2_t" => "q_u64",
        "float16x4_t" => "_f16",
        "float16x8_t" => "q_f16",
        "float32x2_t" => "_f32",
        "float32x4_t" => "q_f32",
        "float64x1_t" => "_f64",
        "float64x2_t" => "q_f64",
        "poly8x8_t" => "_p8",
        "poly8x16_t" => "q_p8",
        "poly16x4_t" => "_p16",
        "poly16x8_t" => "q_p16",
        "poly64x1_t" => "_p64",
        "poly64x2_t" => "q_p64",
        "int8x8x2_t" => "_s8_x2",
        "int8x8x3_t" => "_s8_x3",
        "int8x8x4_t" => "_s8_x4",
        "int16x4x2_t" => "_s16_x2",
        "int16x4x3_t" => "_s16_x3",
        "int16x4x4_t" => "_s16_x4",
        "int32x2x2_t" => "_s32_x2",
        "int32x2x3_t" => "_s32_x3",
        "int32x2x4_t" => "_s32_x4",
        "int64x1x2_t" => "_s64_x2",
        "int64x1x3_t" => "_s64_x3",
        "int64x1x4_t" => "_s64_x4",
        "uint8x8x2_t" => "_u8_x2",
        "uint8x8x3_t" => "_u8_x3",
        "uint8x8x4_t" => "_u8_x4",
        "uint16x4x2_t" => "_u16_x2",
        "uint16x4x3_t" => "_u16_x3",
        "uint16x4x4_t" => "_u16_x4",
        "uint32x2x2_t" => "_u32_x2",
        "uint32x2x3_t" => "_u32_x3",
        "uint32x2x4_t" => "_u32_x4",
        "uint64x1x2_t" => "_u64_x2",
        "uint64x1x3_t" => "_u64_x3",
        "uint64x1x4_t" => "_u64_x4",
        "poly8x8x2_t" => "_p8_x2",
        "poly8x8x3_t" => "_p8_x3",
        "poly8x8x4_t" => "_p8_x4",
        "poly16x4x2_t" => "_p16_x2",
        "poly16x4x3_t" => "_p16_x3",
        "poly16x4x4_t" => "_p16_x4",
        "poly64x1x2_t" => "_p64_x2",
        "poly64x1x3_t" => "_p64_x3",
        "poly64x1x4_t" => "_p64_x4",
        "float32x2x2_t" => "_f32_x2",
        "float32x2x3_t" => "_f32_x3",
        "float32x2x4_t" => "_f32_x4",
        "float64x1x2_t" => "_f64_x2",
        "float64x1x3_t" => "_f64_x3",
        "float64x1x4_t" => "_f64_x4",
        "int8x16x2_t" => "q_s8_x2",
        "int8x16x3_t" => "q_s8_x3",
        "int8x16x4_t" => "q_s8_x4",
        "int16x8x2_t" => "q_s16_x2",
        "int16x8x3_t" => "q_s16_x3",
        "int16x8x4_t" => "q_s16_x4",
        "int32x4x2_t" => "q_s32_x2",
        "int32x4x3_t" => "q_s32_x3",
        "int32x4x4_t" => "q_s32_x4",
        "int64x2x2_t" => "q_s64_x2",
        "int64x2x3_t" => "q_s64_x3",
        "int64x2x4_t" => "q_s64_x4",
        "uint8x16x2_t" => "q_u8_x2",
        "uint8x16x3_t" => "q_u8_x3",
        "uint8x16x4_t" => "q_u8_x4",
        "uint16x8x2_t" => "q_u16_x2",
        "uint16x8x3_t" => "q_u16_x3",
        "uint16x8x4_t" => "q_u16_x4",
        "uint32x4x2_t" => "q_u32_x2",
        "uint32x4x3_t" => "q_u32_x3",
        "uint32x4x4_t" => "q_u32_x4",
        "uint64x2x2_t" => "q_u64_x2",
        "uint64x2x3_t" => "q_u64_x3",
        "uint64x2x4_t" => "q_u64_x4",
        "poly8x16x2_t" => "q_p8_x2",
        "poly8x16x3_t" => "q_p8_x3",
        "poly8x16x4_t" => "q_p8_x4",
        "poly16x8x2_t" => "q_p16_x2",
        "poly16x8x3_t" => "q_p16_x3",
        "poly16x8x4_t" => "q_p16_x4",
        "poly64x2x2_t" => "q_p64_x2",
        "poly64x2x3_t" => "q_p64_x3",
        "poly64x2x4_t" => "q_p64_x4",
        "float32x4x2_t" => "q_f32_x2",
        "float32x4x3_t" => "q_f32_x3",
        "float32x4x4_t" => "q_f32_x4",
        "float64x2x2_t" => "q_f64_x2",
        "float64x2x3_t" => "q_f64_x3",
        "float64x2x4_t" => "q_f64_x4",
        "i8" => "b_s8",
        "i16" => "h_s16",
        "i32" => "s_s32",
        "i64" => "d_s64",
        "u8" => "b_u8",
        "u16" => "h_u16",
        "u32" => "s_u32",
        "u64" => "d_u64",
        "f32" => "s_f32",
        "f64" => "d_f64",
        "p8" => "b_p8",
        "p16" => "h_p16",
        "p128" => "q_p128",
        _ => panic!("unknown type: {}", t),
    }
}

fn type_to_dup_suffix(t: &str) -> String {
    let s: Vec<_> = type_to_suffix(t).split('_').collect();
    assert_eq!(s.len(), 2);
    format!("{}_dup_{}", s[0], s[1])
}

fn type_to_lane_suffix(t: &str) -> String {
    let s: Vec<_> = type_to_suffix(t).split('_').collect();
    assert_eq!(s.len(), 2);
    format!("{}_lane_{}", s[0], s[1])
}

fn type_to_n_suffix(t: &str) -> &str {
    match t {
        "int8x8_t" => "_n_s8",
        "int8x16_t" => "q_n_s8",
        "int16x4_t" => "_n_s16",
        "int16x8_t" => "q_n_s16",
        "int32x2_t" => "_n_s32",
        "int32x4_t" => "q_n_s32",
        "int64x1_t" => "_n_s64",
        "int64x2_t" => "q_n_s64",
        "uint8x8_t" => "_n_u8",
        "uint8x16_t" => "q_n_u8",
        "uint16x4_t" => "_n_u16",
        "uint16x8_t" => "q_n_u16",
        "uint32x2_t" => "_n_u32",
        "uint32x4_t" => "q_n_u32",
        "uint64x1_t" => "_n_u64",
        "uint64x2_t" => "q_n_u64",
        "float16x4_t" => "_n_f16",
        "float16x8_t" => "q_n_f16",
        "float32x2_t" => "_n_f32",
        "float32x4_t" => "q_n_f32",
        "float64x1_t" => "_n_f64",
        "float64x2_t" => "q_n_f64",
        "poly8x8_t" => "_n_p8",
        "poly8x16_t" => "q_n_p8",
        "poly16x4_t" => "_n_p16",
        "poly16x8_t" => "q_n_p16",
        "poly64x1_t" => "_n_p64",
        "poly64x2_t" => "q_n_p64",
        "i8" => "b_n_s8",
        "i16" => "h_n_s16",
        "i32" => "s_n_s32",
        "i64" => "d_n_s64",
        "u8" => "b_n_u8",
        "u16" => "h_n_u16",
        "u32" => "s_n_u32",
        "u64" => "d_n_u64",
        _ => panic!("unknown type: {}", t),
    }
}

fn type_to_noq_n_suffix(t: &str) -> &str {
    match t {
        "int8x8_t" | "int8x16_t" => "_n_s8",
        "int16x4_t" | "int16x8_t" => "_n_s16",
        "int32x2_t" | "int32x4_t" => "_n_s32",
        "int64x1_t" | "int64x2_t" => "_n_s64",
        "uint8x8_t" | "uint8x16_t" => "_n_u8",
        "uint16x4_t" | "uint16x8_t" => "_n_u16",
        "uint32x2_t" | "uint32x4_t" => "_n_u32",
        "uint64x1_t" | "uint64x2_t" => "_n_u64",
        "float16x4_t" | "float16x8_t" => "_n_f16",
        "float32x2_t" | "float32x4_t" => "_n_f32",
        "float64x1_t" | "float64x2_t" => "_n_f64",
        "poly8x8_t" | "poly8x16_t" => "_n_p8",
        "poly16x4_t" | "poly16x8_t" => "_n_p16",
        "poly64x1_t" | "poly64x2_t" => "_n_p64",
        "i8" => "b_n_s8",
        "i16" => "h_n_s16",
        "i32" => "s_n_s32",
        "i64" => "d_n_s64",
        "u8" => "b_n_u8",
        "u16" => "h_n_u16",
        "u32" => "s_n_u32",
        "u64" => "d_n_u64",
        _ => panic!("unknown type: {}", t),
    }
}

fn type_to_lane_suffixes<'a>(out_t: &'a str, in_t: &'a str, re_to_out: bool) -> String {
    let mut str = String::new();
    let suf = type_to_suffix(out_t);
    if !suf.starts_with("_") {
        str.push_str(&suf[0..1]);
    }
    str.push_str("_lane");
    if !re_to_out {
        str.push_str(type_to_suffix(in_t));
    } else {
        if type_to_suffix(in_t).starts_with("q") {
            str.push_str("q");
        };
        let suf2 = type_to_noq_suffix(out_t);
        str.push_str(suf2);
    }
    str
}

fn type_to_rot_suffix(c_name: &str, suf: &str) -> String {
    let ns: Vec<_> = c_name.split('_').collect();
    assert_eq!(ns.len(), 2);
    if suf.starts_with("q") {
        format!("{}q_{}{}", ns[0], ns[1], &suf[1..])
    } else {
        format!("{}{}", c_name, suf)
    }
}

fn type_to_signed(t: &str) -> String {
    let s = t.replace("uint", "int");
    let s = s.replace("poly", "int");
    s
}

fn type_to_unsigned(t: &str) -> String {
    if t.contains("uint") {
        return t.to_string();
    }
    let s = t.replace("int", "uint");
    let s = s.replace("poly", "uint");
    s
}

fn type_to_double_suffixes<'a>(out_t: &'a str, in_t: &'a str) -> String {
    let mut str = String::new();
    let suf = type_to_suffix(in_t);
    if suf.starts_with("q") && type_to_suffix(out_t).starts_with("q") {
        str.push_str("q");
    }
    if !suf.starts_with("_") && !suf.starts_with("q") {
        str.push_str(&suf[0..1]);
    }
    str.push_str(type_to_noq_suffix(out_t));
    str.push_str(type_to_noq_suffix(in_t));
    str
}

fn type_to_double_n_suffixes<'a>(out_t: &'a str, in_t: &'a str) -> String {
    let mut str = String::new();
    let suf = type_to_suffix(in_t);
    if suf.starts_with("q") && type_to_suffix(out_t).starts_with("q") {
        str.push_str("q");
    }
    if !suf.starts_with("_") && !suf.starts_with("q") {
        str.push_str(&suf[0..1]);
    }
    str.push_str("_n");
    str.push_str(type_to_noq_suffix(out_t));
    str.push_str(type_to_noq_suffix(in_t));
    str
}

fn type_to_noq_double_suffixes<'a>(out_t: &'a str, in_t: &'a str) -> String {
    let mut str = String::new();
    str.push_str(type_to_noq_suffix(out_t));
    str.push_str(type_to_noq_suffix(in_t));
    str
}

fn type_to_noq_suffix(t: &str) -> &str {
    match t {
        "int8x8_t" | "int8x16_t" | "i8" => "_s8",
        "int16x4_t" | "int16x8_t" | "i16" => "_s16",
        "int32x2_t" | "int32x4_t" | "i32" => "_s32",
        "int64x1_t" | "int64x2_t" | "i64" => "_s64",
        "uint8x8_t" | "uint8x16_t" | "u8" => "_u8",
        "uint16x4_t" | "uint16x8_t" | "u16" => "_u16",
        "uint32x2_t" | "uint32x4_t" | "u32" => "_u32",
        "uint64x1_t" | "uint64x2_t" | "u64" => "_u64",
        "float16x4_t" | "float16x8_t" => "_f16",
        "float32x2_t" | "float32x4_t" | "f32" => "_f32",
        "float64x1_t" | "float64x2_t" | "f64" => "_f64",
        "poly8x8_t" | "poly8x16_t" => "_p8",
        "poly16x4_t" | "poly16x8_t" => "_p16",
        "poly64x1_t" | "poly64x2_t" | "p64" => "_p64",
        "p128" => "_p128",
        _ => panic!("unknown type: {}", t),
    }
}

#[derive(Clone, Copy)]
enum Suffix {
    Normal,
    Double,
    NoQ,
    NoQDouble,
    NSuffix,
    DoubleN,
    NoQNSuffix,
    OutSuffix,
    OutNSuffix,
    OutNox,
    In1Nox,
    OutDupNox,
    OutLaneNox,
    In1LaneNox,
    Lane,
    In2,
    In2Lane,
    OutLane,
    Rot,
    RotLane,
}

#[derive(Clone, Copy)]
enum TargetFeature {
    Default,
    ArmV7,
    Vfp4,
    FPArmV8,
    AES,
    FCMA,
    Dotprod,
    I8MM,
    SHA3,
    RDM,
    SM4,
    FTTS,
}

#[derive(Clone, Copy)]
enum Fntype {
    Normal,
    Load,
    Store,
}

fn type_to_global_type(t: &str) -> &str {
    match t {
        "int8x8_t" | "int8x8x2_t" | "int8x8x3_t" | "int8x8x4_t" => "i8x8",
        "int8x16_t" | "int8x16x2_t" | "int8x16x3_t" | "int8x16x4_t" => "i8x16",
        "int16x4_t" | "int16x4x2_t" | "int16x4x3_t" | "int16x4x4_t" => "i16x4",
        "int16x8_t" | "int16x8x2_t" | "int16x8x3_t" | "int16x8x4_t" => "i16x8",
        "int32x2_t" | "int32x2x2_t" | "int32x2x3_t" | "int32x2x4_t" => "i32x2",
        "int32x4_t" | "int32x4x2_t" | "int32x4x3_t" | "int32x4x4_t" => "i32x4",
        "int64x1_t" | "int64x1x2_t" | "int64x1x3_t" | "int64x1x4_t" => "i64x1",
        "int64x2_t" | "int64x2x2_t" | "int64x2x3_t" | "int64x2x4_t" => "i64x2",
        "uint8x8_t" | "uint8x8x2_t" | "uint8x8x3_t" | "uint8x8x4_t" => "u8x8",
        "uint8x16_t" | "uint8x16x2_t" | "uint8x16x3_t" | "uint8x16x4_t" => "u8x16",
        "uint16x4_t" | "uint16x4x2_t" | "uint16x4x3_t" | "uint16x4x4_t" => "u16x4",
        "uint16x8_t" | "uint16x8x2_t" | "uint16x8x3_t" | "uint16x8x4_t" => "u16x8",
        "uint32x2_t" | "uint32x2x2_t" | "uint32x2x3_t" | "uint32x2x4_t" => "u32x2",
        "uint32x4_t" | "uint32x4x2_t" | "uint32x4x3_t" | "uint32x4x4_t" => "u32x4",
        "uint64x1_t" | "uint64x1x2_t" | "uint64x1x3_t" | "uint64x1x4_t" => "u64x1",
        "uint64x2_t" | "uint64x2x2_t" | "uint64x2x3_t" | "uint64x2x4_t" => "u64x2",
        "float16x4_t" => "f16x4",
        "float16x8_t" => "f16x8",
        "float32x2_t" | "float32x2x2_t" | "float32x2x3_t" | "float32x2x4_t" => "f32x2",
        "float32x4_t" | "float32x4x2_t" | "float32x4x3_t" | "float32x4x4_t" => "f32x4",
        "float64x1_t" | "float64x1x2_t" | "float64x1x3_t" | "float64x1x4_t" => "f64",
        "float64x2_t" | "float64x2x2_t" | "float64x2x3_t" | "float64x2x4_t" => "f64x2",
        "poly8x8_t" | "poly8x8x2_t" | "poly8x8x3_t" | "poly8x8x4_t" => "i8x8",
        "poly8x16_t" | "poly8x16x2_t" | "poly8x16x3_t" | "poly8x16x4_t" => "i8x16",
        "poly16x4_t" | "poly16x4x2_t" | "poly16x4x3_t" | "poly16x4x4_t" => "i16x4",
        "poly16x8_t" | "poly16x8x2_t" | "poly16x8x3_t" | "poly16x8x4_t" => "i16x8",
        "poly64x1_t" | "poly64x1x2_t" | "poly64x1x3_t" | "poly64x1x4_t" => "i64x1",
        "poly64x2_t" | "poly64x2x2_t" | "poly64x2x3_t" | "poly64x2x4_t" => "i64x2",
        "i8" => "i8",
        "i16" => "i16",
        "i32" => "i32",
        "i64" => "i64",
        "u8" => "u8",
        "u16" => "u16",
        "u32" => "u32",
        "u64" => "u64",
        "f32" => "f32",
        "f64" => "f64",
        "p8" => "p8",
        "p16" => "p16",
        "p64" => "p64",
        "p128" => "p128",
        _ => panic!("unknown type: {}", t),
    }
}

fn type_to_sub_type(t: &str) -> String {
    let s: Vec<_> = t.split('x').collect();
    match s.len() {
        2 => String::from(t),
        3 => format!("{}x{}_t", s[0], s[1]),
        _ => panic!("unknown type: {}", t),
    }
}

fn type_to_native_type(t: &str) -> String {
    let s: Vec<_> = t.split('x').collect();
    match s.len() {
        1 => {
            assert!(t.contains("*const") || t.contains("*mut"));
            let sub: Vec<_> = t.split(' ').collect();
            String::from(sub[1])
        }
        2 | 3 => match &s[0][0..3] {
            "int" => format!("i{}", &s[0][3..]),
            "uin" => format!("u{}", &s[0][4..]),
            "flo" => format!("f{}", &s[0][5..]),
            "pol" => format!("u{}", &s[0][4..]),
            _ => panic!("unknown type: {}", t),
        },
        _ => panic!("unknown type: {}", t),
    }
}

fn native_type_to_type(t: &str) -> &str {
    match t {
        "i8" => "int8x8_t",
        "i16" => "int16x4_t",
        "i32" => "int32x2_t",
        "i64" => "int64x1_t",
        "u8" => "uint8x8_t",
        "u16" => "uint16x4_t",
        "u32" => "uint32x2_t",
        "u64" => "uint64x1_t",
        "f16" => "float16x4_t",
        "f32" => "float32x2_t",
        "f64" => "float64x1_t",
        _ => panic!("unknown type: {}", t),
    }
}

fn native_type_to_long_type(t: &str) -> &str {
    match t {
        "i8" => "int8x16_t",
        "i16" => "int16x8_t",
        "i32" => "int32x4_t",
        "i64" => "int64x2_t",
        "u8" => "uint8x16_t",
        "u16" => "uint16x8_t",
        "u32" => "uint32x4_t",
        "u64" => "uint64x2_t",
        "f16" => "float16x8_t",
        "f32" => "float32x4_t",
        "f64" => "float64x2_t",
        _ => panic!("unknown type: {}", t),
    }
}

fn type_to_half(t: &str) -> &str {
    match t {
        "int8x16_t" => "int8x8_t",
        "int16x8_t" => "int16x4_t",
        "int32x4_t" => "int32x2_t",
        "int64x2_t" => "int64x1_t",
        "uint8x16_t" => "uint8x8_t",
        "uint16x8_t" => "uint16x4_t",
        "uint32x4_t" => "uint32x2_t",
        "uint64x2_t" => "uint64x1_t",
        "poly8x16_t" => "poly8x8_t",
        "poly16x8_t" => "poly16x4_t",
        "float32x4_t" => "float32x2_t",
        "float64x2_t" => "float64x1_t",
        _ => panic!("unknown half type for {}", t),
    }
}

fn asc(start: i32, len: usize) -> String {
    let mut s = String::from("[");
    for i in 0..len {
        if i != 0 {
            s.push_str(", ");
        }
        let n = start + i as i32;
        s.push_str(&n.to_string());
    }
    s.push_str("]");
    s
}

fn transpose1(x: usize) -> &'static str {
    match x {
        2 => "[0, 2]",
        4 => "[0, 4, 2, 6]",
        8 => "[0, 8, 2, 10, 4, 12, 6, 14]",
        16 => "[0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30]",
        _ => panic!("unknown transpose order of len {}", x),
    }
}

fn transpose2(x: usize) -> &'static str {
    match x {
        2 => "[1, 3]",
        4 => "[1, 5, 3, 7]",
        8 => "[1, 9, 3, 11, 5, 13, 7, 15]",
        16 => "[1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31]",
        _ => panic!("unknown transpose order of len {}", x),
    }
}

fn zip1(x: usize) -> &'static str {
    match x {
        2 => "[0, 2]",
        4 => "[0, 4, 1, 5]",
        8 => "[0, 8, 1, 9, 2, 10, 3, 11]",
        16 => "[0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23]",
        _ => panic!("unknown zip order of len {}", x),
    }
}

fn zip2(x: usize) -> &'static str {
    match x {
        2 => "[1, 3]",
        4 => "[2, 6, 3, 7]",
        8 => "[4, 12, 5, 13, 6, 14, 7, 15]",
        16 => "[8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31]",
        _ => panic!("unknown zip order of len {}", x),
    }
}

fn unzip1(x: usize) -> &'static str {
    match x {
        2 => "[0, 2]",
        4 => "[0, 2, 4, 6]",
        8 => "[0, 2, 4, 6, 8, 10, 12, 14]",
        16 => "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]",
        _ => panic!("unknown unzip order of len {}", x),
    }
}

fn unzip2(x: usize) -> &'static str {
    match x {
        2 => "[1, 3]",
        4 => "[1, 3, 5, 7]",
        8 => "[1, 3, 5, 7, 9, 11, 13, 15]",
        16 => "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31]",
        _ => panic!("unknown unzip order of len {}", x),
    }
}

fn values(t: &str, vs: &[String]) -> String {
    if vs.len() == 1 && !t.contains('x') {
        format!(": {} = {}", t, vs[0])
    } else if vs.len() == 1 && type_to_global_type(t) == "f64" {
        format!(": {} = {}", type_to_global_type(t), vs[0])
    } else {
        let s: Vec<_> = t.split('x').collect();
        if s.len() == 3 {
            format!(
                ": [{}; {}] = [{}]",
                type_to_native_type(t),
                type_len(t),
                vs.iter()
                    .map(|v| map_val(type_to_global_type(t), v))
                    //.map(|v| format!("{}{}", v, type_to_native_type(t)))
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        } else {
            format!(
                ": {} = {}::new({})",
                type_to_global_type(t),
                type_to_global_type(t),
                vs.iter()
                    .map(|v| map_val(type_to_global_type(t), v))
                    //.map(|v| format!("{}{}", v, type_to_native_type(t)))
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        }
    }
}

fn max_val(t: &str) -> &'static str {
    match &t[..3] {
        "u8x" => "0xFF",
        "u16" => "0xFF_FF",
        "u32" => "0xFF_FF_FF_FF",
        "u64" => "0xFF_FF_FF_FF_FF_FF_FF_FF",
        "i8x" => "0x7F",
        "i16" => "0x7F_FF",
        "i32" => "0x7F_FF_FF_FF",
        "i64" => "0x7F_FF_FF_FF_FF_FF_FF_FF",
        "f32" => "3.40282347e+38",
        "f64" => "1.7976931348623157e+308",
        _ => panic!("No TRUE for type {}", t),
    }
}

fn min_val(t: &str) -> &'static str {
    match &t[..3] {
        "u8x" => "0",
        "u16" => "0",
        "u32" => "0",
        "u64" => "0",
        "i8x" => "-128",
        "i16" => "-32768",
        "i32" => "-2147483648",
        "i64" => "-9223372036854775808",
        "f32" => "-3.40282347e+38",
        "f64" => "-1.7976931348623157e+308",
        _ => panic!("No TRUE for type {}", t),
    }
}

fn true_val(t: &str) -> &'static str {
    match &t[..3] {
        "u8x" => "0xFF",
        "u16" => "0xFF_FF",
        "u32" => "0xFF_FF_FF_FF",
        "u64" => "0xFF_FF_FF_FF_FF_FF_FF_FF",
        _ => panic!("No TRUE for type {}", t),
    }
}

fn ff_val(t: &str) -> &'static str {
    match &t[..3] {
        "u8x" => "0xFF",
        "u16" => "0xFF_FF",
        "u32" => "0xFF_FF_FF_FF",
        "u64" => "0xFF_FF_FF_FF_FF_FF_FF_FF",
        "i8x" => "0xFF",
        "i16" => "0xFF_FF",
        "i32" => "0xFF_FF_FF_FF",
        "i64" => "0xFF_FF_FF_FF_FF_FF_FF_FF",
        _ => panic!("No TRUE for type {}", t),
    }
}

fn false_val(_t: &str) -> &'static str {
    "0"
}

fn bits(t: &str) -> &'static str {
    match &t[..3] {
        "u8x" => "8",
        "u16" => "16",
        "u32" => "32",
        "u64" => "64",
        "i8x" => "8",
        "i16" => "16",
        "i32" => "32",
        "i64" => "64",
        "p8x" => "8",
        "p16" => "16",
        "p64" => "64",
        _ => panic!("Unknown bits for type {}", t),
    }
}

fn bits_minus_one(t: &str) -> &'static str {
    match &t[..3] {
        "u8x" => "7",
        "u16" => "15",
        "u32" => "31",
        "u64" => "63",
        "i8x" => "7",
        "i16" => "15",
        "i32" => "31",
        "i64" => "63",
        "p8x" => "7",
        "p16" => "15",
        "p64" => "63",
        _ => panic!("Unknown bits for type {}", t),
    }
}

fn half_bits(t: &str) -> &'static str {
    match &t[..3] {
        "u8x" => "4",
        "u16" => "8",
        "u32" => "16",
        "u64" => "32",
        "i8x" => "4",
        "i16" => "8",
        "i32" => "16",
        "i64" => "32",
        "p8x" => "4",
        "p16" => "8",
        "p64" => "32",
        _ => panic!("Unknown bits for type {}", t),
    }
}

fn type_len_str(t: &str) -> &'static str {
    match t {
        "int8x8_t" => "8",
        "int8x16_t" => "16",
        "int16x4_t" => "4",
        "int16x8_t" => "8",
        "int32x2_t" => "2",
        "int32x4_t" => "4",
        "int64x1_t" => "1",
        "int64x2_t" => "2",
        "uint8x8_t" => "8",
        "uint8x16_t" => "16",
        "uint16x4_t" => "4",
        "uint16x8_t" => "8",
        "uint32x2_t" => "2",
        "uint32x4_t" => "4",
        "uint64x1_t" => "1",
        "uint64x2_t" => "2",
        "float16x4_t" => "4",
        "float16x8_t" => "8",
        "float32x2_t" => "2",
        "float32x4_t" => "4",
        "float64x1_t" => "1",
        "float64x2_t" => "2",
        "poly8x8_t" => "8",
        "poly8x16_t" => "16",
        "poly16x4_t" => "4",
        "poly16x8_t" => "8",
        "poly64x1_t" => "1",
        "poly64x2_t" => "2",
        _ => panic!("unknown type: {}", t),
    }
}

fn type_half_len_str(t: &str) -> &'static str {
    match t {
        "int8x8_t" => "4",
        "int8x16_t" => "8",
        "int16x4_t" => "2",
        "int16x8_t" => "4",
        "int32x2_t" => "1",
        "int32x4_t" => "2",
        "int64x1_t" => "0",
        "int64x2_t" => "1",
        "uint8x8_t" => "4",
        "uint8x16_t" => "8",
        "uint16x4_t" => "2",
        "uint16x8_t" => "4",
        "uint32x2_t" => "1",
        "uint32x4_t" => "2",
        "uint64x1_t" => "0",
        "uint64x2_t" => "1",
        "float16x4_t" => "2",
        "float16x8_t" => "4",
        "float32x2_t" => "1",
        "float32x4_t" => "2",
        "float64x1_t" => "0",
        "float64x2_t" => "1",
        "poly8x8_t" => "4",
        "poly8x16_t" => "8",
        "poly16x4_t" => "2",
        "poly16x8_t" => "4",
        "poly64x1_t" => "0",
        "poly64x2_t" => "1",
        _ => panic!("unknown type: {}", t),
    }
}

fn map_val<'v>(t: &str, v: &'v str) -> &'v str {
    match v {
        "FALSE" => false_val(t),
        "TRUE" => true_val(t),
        "MAX" => max_val(t),
        "MIN" => min_val(t),
        "FF" => ff_val(t),
        "BITS" => bits(t),
        "BITS_M1" => bits_minus_one(t),
        "HFBITS" => half_bits(t),
        "LEN" => type_len_str(t),
        "HFLEN" => type_half_len_str(t),
        o => o,
    }
}

fn type_to_ext(t: &str, v: bool, r: bool, pi8: bool) -> String {
    if !t.contains('x') {
        return t.replace("u", "i");
    }
    let native = type_to_native_type(t);
    let sub_ext = match type_sub_len(t) {
        1 => String::new(),
        _ if v => format!(
            ".p0v{}{}",
            &type_len(&type_to_sub_type(t)).to_string(),
            native
        ),
        _ if pi8 => format!(".p0i8"),
        _ => format!(".p0{}", native),
    };
    let sub_type = match &native[0..1] {
        "i" | "f" => native,
        "u" => native.replace("u", "i"),
        _ => panic!("unknown type: {}", t),
    };
    let ext = format!(
        "v{}{}{}",
        &type_len(&type_to_sub_type(t)).to_string(),
        sub_type,
        sub_ext
    );
    if r {
        let ss: Vec<_> = ext.split('.').collect();
        if ss.len() != 2 {
            ext
        } else {
            format!("{}.{}", ss[1], ss[0])
        }
    } else {
        ext
    }
}

fn ext(s: &str, in_t: &[&str; 3], out_t: &str) -> String {
    s.replace("_EXT_", &type_to_ext(in_t[0], false, false, false))
        .replace("_EXT2_", &type_to_ext(out_t, false, false, false))
        .replace("_EXT3_", &type_to_ext(in_t[1], false, false, false))
        .replace("_EXT4_", &type_to_ext(in_t[2], false, false, false))
        .replace("_EXTr3_", &type_to_ext(in_t[1], false, true, false))
        .replace("_EXTv2_", &type_to_ext(out_t, true, false, false))
        .replace("_EXTpi8_", &type_to_ext(in_t[1], false, false, true))
        .replace("_EXTpi82_", &type_to_ext(out_t, false, false, true))
        .replace("_EXTpi8r_", &type_to_ext(in_t[1], false, true, true))
}

fn is_vldx(name: &str) -> bool {
    let s: Vec<_> = name.split('_').collect();
    &name[0..3] == "vld"
        && name[3..4].parse::<i32>().unwrap() > 1
        && (s.last().unwrap().starts_with("s") || s.last().unwrap().starts_with("f"))
}

fn is_vstx(name: &str) -> bool {
    let s: Vec<_> = name.split('_').collect();
    s.len() == 2
        && &name[0..3] == "vst"
        && name[3..4].parse::<i32>().unwrap() > 1
        && (s[1].starts_with("s") || s[1].starts_with("f"))
}

#[allow(clippy::too_many_arguments)]
fn gen_aarch64(
    current_comment: &str,
    current_fn: &Option<String>,
    current_name: &str,
    current_aarch64: &Option<String>,
    link_aarch64: &Option<String>,
    const_aarch64: &Option<String>,
    constn: &Option<String>,
    in_t: &[&str; 3],
    out_t: &str,
    current_tests: &[(
        Vec<String>,
        Vec<String>,
        Vec<String>,
        Option<String>,
        Vec<String>,
    )],
    suffix: Suffix,
    para_num: i32,
    target: TargetFeature,
    fixed: &Vec<String>,
    multi_fn: &Vec<String>,
    fn_type: Fntype,
) -> (String, String) {
    let name = match suffix {
        Normal => format!("{}{}", current_name, type_to_suffix(in_t[1])),
        NoQ => format!("{}{}", current_name, type_to_noq_suffix(in_t[1])),
        Double => format!(
            "{}{}",
            current_name,
            type_to_double_suffixes(out_t, in_t[1])
        ),
        NoQDouble => format!(
            "{}{}",
            current_name,
            type_to_noq_double_suffixes(out_t, in_t[1])
        ),
        NSuffix => format!("{}{}", current_name, type_to_n_suffix(in_t[1])),
        DoubleN => format!(
            "{}{}",
            current_name,
            type_to_double_n_suffixes(out_t, in_t[1])
        ),
        NoQNSuffix => format!("{}{}", current_name, type_to_noq_n_suffix(in_t[1])),
        OutSuffix => format!("{}{}", current_name, type_to_suffix(out_t)),
        OutNSuffix => format!("{}{}", current_name, type_to_n_suffix(out_t)),
        OutNox => format!(
            "{}{}",
            current_name,
            type_to_suffix(&type_to_sub_type(out_t))
        ),
        In1Nox => format!(
            "{}{}",
            current_name,
            type_to_suffix(&type_to_sub_type(in_t[1]))
        ),
        OutDupNox => format!(
            "{}{}",
            current_name,
            type_to_dup_suffix(&type_to_sub_type(out_t))
        ),
        OutLaneNox => format!(
            "{}{}",
            current_name,
            type_to_lane_suffix(&type_to_sub_type(out_t))
        ),
        In1LaneNox => format!(
            "{}{}",
            current_name,
            type_to_lane_suffix(&type_to_sub_type(in_t[1]))
        ),
        Lane => format!(
            "{}{}",
            current_name,
            type_to_lane_suffixes(out_t, in_t[1], false)
        ),
        In2 => format!("{}{}", current_name, type_to_suffix(in_t[2])),
        In2Lane => format!(
            "{}{}",
            current_name,
            type_to_lane_suffixes(out_t, in_t[2], false)
        ),
        OutLane => format!(
            "{}{}",
            current_name,
            type_to_lane_suffixes(out_t, in_t[2], true)
        ),
        Rot => type_to_rot_suffix(current_name, type_to_suffix(out_t)),
        RotLane => type_to_rot_suffix(current_name, &type_to_lane_suffixes(out_t, in_t[2], false)),
    };
    let current_target = match target {
        Default => "neon",
        ArmV7 => "neon",
        Vfp4 => "neon",
        FPArmV8 => "neon",
        AES => "neon,aes",
        FCMA => "neon,fcma",
        Dotprod => "neon,dotprod",
        I8MM => "neon,i8mm",
        SHA3 => "neon,sha3",
        RDM => "rdm",
        SM4 => "neon,sm4",
        FTTS => "neon,frintts",
    };
    let current_fn = if let Some(current_fn) = current_fn.clone() {
        if link_aarch64.is_some() {
            panic!("[{}] Can't specify link and fn at the same time.", name)
        }
        current_fn
    } else if link_aarch64.is_some() {
        format!("{}_", name)
    } else {
        if multi_fn.is_empty() {
            panic!(
                "[{}] Either (multi) fn or link-aarch have to be specified.",
                name
            )
        }
        String::new()
    };
    let current_aarch64 = current_aarch64.clone().unwrap();
    let mut link_t: Vec<String> = vec![
        in_t[0].to_string(),
        in_t[1].to_string(),
        in_t[2].to_string(),
        out_t.to_string(),
    ];
    let mut ext_c = String::new();
    if let Some(mut link_aarch64) = link_aarch64.clone() {
        if link_aarch64.contains(":") {
            let links: Vec<_> = link_aarch64.split(':').map(|v| v.to_string()).collect();
            assert_eq!(links.len(), 5);
            link_aarch64 = links[0].to_string();
            link_t = vec![
                links[1].clone(),
                links[2].clone(),
                links[3].clone(),
                links[4].clone(),
            ];
        }
        let link_aarch64 = if link_aarch64.starts_with("llvm") {
            ext(&link_aarch64, in_t, out_t)
        } else {
            let mut link = String::from("llvm.aarch64.neon.");
            link.push_str(&link_aarch64);
            ext(&link, in_t, out_t)
        };
        let (ext_inputs, ext_output) = {
            if const_aarch64.is_some() {
                if !matches!(fn_type, Fntype::Normal) {
                    let ptr_type = match fn_type {
                        Fntype::Load => "*const i8",
                        Fntype::Store => "*mut i8",
                        _ => panic!("unsupported fn type"),
                    };
                    let sub = type_to_sub_type(in_t[1]);
                    (
                        match type_sub_len(in_t[1]) {
                            1 => format!("a: {}, n: i64, ptr: {}", sub, ptr_type),
                            2 => format!("a: {}, b: {}, n: i64, ptr: {}", sub, sub, ptr_type),
                            3 => format!(
                                "a: {}, b: {}, c: {}, n: i64, ptr: {}",
                                sub, sub, sub, ptr_type
                            ),
                            4 => format!(
                                "a: {}, b: {}, c: {}, d: {}, n: i64, ptr: {}",
                                sub, sub, sub, sub, ptr_type
                            ),
                            _ => panic!("unsupported type: {}", in_t[1]),
                        },
                        if out_t != "void" {
                            format!(" -> {}", out_t)
                        } else {
                            String::new()
                        },
                    )
                } else {
                    (
                        match para_num {
                            1 => format!("a: {}, n: i32", in_t[0]),
                            2 => format!("a: {}, b: {}, n: i32", in_t[0], in_t[1]),
                            3 => format!("a: {}, b: {}, c: {}, n: i32", in_t[0], in_t[1], in_t[2]),
                            _ => unimplemented!("unknown para_num"),
                        },
                        format!(" -> {}", out_t),
                    )
                }
            } else if matches!(fn_type, Fntype::Store) {
                let sub = type_to_sub_type(in_t[1]);
                let ptr_type = if is_vstx(&name) {
                    "i8".to_string()
                } else {
                    type_to_native_type(in_t[1])
                };
                let subs = match type_sub_len(in_t[1]) {
                    1 => format!("a: {}", sub),
                    2 => format!("a: {}, b: {}", sub, sub),
                    3 => format!("a: {}, b: {}, c: {}", sub, sub, sub),
                    4 => format!("a: {}, b: {}, c: {}, d: {}", sub, sub, sub, sub),
                    _ => panic!("unsupported type: {}", in_t[1]),
                };
                (format!("{}, ptr: *mut {}", subs, ptr_type), String::new())
            } else if is_vldx(&name) {
                let ptr_type = if name.contains("dup") {
                    type_to_native_type(out_t)
                } else {
                    type_to_sub_type(out_t)
                };
                (
                    format!("ptr: *const {}", ptr_type),
                    format!(" -> {}", out_t),
                )
            } else {
                (
                    match para_num {
                        1 => format!("a: {}", link_t[0]),
                        2 => format!("a: {}, b: {}", link_t[0], link_t[1]),
                        3 => format!("a: {}, b: {}, c: {}", link_t[0], link_t[1], link_t[2]),
                        _ => unimplemented!("unknown para_num"),
                    },
                    format!(" -> {}", link_t[3]),
                )
            }
        };
        ext_c = format!(
            r#"#[allow(improper_ctypes)]
    extern "unadjusted" {{
        #[cfg_attr(target_arch = "aarch64", link_name = "{}")]
        fn {}({}){};
    }}
    "#,
            link_aarch64, current_fn, ext_inputs, ext_output,
        );
    };
    let const_declare = if let Some(constn) = constn {
        if constn.contains(":") {
            let constns: Vec<_> = constn.split(':').map(|v| v.to_string()).collect();
            assert_eq!(constns.len(), 2);
            format!(r#"<const {}: i32, const {}: i32>"#, constns[0], constns[1])
        } else {
            format!(r#"<const {}: i32>"#, constn)
        }
    } else {
        String::new()
    };
    let multi_calls = if !multi_fn.is_empty() {
        let mut calls = String::new();
        for i in 0..multi_fn.len() {
            if i > 0 {
                calls.push_str("\n    ");
            }
            calls.push_str(&get_call(
                &multi_fn[i],
                current_name,
                &const_declare,
                in_t,
                out_t,
                fixed,
                None,
                true,
            ));
        }
        calls
    } else {
        String::new()
    };
    let const_assert = if let Some(constn) = constn {
        if constn.contains(":") {
            let constns: Vec<_> = constn.split(':').map(|v| v.to_string()).collect();
            let const_test = current_tests[0].3.as_ref().unwrap();
            let const_tests: Vec<_> = const_test.split(':').map(|v| v.to_string()).collect();
            assert_eq!(constns.len(), 2);
            assert_eq!(const_tests.len(), 2);
            format!(
                r#", {} = {}, {} = {}"#,
                constns[0],
                map_val(in_t[1], &const_tests[0]),
                constns[1],
                map_val(in_t[1], &const_tests[1]),
            )
        } else {
            format!(
                r#", {} = {}"#,
                constn,
                map_val(in_t[1], current_tests[0].3.as_ref().unwrap())
            )
        }
    } else {
        String::new()
    };
    let const_legacy = if let Some(constn) = constn {
        if constn.contains(":") {
            format!(
                "\n#[rustc_legacy_const_generics({}, {})]",
                para_num - 1,
                para_num + 1
            )
        } else {
            format!("\n#[rustc_legacy_const_generics({})]", para_num)
        }
    } else {
        String::new()
    };
    let fn_decl = {
        let fn_output = if out_t == "void" {
            String::new()
        } else {
            format!("-> {} ", out_t)
        };
        let fn_inputs = match para_num {
            1 => format!("(a: {})", in_t[0]),
            2 => format!("(a: {}, b: {})", in_t[0], in_t[1]),
            3 => format!("(a: {}, b: {}, c: {})", in_t[0], in_t[1], in_t[2]),
            _ => panic!("unsupported parameter number"),
        };
        format!(
            "pub unsafe fn {}{}{} {}",
            name, const_declare, fn_inputs, fn_output
        )
    };
    let call_params = {
        if let (Some(const_aarch64), Some(_)) = (const_aarch64, link_aarch64) {
            if !matches!(fn_type, Fntype::Normal) {
                let subs = match type_sub_len(in_t[1]) {
                    1 => "b",
                    2 => "b.0, b.1",
                    3 => "b.0, b.1, b.2",
                    4 => "b.0, b.1, b.2, b.3",
                    _ => panic!("unsupported type: {}", in_t[1]),
                };
                format!(
                    r#"{}
    {}{}({}, {} as i64, a as _)"#,
                    multi_calls,
                    ext_c,
                    current_fn,
                    subs,
                    constn.as_deref().unwrap()
                )
            } else {
                match para_num {
                    1 => format!(
                        r#"{}
    {}{}(a, {})"#,
                        multi_calls, ext_c, current_fn, const_aarch64
                    ),
                    2 => format!(
                        r#"{}
    {}{}(a, b, {})"#,
                        multi_calls, ext_c, current_fn, const_aarch64
                    ),
                    _ => String::new(),
                }
            }
        } else if link_aarch64.is_some() && matches!(fn_type, Fntype::Store) {
            let cast = if is_vstx(&name) { " as _" } else { "" };
            match type_sub_len(in_t[1]) {
                1 => format!(r#"{}{}(b, a{})"#, ext_c, current_fn, cast),
                2 => format!(r#"{}{}(b.0, b.1, a{})"#, ext_c, current_fn, cast),
                3 => format!(r#"{}{}(b.0, b.1, b.2, a{})"#, ext_c, current_fn, cast),
                4 => format!(r#"{}{}(b.0, b.1, b.2, b.3, a{})"#, ext_c, current_fn, cast),
                _ => panic!("unsupported type: {}", in_t[1]),
            }
        } else if link_aarch64.is_some() && is_vldx(&name) {
            format!(r#"{}{}(a as _)"#, ext_c, current_fn,)
        } else {
            let trans: [&str; 2] = if link_t[3] != out_t {
                ["transmute(", ")"]
            } else {
                ["", ""]
            };
            match (multi_calls.len(), para_num, fixed.len()) {
                (0, 1, 0) => format!(r#"{}{}{}(a){}"#, ext_c, trans[0], current_fn, trans[1]),
                (0, 1, _) => {
                    let fixed: Vec<String> =
                        fixed.iter().take(type_len(in_t[0])).cloned().collect();
                    format!(
                        r#"let b{};
    {}{}{}(a, transmute(b)){}"#,
                        values(in_t[0], &fixed),
                        ext_c,
                        trans[0],
                        current_fn,
                        trans[1],
                    )
                }
                (0, 2, _) => format!(r#"{}{}{}(a, b){}"#, ext_c, trans[0], current_fn, trans[1],),
                (0, 3, _) => format!(r#"{}{}(a, b, c)"#, ext_c, current_fn,),
                (_, 1, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
                (_, 2, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
                (_, 3, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
                (_, _, _) => String::new(),
            }
        }
    };
    let stable = match target {
        Default | ArmV7 | Vfp4 | FPArmV8 | AES => {
            String::from("\n#[stable(feature = \"neon_intrinsics\", since = \"1.59.0\")]")
        }
        _ => String::new(),
    };
    let function = format!(
        r#"
{}
#[inline]
#[target_feature(enable = "{}")]
#[cfg_attr(test, assert_instr({}{}))]{}{}
{}{{
    {}
}}
"#,
        current_comment,
        current_target,
        current_aarch64,
        const_assert,
        const_legacy,
        stable,
        fn_decl,
        call_params
    );
    let test_target = match target {
        I8MM => "neon,i8mm",
        SM4 => "neon,sm4",
        SHA3 => "neon,sha3",
        FTTS => "neon,frintts",
        _ => "neon",
    };
    let test = match fn_type {
        Fntype::Normal => gen_test(
            &name,
            in_t,
            &out_t,
            current_tests,
            [type_len(in_t[0]), type_len(in_t[1]), type_len(in_t[2])],
            type_len(out_t),
            para_num,
            test_target,
        ),
        Fntype::Load => gen_load_test(&name, in_t, &out_t, current_tests, type_len(out_t)),
        Fntype::Store => gen_store_test(&name, in_t, &out_t, current_tests, type_len(in_t[1])),
    };
    (function, test)
}

fn gen_load_test(
    name: &str,
    in_t: &[&str; 3],
    out_t: &str,
    current_tests: &[(
        Vec<String>,
        Vec<String>,
        Vec<String>,
        Option<String>,
        Vec<String>,
    )],
    type_len: usize,
) -> String {
    let mut test = format!(
        r#"
    #[simd_test(enable = "neon")]
    unsafe fn test_{}() {{"#,
        name,
    );
    for (a, b, _, n, e) in current_tests {
        let a: Vec<String> = a.iter().take(type_len + 1).cloned().collect();
        let e: Vec<String> = e.iter().take(type_len).cloned().collect();
        let has_b = b.len() > 0;
        let has_n = n.is_some();
        let mut input = String::from("[");
        for i in 0..type_len + 1 {
            if i != 0 {
                input.push_str(", ");
            }
            input.push_str(&a[i])
        }
        input.push_str("]");
        let output = |v: &Vec<String>| {
            let mut output = String::from("[");
            for i in 0..type_sub_len(out_t) {
                if i != 0 {
                    output.push_str(", ");
                }
                let sub_len = type_len / type_sub_len(out_t);
                if type_to_global_type(out_t) != "f64" {
                    let mut sub_output = format!("{}::new(", type_to_global_type(out_t));
                    for j in 0..sub_len {
                        if j != 0 {
                            sub_output.push_str(", ");
                        }
                        sub_output.push_str(&v[i * sub_len + j]);
                    }
                    sub_output.push_str(")");
                    output.push_str(&sub_output);
                } else {
                    output.push_str(&v[i]);
                }
            }
            output.push_str("]");
            output
        };
        let input_b = if has_b {
            let b: Vec<String> = b.iter().take(type_len).cloned().collect();
            format!(
                r#"
        let b: [{}; {}] = {};"#,
                type_to_global_type(in_t[1]),
                type_sub_len(in_t[1]),
                output(&b),
            )
        } else {
            String::new()
        };
        let t = format!(
            r#"
        let a: [{}; {}] = {};{}
        let e: [{}; {}] = {};
        let r: [{}; {}] = transmute({}{}(a[1..].as_ptr(){}));
        assert_eq!(r, e);
"#,
            type_to_native_type(out_t),
            type_len + 1,
            input,
            input_b,
            type_to_global_type(out_t),
            type_sub_len(out_t),
            output(&e),
            type_to_global_type(out_t),
            type_sub_len(out_t),
            name,
            if has_n {
                format!("::<{}>", n.as_deref().unwrap())
            } else {
                String::new()
            },
            if has_b { ", transmute(b)" } else { "" },
        );
        test.push_str(&t);
    }
    test.push_str("    }\n");
    test
}

fn gen_store_test(
    name: &str,
    in_t: &[&str; 3],
    _out_t: &str,
    current_tests: &[(
        Vec<String>,
        Vec<String>,
        Vec<String>,
        Option<String>,
        Vec<String>,
    )],
    type_len: usize,
) -> String {
    let mut test = format!(
        r#"
    #[simd_test(enable = "neon")]
    unsafe fn test_{}() {{"#,
        name,
    );
    for (a, _, _, constn, e) in current_tests {
        let a: Vec<String> = a.iter().take(type_len + 1).cloned().collect();
        let e: Vec<String> = e.iter().take(type_len).cloned().collect();
        let mut input = String::from("[");
        for i in 0..type_len + 1 {
            if i != 0 {
                input.push_str(", ");
            }
            input.push_str(&a[i])
        }
        input.push_str("]");
        let mut output = String::from("[");
        for i in 0..type_len {
            if i != 0 {
                output.push_str(", ");
            }
            output.push_str(&e[i])
        }
        output.push_str("]");
        let const_n = constn
            .as_deref()
            .map_or(String::new(), |n| format!("::<{}>", n.to_string()));
        let t = format!(
            r#"
        let a: [{}; {}] = {};
        let e: [{}; {}] = {};
        let mut r: [{}; {}] = [0{}; {}];
        {}{}(r.as_mut_ptr(), core::ptr::read_unaligned(a[1..].as_ptr() as _));
        assert_eq!(r, e);
"#,
            type_to_native_type(in_t[1]),
            type_len + 1,
            input,
            type_to_native_type(in_t[1]),
            type_len,
            output,
            type_to_native_type(in_t[1]),
            type_len,
            type_to_native_type(in_t[1]),
            type_len,
            name,
            const_n,
        );
        test.push_str(&t);
    }
    test.push_str("    }\n");
    test
}

fn gen_test(
    name: &str,
    in_t: &[&str; 3],
    out_t: &str,
    current_tests: &[(
        Vec<String>,
        Vec<String>,
        Vec<String>,
        Option<String>,
        Vec<String>,
    )],
    len_in: [usize; 3],
    len_out: usize,
    para_num: i32,
    target: &str,
) -> String {
    let mut test = format!(
        r#"
    #[simd_test(enable = "{}")]
    unsafe fn test_{}() {{"#,
        target, name,
    );
    for (a, b, c, n, e) in current_tests {
        let a: Vec<String> = a.iter().take(len_in[0]).cloned().collect();
        let b: Vec<String> = b.iter().take(len_in[1]).cloned().collect();
        let c: Vec<String> = c.iter().take(len_in[2]).cloned().collect();
        let e: Vec<String> = e.iter().take(len_out).cloned().collect();
        let const_value = if let Some(constn) = n {
            if constn.contains(":") {
                let constns: Vec<_> = constn.split(':').map(|v| v.to_string()).collect();
                format!(
                    r#"::<{}, {}>"#,
                    map_val(in_t[1], &constns[0]),
                    map_val(in_t[1], &constns[1])
                )
            } else {
                format!(r#"::<{}>"#, map_val(in_t[1], constn))
            }
        } else {
            String::new()
        };
        let r_type = match type_sub_len(out_t) {
            1 => type_to_global_type(out_t).to_string(),
            _ => format!("[{}; {}]", type_to_native_type(out_t), type_len(out_t)),
        };
        let t = {
            match para_num {
                1 => {
                    format!(
                        r#"
        let a{};
        let e{};
        let r: {} = transmute({}{}(transmute(a)));
        assert_eq!(r, e);
"#,
                        values(in_t[0], &a),
                        values(out_t, &e),
                        r_type,
                        name,
                        const_value
                    )
                }
                2 => {
                    format!(
                        r#"
        let a{};
        let b{};
        let e{};
        let r: {} = transmute({}{}(transmute(a), transmute(b)));
        assert_eq!(r, e);
"#,
                        values(in_t[0], &a),
                        values(in_t[1], &b),
                        values(out_t, &e),
                        r_type,
                        name,
                        const_value
                    )
                }
                3 => {
                    format!(
                        r#"
        let a{};
        let b{};
        let c{};
        let e{};
        let r: {} = transmute({}{}(transmute(a), transmute(b), transmute(c)));
        assert_eq!(r, e);
"#,
                        values(in_t[0], &a),
                        values(in_t[1], &b),
                        values(in_t[2], &c),
                        values(out_t, &e),
                        r_type,
                        name,
                        const_value
                    )
                }
                _ => {
                    panic!("no support para_num:{}", para_num.to_string())
                }
            }
        };

        test.push_str(&t);
    }
    test.push_str("    }\n");
    test
}

#[allow(clippy::too_many_arguments)]
fn gen_arm(
    current_comment: &str,
    current_fn: &Option<String>,
    current_name: &str,
    current_arm: &str,
    link_arm: &Option<String>,
    current_aarch64: &Option<String>,
    link_aarch64: &Option<String>,
    const_arm: &Option<String>,
    const_aarch64: &Option<String>,
    constn: &Option<String>,
    in_t: &[&str; 3],
    out_t: &str,
    current_tests: &[(
        Vec<String>,
        Vec<String>,
        Vec<String>,
        Option<String>,
        Vec<String>,
    )],
    suffix: Suffix,
    para_num: i32,
    target: TargetFeature,
    fixed: &Vec<String>,
    multi_fn: &Vec<String>,
    fn_type: Fntype,
    separate: bool,
) -> (String, String) {
    let name = match suffix {
        Normal => format!("{}{}", current_name, type_to_suffix(in_t[1])),
        NoQ => format!("{}{}", current_name, type_to_noq_suffix(in_t[1])),
        Double => format!(
            "{}{}",
            current_name,
            type_to_double_suffixes(out_t, in_t[1])
        ),
        NoQDouble => format!(
            "{}{}",
            current_name,
            type_to_noq_double_suffixes(out_t, in_t[1])
        ),
        NSuffix => format!("{}{}", current_name, type_to_n_suffix(in_t[1])),
        DoubleN => format!(
            "{}{}",
            current_name,
            type_to_double_n_suffixes(out_t, in_t[1])
        ),
        NoQNSuffix => format!("{}{}", current_name, type_to_noq_n_suffix(in_t[1])),
        OutSuffix => format!("{}{}", current_name, type_to_suffix(out_t)),
        OutNSuffix => format!("{}{}", current_name, type_to_n_suffix(out_t)),
        OutNox => format!(
            "{}{}",
            current_name,
            type_to_suffix(&type_to_sub_type(out_t))
        ),
        In1Nox => format!(
            "{}{}",
            current_name,
            type_to_suffix(&type_to_sub_type(in_t[1]))
        ),
        OutDupNox => format!(
            "{}{}",
            current_name,
            type_to_dup_suffix(&type_to_sub_type(out_t))
        ),
        OutLaneNox => format!(
            "{}{}",
            current_name,
            type_to_lane_suffix(&type_to_sub_type(out_t))
        ),
        In1LaneNox => format!(
            "{}{}",
            current_name,
            type_to_lane_suffix(&type_to_sub_type(in_t[1]))
        ),
        Lane => format!(
            "{}{}",
            current_name,
            type_to_lane_suffixes(out_t, in_t[1], false)
        ),
        In2 => format!("{}{}", current_name, type_to_suffix(in_t[2])),
        In2Lane => format!(
            "{}{}",
            current_name,
            type_to_lane_suffixes(out_t, in_t[2], false)
        ),
        OutLane => format!(
            "{}{}",
            current_name,
            type_to_lane_suffixes(out_t, in_t[2], true)
        ),
        Rot => type_to_rot_suffix(current_name, type_to_suffix(out_t)),
        RotLane => type_to_rot_suffix(current_name, &type_to_lane_suffixes(out_t, in_t[2], false)),
    };
    let current_aarch64 = current_aarch64
        .clone()
        .unwrap_or_else(|| current_arm.to_string());
    let current_target_aarch64 = match target {
        Default => "neon",
        ArmV7 => "neon",
        Vfp4 => "neon",
        FPArmV8 => "neon",
        AES => "neon,aes",
        FCMA => "neon,fcma",
        Dotprod => "neon,dotprod",
        I8MM => "neon,i8mm",
        SHA3 => "neon,sha3",
        RDM => "rdm",
        SM4 => "neon,sm4",
        FTTS => "neon,frintts",
    };
    let current_target_arm = match target {
        Default => "v7",
        ArmV7 => "v7",
        Vfp4 => "vfp4",
        FPArmV8 => "fp-armv8,v8",
        AES => "aes,v8",
        FCMA => "v8",    // v8.3a
        Dotprod => "v8", // v8.2a
        I8MM => "v8,i8mm",
        RDM => unreachable!(),
        SM4 => unreachable!(),
        SHA3 => unreachable!(),
        FTTS => unreachable!(),
    };
    let current_fn = if let Some(current_fn) = current_fn.clone() {
        if link_aarch64.is_some() || link_arm.is_some() {
            panic!(
                "[{}] Can't specify link and function at the same time. {} / {:?} / {:?}",
                name, current_fn, link_aarch64, link_arm
            )
        }
        current_fn
    } else if link_aarch64.is_some() || link_arm.is_some() {
        format!("{}_", name)
    } else {
        if multi_fn.is_empty() {
            panic!(
                "[{}] Either fn or link-arm and link-aarch have to be specified.",
                name
            )
        }
        String::new()
    };
    let mut ext_c = String::new();
    let mut ext_c_arm = if multi_fn.is_empty() || link_arm.is_none() {
        String::new()
    } else {
        String::from(
            r#"
    "#,
        )
    };
    let mut ext_c_aarch64 = if multi_fn.is_empty() || link_aarch64.is_none() {
        String::new()
    } else {
        String::from(
            r#"
    "#,
        )
    };
    let mut link_arm_t: Vec<String> = vec![
        in_t[0].to_string(),
        in_t[1].to_string(),
        in_t[2].to_string(),
        out_t.to_string(),
    ];
    let mut link_aarch64_t: Vec<String> = vec![
        in_t[0].to_string(),
        in_t[1].to_string(),
        in_t[2].to_string(),
        out_t.to_string(),
    ];
    if let (Some(mut link_arm), Some(mut link_aarch64)) = (link_arm.clone(), link_aarch64.clone()) {
        if link_arm.contains(":") {
            let links: Vec<_> = link_arm.split(':').map(|v| v.to_string()).collect();
            assert_eq!(links.len(), 5);
            link_arm = links[0].to_string();
            link_arm_t = vec![
                links[1].clone(),
                links[2].clone(),
                links[3].clone(),
                links[4].clone(),
            ];
        }
        if link_aarch64.contains(":") {
            let links: Vec<_> = link_aarch64.split(':').map(|v| v.to_string()).collect();
            assert_eq!(links.len(), 5);
            link_aarch64 = links[0].to_string();
            link_aarch64_t = vec![
                links[1].clone(),
                links[2].clone(),
                links[3].clone(),
                links[4].clone(),
            ];
        }
        let link_arm = if link_arm.starts_with("llvm") {
            ext(&link_arm, in_t, out_t)
        } else {
            let mut link = String::from("llvm.arm.neon.");
            link.push_str(&link_arm);
            ext(&link, in_t, out_t)
        };
        let link_aarch64 = if link_aarch64.starts_with("llvm") {
            ext(&link_aarch64, in_t, out_t)
        } else {
            let mut link = String::from("llvm.aarch64.neon.");
            link.push_str(&link_aarch64);
            ext(&link, in_t, out_t)
        };
        if out_t == link_arm_t[3] && out_t == link_aarch64_t[3] {
            ext_c = format!(
                r#"#[allow(improper_ctypes)]
    extern "unadjusted" {{
        #[cfg_attr(target_arch = "arm", link_name = "{}")]
        #[cfg_attr(target_arch = "aarch64", link_name = "{}")]
        fn {}({}) -> {};
    }}
"#,
                link_arm,
                link_aarch64,
                current_fn,
                match para_num {
                    1 => format!("a: {}", in_t[0]),
                    2 => format!("a: {}, b: {}", in_t[0], in_t[1]),
                    3 => format!("a: {}, b: {}, c: {}", in_t[0], in_t[1], in_t[2]),
                    _ => unimplemented!("unknown para_num"),
                },
                out_t
            );
        };
        let (arm_ext_inputs, arm_ext_output) = {
            if let Some(const_arm) = const_arm {
                if !matches!(fn_type, Fntype::Normal) {
                    let ptr_type = match fn_type {
                        Fntype::Load => "*const i8",
                        Fntype::Store => "*mut i8",
                        _ => panic!("unsupported fn type"),
                    };
                    let sub_type = type_to_sub_type(in_t[1]);
                    let inputs = match type_sub_len(in_t[1]) {
                        1 => format!("a: {}", sub_type),
                        2 => format!("a: {}, b: {}", sub_type, sub_type,),
                        3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
                        4 => format!(
                            "a: {}, b: {}, c: {}, d: {}",
                            sub_type, sub_type, sub_type, sub_type,
                        ),
                        _ => panic!("unknown type: {}", in_t[1]),
                    };
                    let out = if out_t == "void" {
                        String::new()
                    } else {
                        format!(" -> {}", out_t)
                    };
                    (
                        format!("ptr: {}, {}, n: i32, size: i32", ptr_type, inputs),
                        out,
                    )
                } else {
                    let (_, const_type) = if const_arm.contains(":") {
                        let consts: Vec<_> =
                            const_arm.split(':').map(|v| v.trim().to_string()).collect();
                        (consts[0].clone(), consts[1].clone())
                    } else {
                        (
                            const_arm.to_string(),
                            in_t[para_num as usize - 1].to_string(),
                        )
                    };
                    (
                        match para_num {
                            1 => format!("a: {}, n: {}", in_t[0], const_type),
                            2 => format!("a: {}, b: {}, n: {}", in_t[0], in_t[1], const_type),
                            3 => format!(
                                "a: {}, b: {}, c: {}, n: {}",
                                in_t[0], in_t[1], in_t[2], const_type
                            ),
                            _ => unimplemented!("unknown para_num"),
                        },
                        format!(" -> {}", out_t),
                    )
                }
            } else if out_t != link_arm_t[3] {
                (
                    match para_num {
                        1 => format!("a: {}", link_arm_t[0]),
                        2 => format!("a: {}, b: {}", link_arm_t[0], link_arm_t[1]),
                        3 => format!(
                            "a: {}, b: {}, c: {}",
                            link_arm_t[0], link_arm_t[1], link_arm_t[2]
                        ),
                        _ => unimplemented!("unknown para_num"),
                    },
                    format!(" -> {}", link_arm_t[3]),
                )
            } else if matches!(fn_type, Fntype::Store) {
                let sub_type = type_to_sub_type(in_t[1]);
                let inputs = match type_sub_len(in_t[1]) {
                    1 => format!("a: {}", sub_type),
                    2 => format!("a: {}, b: {}", sub_type, sub_type,),
                    3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
                    4 => format!(
                        "a: {}, b: {}, c: {}, d: {}",
                        sub_type, sub_type, sub_type, sub_type,
                    ),
                    _ => panic!("unknown type: {}", in_t[1]),
                };
                let (ptr_type, size) = if is_vstx(&name) {
                    ("i8".to_string(), ", size: i32")
                } else {
                    (type_to_native_type(in_t[1]), "")
                };
                (
                    format!("ptr: *mut {}, {}{}", ptr_type, inputs, size),
                    String::new(),
                )
            } else if is_vldx(&name) {
                (
                    format!("ptr: *const i8, size: i32"),
                    format!(" -> {}", out_t),
                )
            } else {
                (String::new(), String::new())
            }
        };
        ext_c_arm.push_str(&format!(
            r#"#[allow(improper_ctypes)]
    extern "unadjusted" {{
        #[cfg_attr(target_arch = "arm", link_name = "{}")]
        fn {}({}){};
    }}
"#,
            link_arm, current_fn, arm_ext_inputs, arm_ext_output,
        ));
        let (aarch64_ext_inputs, aarch64_ext_output) = {
            if let Some(const_aarch64) = const_aarch64 {
                if !matches!(fn_type, Fntype::Normal) {
                    let ptr_type = match fn_type {
                        Fntype::Load => "*const i8",
                        Fntype::Store => "*mut i8",
                        _ => panic!("unsupported fn type"),
                    };
                    let sub_type = type_to_sub_type(in_t[1]);
                    let mut inputs = match type_sub_len(in_t[1]) {
                        1 => format!("a: {}", sub_type,),
                        2 => format!("a: {}, b: {}", sub_type, sub_type,),
                        3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
                        4 => format!(
                            "a: {}, b: {}, c: {}, d: {}",
                            sub_type, sub_type, sub_type, sub_type,
                        ),
                        _ => panic!("unknown type: {}", in_t[1]),
                    };
                    inputs.push_str(&format!(", n: i64, ptr: {}", ptr_type));
                    let out = if out_t == "void" {
                        String::new()
                    } else {
                        format!(" -> {}", out_t)
                    };
                    (inputs, out)
                } else if const_aarch64.contains("dup-in_len-N as ttn") {
                    (
                        match para_num {
                            1 => format!("a: {}, n: {}", in_t[0], in_t[0]),
                            2 => format!("a: {}, b: {}, n: {}", in_t[0], in_t[1], in_t[1]),
                            3 => format!(
                                "a: {}, b: {}, c: {}, n: {}",
                                in_t[0], in_t[1], in_t[2], in_t[1]
                            ),
                            _ => unimplemented!("unknown para_num"),
                        },
                        format!(" -> {}", out_t),
                    )
                } else {
                    (
                        match para_num {
                            1 => format!("a: {}, n: i32", in_t[0]),
                            2 => format!("a: {}, b: {}, n: i32", in_t[0], in_t[1]),
                            3 => format!("a: {}, b: {}, c: {}, n: i32", in_t[0], in_t[1], in_t[2]),
                            _ => unimplemented!("unknown para_num"),
                        },
                        format!(" -> {}", out_t),
                    )
                }
            } else if out_t != link_aarch64_t[3] {
                (
                    match para_num {
                        1 => format!("a: {}", link_aarch64_t[0]),
                        2 => format!("a: {}, b: {}", link_aarch64_t[0], link_aarch64_t[1]),
                        3 => format!(
                            "a: {}, b: {}, c: {}",
                            link_aarch64_t[0], link_aarch64_t[1], link_aarch64_t[2]
                        ),
                        _ => unimplemented!("unknown para_num"),
                    },
                    format!(" -> {}", link_aarch64_t[3]),
                )
            } else if matches!(fn_type, Fntype::Store) {
                let sub_type = type_to_sub_type(in_t[1]);
                let mut inputs = match type_sub_len(in_t[1]) {
                    1 => format!("a: {}", sub_type,),
                    2 => format!("a: {}, b: {}", sub_type, sub_type,),
                    3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
                    4 => format!(
                        "a: {}, b: {}, c: {}, d: {}",
                        sub_type, sub_type, sub_type, sub_type,
                    ),
                    _ => panic!("unknown type: {}", in_t[1]),
                };
                let ptr_type = if is_vstx(&name) {
                    "i8".to_string()
                } else {
                    type_to_native_type(in_t[1])
                };
                inputs.push_str(&format!(", ptr: *mut {}", ptr_type));
                (inputs, String::new())
            } else if is_vldx(&name) {
                let ptr_type = if name.contains("dup") {
                    type_to_native_type(out_t)
                } else {
                    type_to_sub_type(out_t)
                };
                (
                    format!("ptr: *const {}", ptr_type),
                    format!(" -> {}", out_t),
                )
            } else {
                (String::new(), String::new())
            }
        };
        ext_c_aarch64.push_str(&format!(
            r#"#[allow(improper_ctypes)]
    extern "unadjusted" {{
        #[cfg_attr(target_arch = "aarch64", link_name = "{}")]
        fn {}({}){};
    }}
"#,
            link_aarch64, current_fn, aarch64_ext_inputs, aarch64_ext_output,
        ));
    };
    let const_declare = if let Some(constn) = constn {
        format!(r#"<const {}: i32>"#, constn)
    } else {
        String::new()
    };
    let multi_calls = if !multi_fn.is_empty() {
        let mut calls = String::new();
        for i in 0..multi_fn.len() {
            if i > 0 {
                calls.push_str("\n    ");
            }
            calls.push_str(&get_call(
                &multi_fn[i],
                current_name,
                &const_declare,
                in_t,
                out_t,
                fixed,
                None,
                false,
            ));
        }
        calls
    } else {
        String::new()
    };
    let const_assert = if let Some(constn) = constn {
        format!(
            r#", {} = {}"#,
            constn,
            map_val(in_t[1], current_tests[0].3.as_ref().unwrap())
        )
    } else {
        String::new()
    };
    let const_legacy = if constn.is_some() {
        format!("\n#[rustc_legacy_const_generics({})]", para_num)
    } else {
        String::new()
    };
    let fn_decl = {
        let fn_output = if out_t == "void" {
            String::new()
        } else {
            format!("-> {} ", out_t)
        };
        let fn_inputs = match para_num {
            1 => format!("(a: {})", in_t[0]),
            2 => format!("(a: {}, b: {})", in_t[0], in_t[1]),
            3 => format!("(a: {}, b: {}, c: {})", in_t[0], in_t[1], in_t[2]),
            _ => panic!("unsupported parameter number"),
        };
        format!(
            "pub unsafe fn {}{}{} {}",
            name, const_declare, fn_inputs, fn_output
        )
    };
    let function = if separate {
        let call_arm = {
            let arm_params = if let (Some(const_arm), Some(_)) = (const_arm, link_arm) {
                if !matches!(fn_type, Fntype::Normal) {
                    let subs = match type_sub_len(in_t[1]) {
                        1 => "b",
                        2 => "b.0, b.1",
                        3 => "b.0, b.1, b.2",
                        4 => "b.0, b.1, b.2, b.3",
                        _ => "",
                    };
                    format!(
                        "{}(a as _, {}, {}, {})",
                        current_fn,
                        subs,
                        constn.as_deref().unwrap(),
                        type_bits(&type_to_sub_type(in_t[1])) / 8,
                    )
                } else {
                    let cnt = if const_arm.contains(':') {
                        let consts: Vec<_> =
                            const_arm.split(':').map(|v| v.trim().to_string()).collect();
                        consts[0].clone()
                    } else {
                        let const_arm = const_arm.replace("ttn", &type_to_native_type(in_t[1]));
                        let mut cnt = String::from(in_t[1]);
                        cnt.push_str("(");
                        for i in 0..type_len(in_t[1]) {
                            if i != 0 {
                                cnt.push_str(", ");
                            }
                            cnt.push_str(&const_arm);
                        }
                        cnt.push_str(")");
                        cnt
                    };
                    match para_num {
                        1 => format!("{}(a, {})", current_fn, cnt),
                        2 => format!("{}(a, b, {})", current_fn, cnt),
                        _ => String::new(),
                    }
                }
            } else if out_t != link_arm_t[3] {
                match para_num {
                    1 => format!("transmute({}(a))", current_fn,),
                    2 => format!("transmute({}(transmute(a), transmute(b)))", current_fn,),
                    _ => String::new(),
                }
            } else if matches!(fn_type, Fntype::Store) {
                let (cast, size) = if is_vstx(&name) {
                    (
                        " as _",
                        format!(", {}", type_bits(&type_to_sub_type(in_t[1])) / 8),
                    )
                } else {
                    ("", String::new())
                };
                match type_sub_len(in_t[1]) {
                    1 => format!("{}(a{}, b{})", current_fn, cast, size),
                    2 => format!("{}(a{}, b.0, b.1{})", current_fn, cast, size),
                    3 => format!("{}(a{}, b.0, b.1, b.2{})", current_fn, cast, size),
                    4 => format!("{}(a{}, b.0, b.1, b.2, b.3{})", current_fn, cast, size),
                    _ => String::new(),
                }
            } else if link_arm.is_some() && is_vldx(&name) {
                format!(
                    "{}(a as *const i8, {})",
                    current_fn,
                    type_bits(&type_to_sub_type(out_t)) / 8
                )
            } else {
                String::new()
            };
            format!(
                r#"{}{{
    {}{}{}
}}"#,
                fn_decl, multi_calls, ext_c_arm, arm_params
            )
        };
        let call_aarch64 = {
            let aarch64_params =
                if let (Some(const_aarch64), Some(_)) = (const_aarch64, link_aarch64) {
                    if !matches!(fn_type, Fntype::Normal) {
                        let subs = match type_sub_len(in_t[1]) {
                            1 => "b",
                            2 => "b.0, b.1",
                            3 => "b.0, b.1, b.2",
                            4 => "b.0, b.1, b.2, b.3",
                            _ => "",
                        };
                        format!(
                            "{}({}, {} as i64, a as _)",
                            current_fn,
                            subs,
                            constn.as_deref().unwrap()
                        )
                    } else if const_aarch64.contains("dup-in_len-N as ttn") {
                        let const_aarch64 = format!("N as {}", type_to_native_type(in_t[1]));
                        let mut cnt = String::from(in_t[1]);
                        cnt.push_str("(");
                        for i in 0..type_len(in_t[1]) {
                            if i != 0 {
                                cnt.push_str(", ");
                            }
                            cnt.push_str(&const_aarch64);
                        }
                        cnt.push_str(")");
                        format!("{}(a, {})", current_fn, cnt)
                    } else {
                        match para_num {
                            1 => format!("{}(a, {})", current_fn, const_aarch64),
                            2 => format!("{}(a, b, {})", current_fn, const_aarch64),
                            _ => String::new(),
                        }
                    }
                } else if out_t != link_aarch64_t[3] {
                    match para_num {
                        1 => format!("transmute({}(a))", current_fn,),
                        2 => format!("transmute({}(a, b))", current_fn,),
                        _ => String::new(),
                    }
                } else if matches!(fn_type, Fntype::Store) {
                    let cast = if is_vstx(&name) { " as _" } else { "" };
                    match type_sub_len(in_t[1]) {
                        1 => format!("{}(b, a{})", current_fn, cast),
                        2 => format!("{}(b.0, b.1, a{})", current_fn, cast),
                        3 => format!("{}(b.0, b.1, b.2, a{})", current_fn, cast),
                        4 => format!("{}(b.0, b.1, b.2, b.3, a{})", current_fn, cast),
                        _ => String::new(),
                    }
                } else if link_aarch64.is_some() && is_vldx(&name) {
                    format!("{}(a as _)", current_fn)
                } else {
                    String::new()
                };
            format!(
                r#"{}{{
    {}{}{}
}}"#,
                fn_decl, multi_calls, ext_c_aarch64, aarch64_params
            )
        };
        let stable_aarch64 = match target {
            Default | ArmV7 | Vfp4 | FPArmV8 | AES => {
                String::from("\n#[stable(feature = \"neon_intrinsics\", since = \"1.59.0\")]")
            }
            _ => String::new(),
        };
        format!(
            r#"
{}
#[inline]
#[cfg(target_arch = "arm")]
#[target_feature(enable = "neon,{}")]
#[cfg_attr(test, assert_instr({}{}))]{}
{}

{}
#[inline]
#[cfg(target_arch = "aarch64")]
#[target_feature(enable = "{}")]
#[cfg_attr(test, assert_instr({}{}))]{}{}
{}
"#,
            current_comment,
            current_target_arm,
            expand_intrinsic(&current_arm, in_t[1]),
            const_assert,
            const_legacy,
            call_arm,
            current_comment,
            current_target_aarch64,
            expand_intrinsic(&current_aarch64, in_t[1]),
            const_assert,
            const_legacy,
            stable_aarch64,
            call_aarch64,
        )
    } else {
        let call = {
            let stmts = match (multi_calls.len(), para_num, fixed.len()) {
                (0, 1, 0) => format!(r#"{}{}(a)"#, ext_c, current_fn,),
                (0, 1, _) => {
                    let fixed: Vec<String> =
                        fixed.iter().take(type_len(in_t[0])).cloned().collect();
                    format!(
                        r#"let b{};
    {}{}(a, transmute(b))"#,
                        values(in_t[0], &fixed),
                        ext_c,
                        current_fn,
                    )
                }
                (0, 2, _) => format!(r#"{}{}(a, b)"#, ext_c, current_fn,),
                (0, 3, _) => format!(r#"{}{}(a, b, c)"#, ext_c, current_fn,),
                (_, 1, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
                (_, 2, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
                (_, 3, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
                (_, _, _) => String::new(),
            };
            if stmts != String::new() {
                format!(
                    r#"{}{{
    {}
}}"#,
                    fn_decl, stmts
                )
            } else {
                String::new()
            }
        };
        let stable_aarch64 = match target {
            Default | ArmV7 | Vfp4 | FPArmV8 | AES => String::from("\n#[cfg_attr(target_arch = \"aarch64\", stable(feature = \"neon_intrinsics\", since = \"1.59.0\"))]"),
            _ => String::new(),
        };
        format!(
            r#"
{}
#[inline]
#[target_feature(enable = "{}")]
#[cfg_attr(target_arch = "arm", target_feature(enable = "{}"))]
#[cfg_attr(all(test, target_arch = "arm"), assert_instr({}{}))]
#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr({}{}))]{}{}
{}
"#,
            current_comment,
            current_target_aarch64,
            current_target_arm,
            expand_intrinsic(&current_arm, in_t[1]),
            const_assert,
            expand_intrinsic(&current_aarch64, in_t[1]),
            const_assert,
            const_legacy,
            stable_aarch64,
            call,
        )
    };
    let test_target = match target {
        I8MM => "neon,i8mm",
        SM4 => "neon,sm4",
        SHA3 => "neon,sha3",
        FTTS => "neon,frintts",
        _ => "neon",
    };
    let test = match fn_type {
        Fntype::Normal => gen_test(
            &name,
            in_t,
            &out_t,
            current_tests,
            [type_len(in_t[0]), type_len(in_t[1]), type_len(in_t[2])],
            type_len(out_t),
            para_num,
            test_target,
        ),
        Fntype::Load => gen_load_test(&name, in_t, &out_t, current_tests, type_len(out_t)),
        Fntype::Store => gen_store_test(&name, in_t, &out_t, current_tests, type_len(in_t[1])),
    };
    (function, test)
}

fn expand_intrinsic(intr: &str, t: &str) -> String {
    if intr.ends_with('.') {
        let ext = match t {
            "int8x8_t" => "i8",
            "int8x16_t" => "i8",
            "int16x4_t" => "i16",
            "int16x8_t" => "i16",
            "int32x2_t" => "i32",
            "int32x4_t" => "i32",
            "int64x1_t" => "i64",
            "int64x2_t" => "i64",
            "uint8x8_t" => "i8",
            "uint8x16_t" => "i8",
            "uint16x4_t" => "i16",
            "uint16x8_t" => "i16",
            "uint32x2_t" => "i32",
            "uint32x4_t" => "i32",
            "uint64x1_t" => "i64",
            "uint64x2_t" => "i64",
            "float16x4_t" => "f16",
            "float16x8_t" => "f16",
            "float32x2_t" => "f32",
            "float32x4_t" => "f32",
            "float64x1_t" => "f64",
            "float64x2_t" => "f64",
            "poly8x8_t" => "i8",
            "poly8x16_t" => "i8",
            "poly16x4_t" => "i16",
            "poly16x8_t" => "i16",
            /*
            "poly64x1_t" => "i64x1",
            "poly64x2_t" => "i64x2",
            */
            _ => panic!("unknown type for extension: {}", t),
        };
        format!(r#""{}{}""#, intr, ext)
    } else if intr.ends_with(".s") {
        let ext = match t {
            "int8x8_t" => "s8",
            "int8x16_t" => "s8",
            "int16x4_t" => "s16",
            "int16x8_t" => "s16",
            "int32x2_t" => "s32",
            "int32x4_t" => "s32",
            "int64x1_t" => "s64",
            "int64x2_t" => "s64",
            "uint8x8_t" => "u8",
            "uint8x16_t" => "u8",
            "uint16x4_t" => "u16",
            "uint16x8_t" => "u16",
            "uint32x2_t" => "u32",
            "uint32x4_t" => "u32",
            "uint64x1_t" => "u64",
            "uint64x2_t" => "u64",
            "poly8x8_t" => "p8",
            "poly8x16_t" => "p8",
            "poly16x4_t" => "p16",
            "poly16x8_t" => "p16",
            "float16x4_t" => "f16",
            "float16x8_t" => "f16",
            "float32x2_t" => "f32",
            "float32x4_t" => "f32",
            "float64x1_t" => "f64",
            "float64x2_t" => "f64",
            /*
            "poly64x1_t" => "i64x1",
            "poly64x2_t" => "i64x2",
            */
            _ => panic!("unknown type for extension: {}", t),
        };
        format!(r#""{}{}""#, &intr[..intr.len() - 1], ext)
    } else if intr.ends_with(".l") {
        let ext = match t {
            "int8x8_t" => "8",
            "int8x16_t" => "8",
            "int16x4_t" => "16",
            "int16x8_t" => "16",
            "int32x2_t" => "32",
            "int32x4_t" => "32",
            "int64x1_t" => "64",
            "int64x2_t" => "64",
            "uint8x8_t" => "8",
            "uint8x16_t" => "8",
            "uint16x4_t" => "16",
            "uint16x8_t" => "16",
            "uint32x2_t" => "32",
            "uint32x4_t" => "32",
            "uint64x1_t" => "64",
            "uint64x2_t" => "64",
            "poly8x8_t" => "8",
            "poly8x16_t" => "8",
            "poly16x4_t" => "16",
            "poly16x8_t" => "16",
            "float16x4_t" => "16",
            "float16x8_t" => "16",
            "float32x2_t" => "32",
            "float32x4_t" => "32",
            "float64x1_t" => "64",
            "float64x2_t" => "64",
            "poly64x1_t" => "64",
            "poly64x2_t" => "64",
            _ => panic!("unknown type for extension: {}", t),
        };
        format!(r#""{}{}""#, &intr[..intr.len() - 1], ext)
    } else {
        intr.to_string()
    }
}

fn get_call(
    in_str: &str,
    current_name: &str,
    const_declare: &str,
    in_t: &[&str; 3],
    out_t: &str,
    fixed: &Vec<String>,
    n: Option<i32>,
    aarch64: bool,
) -> String {
    let params: Vec<_> = in_str.split(',').map(|v| v.trim().to_string()).collect();
    assert!(params.len() > 0);
    let mut fn_name = params[0].clone();
    if fn_name == "a" {
        return String::from("a");
    }
    if fn_name == "transpose-1-in_len" {
        return transpose1(type_len(in_t[1])).to_string();
    }
    if fn_name == "transpose-2-in_len" {
        return transpose2(type_len(in_t[1])).to_string();
    }
    if fn_name == "zip-1-in_len" {
        return zip1(type_len(in_t[1])).to_string();
    }
    if fn_name == "zip-2-in_len" {
        return zip2(type_len(in_t[1])).to_string();
    }
    if fn_name == "unzip-1-in_len" {
        return unzip1(type_len(in_t[1])).to_string();
    }
    if fn_name == "unzip-2-in_len" {
        return unzip2(type_len(in_t[1])).to_string();
    }
    if fn_name.starts_with("dup") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        let len = match &*fn_format[1] {
            "out_len" => type_len(out_t),
            "in_len" => type_len(in_t[1]),
            "in0_len" => type_len(in_t[0]),
            "halflen" => type_len(in_t[1]) / 2,
            _ => 0,
        };
        let mut s = format!("{} [", const_declare);
        for i in 0..len {
            if i != 0 {
                s.push_str(", ");
            }
            s.push_str(&fn_format[2]);
        }
        s.push_str("]");
        return s;
    }
    if fn_name.starts_with("asc") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        let start = match &*fn_format[1] {
            "0" => 0,
            "n" => n.unwrap(),
            "out_len" => type_len(out_t) as i32,
            "halflen" => (type_len(in_t[1]) / 2) as i32,
            s => s.parse::<i32>().unwrap(),
        };
        let len = match &*fn_format[2] {
            "out_len" => type_len(out_t),
            "in_len" => type_len(in_t[1]),
            "in0_len" => type_len(in_t[0]),
            "halflen" => type_len(in_t[1]) / 2,
            _ => 0,
        };
        return asc(start, len);
    }
    if fn_name.starts_with("base") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        assert_eq!(fn_format.len(), 3);
        let mut s = format!("<const {}: i32> [", &fn_format[2]);
        let base_len = fn_format[1].parse::<usize>().unwrap();
        for i in 0..type_len(in_t[1]) / base_len {
            for j in 0..base_len {
                if i != 0 || j != 0 {
                    s.push_str(", ");
                }
                s.push_str(&format!("{} * {} as u32", base_len, &fn_format[2]));
                if j != 0 {
                    s.push_str(&format!(" + {}", j));
                }
            }
        }
        s.push_str("]");
        return s;
    }
    if fn_name.starts_with("as") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        assert_eq!(fn_format.len(), 3);
        let t = match &*fn_format[2] {
            "in_ttn" => type_to_native_type(in_t[1]),
            _ => String::new(),
        };
        return format!("{} as {}", &fn_format[1], t);
    }
    if fn_name.starts_with("ins") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        let n = n.unwrap();
        let len = match &*fn_format[1] {
            "out_len" => type_len(out_t),
            "in_len" => type_len(in_t[1]),
            "in0_len" => type_len(in_t[0]),
            _ => 0,
        };
        let offset = match &*fn_format[2] {
            "out_len" => type_len(out_t),
            "in_len" => type_len(in_t[1]),
            "in0_len" => type_len(in_t[0]),
            _ => 0,
        };
        let mut s = format!("{} [", const_declare);
        for i in 0..len {
            if i != 0 {
                s.push_str(", ");
            }
            if i == n as usize {
                s.push_str(&format!("{} + {} as u32", offset.to_string(), fn_format[3]));
            } else {
                s.push_str(&i.to_string());
            }
        }
        s.push_str("]");
        return s;
    }
    if fn_name.starts_with("static_assert_imm") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        let len = match &*fn_format[1] {
            "out_exp_len" => type_exp_len(out_t, 1),
            "out_bits_exp_len" => type_bits_exp_len(out_t),
            "in_exp_len" => type_exp_len(in_t[1], 1),
            "in_bits_exp_len" => type_bits_exp_len(in_t[1]),
            "in0_exp_len" => type_exp_len(in_t[0], 1),
            "in1_exp_len" => type_exp_len(in_t[1], 1),
            "in2_exp_len" => type_exp_len(in_t[2], 1),
            "in2_rot" => type_exp_len(in_t[2], 2),
            "in2_dot" => type_exp_len(in_t[2], 4),
            _ => 0,
        };
        if len == 0 {
            return format!(
                r#"static_assert!({} : i32 where {} == 0);"#,
                fn_format[2], fn_format[2]
            );
        } else {
            return format!(r#"static_assert_imm{}!({});"#, len, fn_format[2]);
        }
    }
    if fn_name.starts_with("static_assert") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        let lim1 = if fn_format[2] == "bits" {
            type_bits(in_t[1]).to_string()
        } else if fn_format[2] == "halfbits" {
            (type_bits(in_t[1]) / 2).to_string()
        } else {
            fn_format[2].clone()
        };
        let lim2 = if fn_format[3] == "bits" {
            type_bits(in_t[1]).to_string()
        } else if fn_format[3] == "halfbits" {
            (type_bits(in_t[1]) / 2).to_string()
        } else {
            fn_format[3].clone()
        };
        if lim1 == lim2 {
            return format!(
                r#"static_assert!({} : i32 where {} == {});"#,
                fn_format[1], fn_format[1], lim1
            );
        } else {
            return format!(
                r#"static_assert!({} : i32 where {} >= {} && {} <= {});"#,
                fn_format[1], fn_format[1], lim1, fn_format[1], lim2
            );
        }
    }
    if fn_name.starts_with("fix_right_shift_imm") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        let lim = if fn_format[2] == "bits" {
            type_bits(in_t[1]).to_string()
        } else {
            fn_format[2].clone()
        };
        let fixed = if in_t[1].starts_with('u') {
            format!("return vdup{nself}(0);", nself = type_to_n_suffix(in_t[1]))
        } else {
            (lim.parse::<i32>().unwrap() - 1).to_string()
        };

        return format!(
            r#"let {name}: i32 = if {const_name} == {upper} {{ {fixed} }} else {{ N }};"#,
            name = fn_format[1].to_lowercase(),
            const_name = fn_format[1],
            upper = lim,
            fixed = fixed,
        );
    }

    if fn_name.starts_with("matchn") {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        let len = match &*fn_format[1] {
            "out_exp_len" => type_exp_len(out_t, 1),
            "in_exp_len" => type_exp_len(in_t[1], 1),
            "in0_exp_len" => type_exp_len(in_t[0], 1),
            _ => 0,
        };
        let mut call = format!("match {} & 0b{} {{\n", &fn_format[2], "1".repeat(len));
        let mut sub_call = String::new();
        for p in 1..params.len() {
            if !sub_call.is_empty() {
                sub_call.push_str(", ");
            }
            sub_call.push_str(&params[p]);
        }
        for i in 0..(2u32.pow(len as u32) as usize) {
            let sub_match = format!(
                "        {} => {},\n",
                i,
                get_call(
                    &sub_call,
                    current_name,
                    const_declare,
                    in_t,
                    out_t,
                    fixed,
                    Some(i as i32),
                    aarch64
                )
            );
            call.push_str(&sub_match);
        }
        call.push_str("        _ => unreachable_unchecked(),\n    }");
        return call;
    }
    let mut re: Option<(String, String)> = None;
    let mut param_str = String::new();
    let mut i = 1;
    while i < params.len() {
        let s = &params[i];
        if s.starts_with('{') {
            let mut sub_fn = String::new();
            let mut parentheses = 0;
            while i < params.len() {
                if !sub_fn.is_empty() {
                    sub_fn.push_str(", ");
                }
                sub_fn.push_str(&params[i]);
                let l = params[i].len();
                for j in 0..l {
                    if &params[i][j..j + 1] == "{" {
                        parentheses += 1;
                    } else {
                        break;
                    }
                }
                for j in 0..l {
                    if &params[i][l - j - 1..l - j] == "}" {
                        parentheses -= 1;
                    } else {
                        break;
                    }
                }
                if parentheses == 0 {
                    break;
                }
                i += 1;
            }
            let sub_call = get_call(
                &sub_fn[1..sub_fn.len() - 1],
                current_name,
                const_declare,
                in_t,
                out_t,
                fixed,
                n.clone(),
                aarch64,
            );
            if !param_str.is_empty() {
                param_str.push_str(", ");
            }
            param_str.push_str(&sub_call);
        } else if s.contains(':') {
            let re_params: Vec<_> = s.split(':').map(|v| v.to_string()).collect();
            if re_params[1] == "" {
                re = Some((re_params[0].clone(), in_t[1].to_string()));
            } else if re_params[1] == "in_t" {
                re = Some((re_params[0].clone(), in_t[1].to_string()));
            } else if re_params[1] == "signed" {
                re = Some((re_params[0].clone(), type_to_signed(in_t[1])));
            } else if re_params[1] == "unsigned" {
                re = Some((re_params[0].clone(), type_to_unsigned(in_t[1])));
            } else if re_params[1] == "in_t0" {
                re = Some((re_params[0].clone(), in_t[0].to_string()));
            } else if re_params[1] == "in_t1" {
                re = Some((re_params[0].clone(), in_t[1].to_string()));
            } else if re_params[1] == "out_t" {
                re = Some((re_params[0].clone(), out_t.to_string()));
            } else if re_params[1] == "half" {
                re = Some((re_params[0].clone(), type_to_half(in_t[1]).to_string()));
            } else if re_params[1] == "in_ntt" {
                re = Some((
                    re_params[0].clone(),
                    native_type_to_type(in_t[1]).to_string(),
                ));
            } else if re_params[1] == "in_long_ntt" {
                re = Some((
                    re_params[0].clone(),
                    native_type_to_long_type(in_t[1]).to_string(),
                ));
            } else if re_params[1] == "out_ntt" {
                re = Some((re_params[0].clone(), native_type_to_type(out_t).to_string()));
            } else if re_params[1] == "out_long_ntt" {
                re = Some((
                    re_params[0].clone(),
                    native_type_to_long_type(out_t).to_string(),
                ));
            } else {
                re = Some((re_params[0].clone(), re_params[1].clone()));
            }
        } else {
            if !param_str.is_empty() {
                param_str.push_str(", ");
            }
            param_str.push_str(s);
        }
        i += 1;
    }
    if fn_name == "fixed" {
        let (re_name, re_type) = re.unwrap();
        let fixed: Vec<String> = fixed.iter().take(type_len(in_t[1])).cloned().collect();
        return format!(r#"let {}{};"#, re_name, values(&re_type, &fixed));
    }
    if fn_name == "fixed-half-right" {
        let fixed: Vec<String> = fixed.iter().take(type_len(in_t[1])).cloned().collect();
        let half = fixed[type_len(in_t[1]) / 2..]
            .iter()
            .fold(String::new(), |mut s, fix| {
                s.push_str(fix);
                s.push_str(", ");
                s
            });
        return format!(r#"[{}]"#, &half[..half.len() - 2]);
    }
    if fn_name == "a - b" {
        return fn_name;
    }
    if fn_name == "-a" {
        return fn_name;
    }
    if fn_name.contains('-') {
        let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
        assert_eq!(fn_format.len(), 3);
        fn_name = if fn_format[0] == "self" {
            current_name.to_string()
        } else {
            fn_format[0].clone()
        };
        if fn_format[1] == "self" {
            fn_name.push_str(type_to_suffix(in_t[1]));
        } else if fn_format[1] == "nself" {
            fn_name.push_str(type_to_n_suffix(in_t[1]));
        } else if fn_format[1] == "nselfvfp4" {
            fn_name.push_str(type_to_n_suffix(in_t[1]));
            if !aarch64 {
                fn_name.push_str("_vfp4");
            }
        } else if fn_format[1] == "out" {
            fn_name.push_str(type_to_suffix(out_t));
        } else if fn_format[1] == "in0" {
            fn_name.push_str(type_to_suffix(in_t[0]));
        } else if fn_format[1] == "in2" {
            fn_name.push_str(type_to_suffix(in_t[2]));
        } else if fn_format[1] == "in2lane" {
            fn_name.push_str(&type_to_lane_suffixes(out_t, in_t[2], false));
        } else if fn_format[1] == "outlane" {
            fn_name.push_str(&type_to_lane_suffixes(out_t, in_t[2], true));
        } else if fn_format[1] == "signed" {
            fn_name.push_str(type_to_suffix(&type_to_signed(&String::from(in_t[1]))));
        } else if fn_format[1] == "outsigned" {
            fn_name.push_str(type_to_suffix(&type_to_signed(&String::from(out_t))));
        } else if fn_format[1] == "outsignednox" {
            fn_name.push_str(&type_to_suffix(&type_to_sub_type(&type_to_signed(
                &String::from(out_t),
            ))));
        } else if fn_format[1] == "in1signednox" {
            fn_name.push_str(&type_to_suffix(&type_to_sub_type(&type_to_signed(
                &String::from(in_t[1]),
            ))));
        } else if fn_format[1] == "outsigneddupnox" {
            fn_name.push_str(&type_to_dup_suffix(&type_to_sub_type(&type_to_signed(
                &String::from(out_t),
            ))));
        } else if fn_format[1] == "outsignedlanenox" {
            fn_name.push_str(&type_to_lane_suffix(&type_to_sub_type(&type_to_signed(
                &String::from(out_t),
            ))));
        } else if fn_format[1] == "in1signedlanenox" {
            fn_name.push_str(&type_to_lane_suffix(&type_to_sub_type(&type_to_signed(
                &String::from(in_t[1]),
            ))));
        } else if fn_format[1] == "unsigned" {
            fn_name.push_str(type_to_suffix(&type_to_unsigned(in_t[1])));
        } else if fn_format[1] == "doubleself" {
            fn_name.push_str(&type_to_double_suffixes(out_t, in_t[1]));
        } else if fn_format[1] == "noq_doubleself" {
            fn_name.push_str(&type_to_noq_double_suffixes(out_t, in_t[1]));
        } else if fn_format[1] == "noqself" {
            fn_name.push_str(type_to_noq_suffix(in_t[1]));
        } else if fn_format[1] == "noqsigned" {
            fn_name.push_str(type_to_noq_suffix(&type_to_signed(&String::from(in_t[1]))));
        } else if fn_format[1] == "nosuffix" {
        } else if fn_format[1] == "in_len" {
            fn_name.push_str(&type_len(in_t[1]).to_string());
        } else if fn_format[1] == "in0_len" {
            fn_name.push_str(&type_len(in_t[0]).to_string());
        } else if fn_format[1] == "out_len" {
            fn_name.push_str(&type_len(out_t).to_string());
        } else if fn_format[1] == "halflen" {
            fn_name.push_str(&(type_len(in_t[1]) / 2).to_string());
        } else if fn_format[1] == "nout" {
            fn_name.push_str(type_to_n_suffix(out_t));
        } else if fn_format[1] == "nin0" {
            fn_name.push_str(type_to_n_suffix(in_t[0]));
        } else if fn_format[1] == "nsigned" {
            fn_name.push_str(type_to_n_suffix(&type_to_signed(&String::from(in_t[1]))));
        } else if fn_format[1] == "in_ntt" {
            fn_name.push_str(type_to_suffix(native_type_to_type(in_t[1])));
        } else if fn_format[1] == "out_ntt" {
            fn_name.push_str(type_to_suffix(native_type_to_type(out_t)));
        } else if fn_format[1] == "rot" {
            fn_name = type_to_rot_suffix(&fn_name, type_to_suffix(out_t));
        } else {
            fn_name.push_str(&fn_format[1]);
        };
        if fn_format[2] == "ext" {
            fn_name.push_str("_");
        } else if fn_format[2] == "noext" {
        } else if fn_format[2].starts_with("<") {
            assert!(fn_format[2].ends_with(">"));
            let types: Vec<_> = fn_format[2][1..fn_format[2].len() - 1]
                .split(' ')
                .map(|v| v.to_string())
                .collect();
            assert_eq!(types.len(), 2);
            let type1 = if types[0] == "element_t" {
                type_to_native_type(in_t[1])
            } else {
                String::from(&types[0])
            };
            let type2 = if types[1] == "element_t" {
                type_to_native_type(in_t[1])
            } else {
                String::from(&types[1])
            };
            fn_name.push_str(&format!("::<{}, {}>", &type1, &type2));
        } else {
            fn_name.push_str(&fn_format[2]);
        }
    }
    if param_str.is_empty() {
        return fn_name.replace("out_t", out_t);
    }
    let fn_str = if let Some((re_name, re_type)) = re.clone() {
        format!(
            r#"let {}: {} = {}({});"#,
            re_name, re_type, fn_name, param_str
        )
    } else if fn_name.starts_with("*") {
        format!(r#"{} = {};"#, fn_name, param_str)
    } else {
        format!(r#"{}({})"#, fn_name, param_str)
    };
    return fn_str;
}

fn main() -> io::Result<()> {
    let args: Vec<String> = env::args().collect();
    let in_file = args.get(1).cloned().unwrap_or_else(|| IN.to_string());

    let f = File::open(in_file).expect("Failed to open neon.spec");
    let f = BufReader::new(f);

    let mut current_comment = String::new();
    let mut current_name: Option<String> = None;
    let mut current_fn: Option<String> = None;
    let mut current_arm: Option<String> = None;
    let mut current_aarch64: Option<String> = None;
    let mut link_arm: Option<String> = None;
    let mut link_aarch64: Option<String> = None;
    let mut const_arm: Option<String> = None;
    let mut const_aarch64: Option<String> = None;
    let mut constn: Option<String> = None;
    let mut para_num = 2;
    let mut suffix: Suffix = Normal;
    let mut a: Vec<String> = Vec::new();
    let mut b: Vec<String> = Vec::new();
    let mut c: Vec<String> = Vec::new();
    let mut n: Option<String> = None;
    let mut fixed: Vec<String> = Vec::new();
    let mut current_tests: Vec<(
        Vec<String>,
        Vec<String>,
        Vec<String>,
        Option<String>,
        Vec<String>,
    )> = Vec::new();
    let mut multi_fn: Vec<String> = Vec::new();
    let mut target: TargetFeature = Default;
    let mut fn_type: Fntype = Fntype::Normal;
    let mut separate = false;

    //
    // THIS FILE IS GENERATED FORM neon.spec DO NOT CHANGE IT MANUALLY
    //
    let mut out_arm = String::from(
        r#"// This code is automatically generated. DO NOT MODIFY.
//
// Instead, modify `crates/stdarch-gen/neon.spec` and run the following command to re-generate this file:
//
// ```
// OUT_DIR=`pwd`/crates/core_arch cargo run -p stdarch-gen -- crates/stdarch-gen/neon.spec
// ```
use super::*;
#[cfg(test)]
use stdarch_test::assert_instr;
"#,
    );
    let mut tests_arm = String::from(
        r#"
#[cfg(test)]
#[allow(overflowing_literals)]
mod test {
    use super::*;
    use crate::core_arch::simd::*;
    use std::mem::transmute;
    use stdarch_test::simd_test;
"#,
    );
    //
    // THIS FILE IS GENERATED FORM neon.spec DO NOT CHANGE IT MANUALLY
    //
    let mut out_aarch64 = String::from(
        r#"// This code is automatically generated. DO NOT MODIFY.
//
// Instead, modify `crates/stdarch-gen/neon.spec` and run the following command to re-generate this file:
//
// ```
// OUT_DIR=`pwd`/crates/core_arch cargo run -p stdarch-gen -- crates/stdarch-gen/neon.spec
// ```
use super::*;
#[cfg(test)]
use stdarch_test::assert_instr;
"#,
    );
    let mut tests_aarch64 = String::from(
        r#"
#[cfg(test)]
mod test {
    use super::*;
    use crate::core_arch::simd::*;
    use std::mem::transmute;
    use stdarch_test::simd_test;
"#,
    );

    for line in f.lines() {
        let line = line.unwrap();
        if line.is_empty() {
            continue;
        }
        if line.starts_with("/// ") {
            current_comment = line;
            current_name = None;
            current_fn = None;
            current_arm = None;
            current_aarch64 = None;
            link_aarch64 = None;
            link_arm = None;
            const_aarch64 = None;
            const_arm = None;
            current_tests = Vec::new();
            constn = None;
            para_num = 2;
            suffix = Normal;
            a = Vec::new();
            b = Vec::new();
            c = Vec::new();
            fixed = Vec::new();
            n = None;
            multi_fn = Vec::new();
            target = Default;
            fn_type = Fntype::Normal;
            separate = false;
        } else if line.starts_with("//") {
        } else if line.starts_with("name = ") {
            current_name = Some(String::from(&line[7..]));
        } else if line.starts_with("fn = ") {
            current_fn = Some(String::from(&line[5..]));
        } else if line.starts_with("multi_fn = ") {
            multi_fn.push(String::from(&line[11..]));
        } else if line.starts_with("constn = ") {
            constn = Some(String::from(&line[9..]));
        } else if line.starts_with("arm = ") {
            current_arm = Some(String::from(&line[6..]));
        } else if line.starts_with("aarch64 = ") {
            current_aarch64 = Some(String::from(&line[10..]));
        } else if line.starts_with("double-suffixes") {
            suffix = Double;
        } else if line.starts_with("no-q") {
            suffix = NoQ;
        } else if line.starts_with("noq-double-suffixes") {
            suffix = NoQDouble;
        } else if line.starts_with("n-suffix") {
            suffix = NSuffix;
        } else if line.starts_with("double-n-suffixes") {
            suffix = DoubleN;
        } else if line.starts_with("out-n-suffix") {
            suffix = OutNSuffix;
        } else if line.starts_with("noq-n-suffix") {
            suffix = NoQNSuffix;
        } else if line.starts_with("out-suffix") {
            suffix = OutSuffix;
        } else if line.starts_with("out-nox") {
            suffix = OutNox;
        } else if line.starts_with("in1-nox") {
            suffix = In1Nox;
        } else if line.starts_with("out-dup-nox") {
            suffix = OutDupNox;
        } else if line.starts_with("out-lane-nox") {
            suffix = OutLaneNox;
        } else if line.starts_with("in1-lane-nox") {
            suffix = In1LaneNox;
        } else if line.starts_with("lane-suffixes") {
            suffix = Lane;
        } else if line.starts_with("in2-suffix") {
            suffix = In2;
        } else if line.starts_with("in2-lane-suffixes") {
            suffix = In2Lane;
        } else if line.starts_with("out-lane-suffixes") {
            suffix = OutLane;
        } else if line.starts_with("rot-suffix") {
            suffix = Rot;
        } else if line.starts_with("rot-lane-suffixes") {
            suffix = RotLane;
        } else if line.starts_with("a = ") {
            a = line[4..].split(',').map(|v| v.trim().to_string()).collect();
        } else if line.starts_with("b = ") {
            b = line[4..].split(',').map(|v| v.trim().to_string()).collect();
        } else if line.starts_with("c = ") {
            c = line[4..].split(',').map(|v| v.trim().to_string()).collect();
        } else if line.starts_with("n = ") {
            n = Some(String::from(&line[4..]));
        } else if line.starts_with("fixed = ") {
            fixed = line[8..].split(',').map(|v| v.trim().to_string()).collect();
        } else if line.starts_with("validate ") {
            let e = line[9..].split(',').map(|v| v.trim().to_string()).collect();
            current_tests.push((a.clone(), b.clone(), c.clone(), n.clone(), e));
        } else if line.starts_with("link-aarch64 = ") {
            link_aarch64 = Some(String::from(&line[15..]));
        } else if line.starts_with("const-aarch64 = ") {
            const_aarch64 = Some(String::from(&line[16..]));
        } else if line.starts_with("link-arm = ") {
            link_arm = Some(String::from(&line[11..]));
        } else if line.starts_with("const-arm = ") {
            const_arm = Some(String::from(&line[12..]));
        } else if line.starts_with("load_fn") {
            fn_type = Fntype::Load;
        } else if line.starts_with("store_fn") {
            fn_type = Fntype::Store;
        } else if line.starts_with("arm-aarch64-separate") {
            separate = true;
        } else if line.starts_with("target = ") {
            target = match Some(String::from(&line[9..])) {
                Some(input) => match input.as_str() {
                    "v7" => ArmV7,
                    "vfp4" => Vfp4,
                    "fp-armv8" => FPArmV8,
                    "aes" => AES,
                    "fcma" => FCMA,
                    "dotprod" => Dotprod,
                    "i8mm" => I8MM,
                    "sha3" => SHA3,
                    "rdm" => RDM,
                    "sm4" => SM4,
                    "frintts" => FTTS,
                    _ => Default,
                },
                _ => Default,
            }
        } else if line.starts_with("generate ") {
            let line = &line[9..];
            let types: Vec<String> = line
                .split(',')
                .map(|v| v.trim().to_string())
                .flat_map(|v| match v.as_str() {
                    "uint*_t" => UINT_TYPES.iter().map(|v| v.to_string()).collect(),
                    "uint64x*_t" => UINT_TYPES_64.iter().map(|v| v.to_string()).collect(),
                    "int*_t" => INT_TYPES.iter().map(|v| v.to_string()).collect(),
                    "int64x*_t" => INT_TYPES_64.iter().map(|v| v.to_string()).collect(),
                    "float*_t" => FLOAT_TYPES.iter().map(|v| v.to_string()).collect(),
                    "float64x*_t" => FLOAT_TYPES_64.iter().map(|v| v.to_string()).collect(),
                    _ => vec![v],
                })
                .collect();

            for line in types {
                let spec: Vec<&str> = line.split(':').map(|e| e.trim()).collect();
                let in_t: [&str; 3];
                let out_t;
                if spec.len() == 1 {
                    in_t = [spec[0], spec[0], spec[0]];
                    out_t = spec[0];
                } else if spec.len() == 2 {
                    in_t = [spec[0], spec[0], spec[0]];
                    out_t = spec[1];
                } else if spec.len() == 3 {
                    in_t = [spec[0], spec[1], spec[1]];
                    out_t = spec[2];
                } else if spec.len() == 4 {
                    in_t = [spec[0], spec[1], spec[2]];
                    out_t = spec[3];
                } else {
                    panic!("Bad spec: {}", line)
                }
                if b.len() == 0 {
                    if matches!(fn_type, Fntype::Store) {
                        para_num = 2;
                    } else {
                        para_num = 1;
                    }
                } else if c.len() != 0 {
                    para_num = 3;
                }
                let current_name = current_name.clone().unwrap();
                if let Some(current_arm) = current_arm.clone() {
                    let (function, test) = gen_arm(
                        &current_comment,
                        &current_fn,
                        &current_name,
                        &current_arm,
                        &link_arm,
                        &current_aarch64,
                        &link_aarch64,
                        &const_arm,
                        &const_aarch64,
                        &constn,
                        &in_t,
                        &out_t,
                        &current_tests,
                        suffix,
                        para_num,
                        target,
                        &fixed,
                        &multi_fn,
                        fn_type,
                        separate,
                    );
                    out_arm.push_str(&function);
                    tests_arm.push_str(&test);
                } else {
                    let (function, test) = gen_aarch64(
                        &current_comment,
                        &current_fn,
                        &current_name,
                        &current_aarch64,
                        &link_aarch64,
                        &const_aarch64,
                        &constn,
                        &in_t,
                        &out_t,
                        &current_tests,
                        suffix,
                        para_num,
                        target,
                        &fixed,
                        &multi_fn,
                        fn_type,
                    );
                    out_aarch64.push_str(&function);
                    tests_aarch64.push_str(&test);
                }
            }
        }
    }
    tests_arm.push('}');
    tests_arm.push('\n');
    tests_aarch64.push('}');
    tests_aarch64.push('\n');

    let arm_out_path: PathBuf =
        PathBuf::from(env::var("OUT_DIR").unwrap_or("crates/core_arch".to_string()))
            .join("src")
            .join("arm_shared")
            .join("neon");
    std::fs::create_dir_all(&arm_out_path)?;

    let mut file_arm = File::create(arm_out_path.join(ARM_OUT))?;
    file_arm.write_all(out_arm.as_bytes())?;
    file_arm.write_all(tests_arm.as_bytes())?;

    let aarch64_out_path: PathBuf =
        PathBuf::from(env::var("OUT_DIR").unwrap_or("crates/core_arch".to_string()))
            .join("src")
            .join("aarch64")
            .join("neon");
    std::fs::create_dir_all(&aarch64_out_path)?;

    let mut file_aarch = File::create(aarch64_out_path.join(AARCH64_OUT))?;
    file_aarch.write_all(out_aarch64.as_bytes())?;
    file_aarch.write_all(tests_aarch64.as_bytes())?;
    /*
    if let Err(e) = Command::new("rustfmt")
        .arg(&arm_out_path)
        .arg(&aarch64_out_path)
        .status() {
            eprintln!("Could not format `{}`: {}", arm_out_path.to_str().unwrap(), e);
            eprintln!("Could not format `{}`: {}", aarch64_out_path.to_str().unwrap(), e);
    };
    */
    Ok(())
}
