content: [package]
  name = "mech-interpreter"
  version = "0.2.60"
  authors = ["Corey Montella <corey@mech-lang.org>"]
  description = "The Mech language runtime."
  documentation = "http://docs.mech-lang.org"
  homepage = "https://mech-lang.org"
  repository = "https://github.com/mech-lang/mech"
  keywords = ["mech", "language", "programming", "dataflow", "runtime"]
  categories = ["no-std", "science::robotics", "science", "game-engines", "database-implementations"]
  license = "Apache-2.0"
  readme = "README.md"
  edition = "2021"
  rust-version = "1.88"
  
  [badges]
  gitlab = { repository = "mech-lang/mech", branch = "main" }
  maintenance = { status = "actively-developed" }
  
  [[bin]]
  name = "interpreter"
  path = "bin/interpreter.rs"
  
  [features]
  no_std = ["mech-core/no_std", "mech-math/no_std", "mech-compare/no_std", "mech-combinatorics/no_std", "mech-logic/no_std", "mech-matrix/no_std", "mech-io/no_std", "mech-stats/no_std", "mech-range/no_std"]
  
  default = ["baselib", "pretty_print", "serde", "compiler", "program",
    "u8", "u16", "u32", "u64", "u128", 
    "i8", "i16", "i32", "i64", "i128", 
    "f32", "f64", "c64", "r64", 
    "math_default", "compare_default", "combinatorics_default", "logic_default",
    "matrix_default", "io_default", "range_default", "stats_default",
    "statements_default", "subscript_default",
    "mech-core/default",
    "mech-math/default", "mech-compare/default", "mech-combinatorics/default", "mech-logic/default", "mech-matrix/default", "mech-io/default", "mech-stats/default", "mech-range/default",
    ]
  base = ["baselib", "pretty_print", "serde", "compiler", "program",
        "math_default", "compare_default", "combinatorics_default", "logic_default",
        "matrix_default", "io_default", "range_default", "stats_default",
        "statements_default", "subscript_default",
        "mech-core/base", "mech-math/base", "mech-compare/base", "mech-combinatorics/base", "mech-logic/base", "mech-matrix/base", "mech-io/base", "mech-stats/base", "mech-range/base",
        ]    
    
  statements_default = ["variable_assign","variable_define","kind_define",
      "mech-core/statements_default", "mech-math/statements_default", "mech-compare/statements_default", "mech-combinatorics/statements_default", "mech-logic/statements_default", "mech-matrix/statements_default", "mech-io/statements_default", "mech-stats/statements_default", "mech-range/statements_default"]
  subscript_default = ["subscript_slice", "subscript_range", "logical_indexing", "swizzle", "subscript_formula", "dot_indexing",
      "mech-core/subscript_default", "mech-math/subscript_default", "mech-compare/subscript_default", "mech-combinatorics/subscript_default", "mech-logic/subscript_default", "mech-matrix/subscript_default", "mech-io/subscript_default", "mech-stats/subscript_default", "mech-range/subscript_default"]
  
  stdlib = ["bool", "string", 
    "u8", "u16", "u32", "u64", "u128", 
    "i8", "i16", "i32", "i64", "i128", 
    "f32", "f64", "c64", "r64", 
    "set", "map", "table", "tuple", "record", "atom",
    "matrix1", "matrix2", "matrix3", "matrix4", "matrix2x3", "matrix3x2",
    "row_vector2", "row_vector3", "row_vector4",
    "vector2", "vector3", "vector4",
    "row_vectord", "vectord", "matrixd",
    "subscript_range", "logical_indexing", "swizzle",
    "subscript_formula", "dot_indexing",
    "variable_define", "variable_assign", "kind_define",
    "kind_annotation", "variables",
    "functions", "formulas",
    "access", "assign", "convert",
    "mech-core/stdlib", "mech-math/stdlib", "mech-compare/stdlib", "mech-combinatorics/stdlib", "mech-logic/stdlib", "mech-matrix/stdlib", "mech-io/stdlib", "mech-stats/stdlib", "mech-range/stdlib",
      ]
  
  baselib = ["bool", "string", 
        "f64", "c64", "r64",
        "set", "map", "table", "tuple", "record", "atom", "enum",
        "row_vectord", "vectord", "matrixd",
        "subscript_range", "logical_indexing", 
        "subscript_formula",
        "variable_define", "variable_assign", 
        "kind_define",
        "kind_annotation", "variables",
        "access", "assign", "convert",
        "functions", "formulas",
        "mech-core/baselib", "mech-math/baselib", "mech-compare/baselib", "mech-combinatorics/baselib", "mech-logic/baselib", "mech-matrix/baselib", "mech-io/baselib", "mech-stats/baselib", "mech-range/baselib",
      ]
  
  compiler = ["mech-core/compiler", "mech-math/compiler", "mech-compare/compiler", "mech-combinatorics/compiler", "mech-logic/compiler", "mech-matrix/compiler", "mech-io/compiler", "mech-stats/compiler", "mech-range/compiler"]
  program = ["mech-core/program"]
  pretty_print = ["mech-core/pretty_print", "mech-math/pretty_print", "mech-compare/pretty_print", "mech-combinatorics/pretty_print", "mech-logic/pretty_print", "mech-matrix/pretty_print", "mech-io/pretty_print", "mech-stats/pretty_print", "mech-range/pretty_print"]
  serde = ["mech-core/serde", "mech-math/serde", "mech-compare/serde", "mech-combinatorics/serde", "mech-logic/serde", "mech-matrix/serde", "mech-io/serde", "mech-stats/serde", "mech-range/serde"]
  
  statements = ["mech-core/statements", "mech-math/statements", "mech-compare/statements", "mech-combinatorics/statements", "mech-logic/statements", "mech-matrix/statements", "mech-io/statements", "mech-stats/statements", "mech-range/statements"]
  variables = ["variable_define", "symbol_table", "mech-core/variables", "mech-math/variables", "mech-compare/variables", "mech-combinatorics/variables", "mech-logic/variables", "mech-matrix/variables", "mech-io/variables", "mech-stats/variables", "mech-range/variables"]
  variable_define = ["statements", "functions", "mech-core/variable_define", "mech-math/variable_define", "mech-compare/variable_define", "mech-combinatorics/variable_define", "mech-logic/variable_define", "mech-matrix/variable_define", "mech-io/variable_define", "mech-stats/variable_define", "mech-range/variable_define"]
  variable_assign = ["assign", "statements", "mech-core/variable_assign", "mech-math/variable_assign", "mech-compare/variable_assign", "mech-combinatorics/variable_assign", "mech-logic/variable_assign", "mech-matrix/variable_assign", "mech-io/variable_assign", "mech-stats/variable_assign", "mech-range/variable_assign"]
  kind_define = ["kind_annotation", "functions", "statements", "mech-core/kind_define", "mech-math/kind_define", "mech-compare/kind_define", "mech-combinatorics/kind_define", "mech-logic/kind_define", "mech-matrix/kind_define", "mech-io/kind_define", "mech-stats/kind_define", "mech-range/kind_define"]
  kind_annotation = ["functions", "mech-core/kind_annotation", "mech-math/kind_annotation", "mech-compare/kind_annotation", "mech-combinatorics/kind_annotation", "mech-logic/kind_annotation", "mech-matrix/kind_annotation", "mech-io/kind_annotation", "mech-stats/kind_annotation", "mech-range/kind_annotation"]
  formulas = ["mech-core/formulas", "mech-math/formulas", "mech-compare/formulas", "mech-combinatorics/formulas", "mech-logic/formulas", "mech-matrix/formulas", "mech-io/formulas", "mech-stats/formulas", "mech-range/formulas"]
  functions = ["symbol_table", "mech-core/functions", "mech-math/functions", "mech-compare/functions", "mech-combinatorics/functions", "mech-logic/functions", "mech-matrix/functions", "mech-io/functions", "mech-stats/functions", "mech-range/functions"]
  symbol_table = ["mech-core/symbol_table", "mech-math/symbol_table", "mech-compare/symbol_table", "mech-combinatorics/symbol_table", "mech-logic/symbol_table", "mech-matrix/symbol_table", "mech-io/symbol_table", "mech-stats/symbol_table", "mech-range/symbol_table"]
  
  access = ["functions"]
  assign = ["functions"]
  convert = ["functions"]
  
  bool = ["mech-core/bool", "mech-compare/bool", "mech-math/bool", "mech-combinatorics/bool", "mech-logic/bool", "mech-matrix/bool", "mech-io/bool", "mech-stats/bool", "mech-range/bool"]
  string = ["mech-core/string", "mech-math/string", "mech-compare/string", "mech-combinatorics/string", "mech-logic/string", "mech-matrix/string", "mech-io/string", "mech-stats/string", "mech-range/string"]
  
  # Numbers
  numbers = ["mech-core/numbers", "mech-math/numbers", "mech-compare/numbers", "mech-combinatorics/numbers", "mech-logic/numbers", "mech-matrix/numbers", "mech-io/numbers", "mech-stats/numbers", "mech-range/numbers"]
  complex = ["f64", "numbers", "mech-core/complex", "mech-math/complex", "mech-compare/complex", "mech-combinatorics/complex", "mech-logic/complex", "mech-matrix/complex", "mech-io/complex", "mech-stats/complex", "mech-range/complex"]
  rational = ["i64", "numbers", "mech-core/rational", "mech-math/rational", "mech-compare/rational", "mech-combinatorics/rational", "mech-logic/rational", "mech-matrix/rational", "mech-io/rational", "mech-stats/rational", "mech-range/rational"]
  signed_ints = ["numbers", "mech-core/signed_ints", "mech-math/signed_ints", "mech-compare/signed_ints", "mech-combinatorics/signed_ints", "mech-logic/signed_ints", "mech-matrix/signed_ints", "mech-io/signed_ints", "mech-stats/signed_ints", "mech-range/signed_ints"]
  unsigned_ints = ["numbers", "mech-core/unsigned_ints", "mech-math/unsigned_ints", "mech-compare/unsigned_ints", "mech-combinatorics/unsigned_ints", "mech-logic/unsigned_ints", "mech-matrix/unsigned_ints", "mech-io/unsigned_ints", "mech-stats/unsigned_ints", "mech-range/unsigned_ints"]
  floats = ["numbers", "mech-core/floats", "mech-math/floats", "mech-compare/floats", "mech-combinatorics/floats", "mech-logic/floats", "mech-matrix/floats", "mech-io/floats", "mech-stats/floats", "mech-range/floats"]
  u8 = ["unsigned_ints", "mech-core/u8", "mech-math/u8", "mech-compare/u8", "mech-combinatorics/u8", "mech-logic/u8", "mech-matrix/u8", "mech-io/u8", "mech-stats/u8", "mech-range/u8"]
  u16 = ["unsigned_ints", "mech-core/u16", "mech-math/u16", "mech-compare/u16", "mech-combinatorics/u16", "mech-logic/u16", "mech-matrix/u16", "mech-io/u16", "mech-stats/u16", "mech-range/u16"]
  u32 = ["unsigned_ints", "mech-core/u32", "mech-math/u32", "mech-compare/u32", "mech-combinatorics/u32", "mech-logic/u32", "mech-matrix/u32", "mech-io/u32", "mech-stats/u32", "mech-range/u32"]
  u64 = ["unsigned_ints", "mech-core/u64", "mech-math/u64", "mech-compare/u64", "mech-combinatorics/u64", "mech-logic/u64", "mech-matrix/u64", "mech-io/u64", "mech-stats/u64", "mech-range/u64"]
  u128 = ["unsigned_ints", "mech-core/u128", "mech-math/u128", "mech-compare/u128", "mech-combinatorics/u128", "mech-logic/u128", "mech-matrix/u128", "mech-io/u128", "mech-stats/u128", "mech-range/u128"]
  i8 = ["signed_ints", "mech-core/i8", "mech-math/i8", "mech-compare/i8", "mech-combinatorics/i8", "mech-logic/i8", "mech-matrix/i8", "mech-io/i8", "mech-stats/i8", "mech-range/i8"]
  i16 = ["signed_ints", "mech-core/i16", "mech-math/i16", "mech-compare/i16", "mech-combinatorics/i16", "mech-logic/i16", "mech-matrix/i16", "mech-io/i16", "mech-stats/i16", "mech-range/i16"]
  i32 = ["signed_ints", "mech-core/i32", "mech-math/i32", "mech-compare/i32", "mech-combinatorics/i32", "mech-logic/i32", "mech-matrix/i32", "mech-io/i32", "mech-stats/i32", "mech-range/i32"]
  i64 = ["signed_ints", "mech-core/i64", "mech-math/i64", "mech-compare/i64", "mech-combinatorics/i64", "mech-logic/i64", "mech-matrix/i64", "mech-io/i64", "mech-stats/i64", "mech-range/i64"]
  i128 = ["signed_ints", "mech-core/i128", "mech-math/i128", "mech-compare/i128", "mech-combinatorics/i128", "mech-logic/i128", "mech-matrix/i128", "mech-io/i128", "mech-stats/i128", "mech-range/i128"]
  f32 = ["floats", "mech-core/f32", "mech-math/f32", "mech-compare/f32", "mech-combinatorics/f32", "mech-logic/f32", "mech-matrix/f32", "mech-io/f32", "mech-stats/f32", "mech-range/f32"]
  f64 = ["floats", "mech-core/f64", "mech-math/f64", "mech-compare/f64", "mech-combinatorics/f64", "mech-logic/f64", "mech-matrix/f64", "mech-io/f64", "mech-stats/f64", "mech-range/f64"]
  c64 = ["complex", "mech-core/c64", "mech-math/c64", "mech-compare/c64", "mech-combinatorics/c64", "mech-logic/c64", "mech-matrix/c64", "mech-io/c64", "mech-stats/c64", "mech-range/c64"]
  r64 = ["rational", "mech-core/r64", "mech-math/r64", "mech-compare/r64", "mech-combinatorics/r64", "mech-logic/r64", "mech-matrix/r64", "mech-io/r64", "mech-stats/r64", "mech-range/r64"]
  
  # Structs
  set = ["indexmap", "mech-core/set", "mech-math/set", "mech-compare/set", "mech-combinatorics/set", "mech-logic/set", "mech-matrix/set", "mech-io/set", "mech-stats/set", "mech-range/set"]
  map = ["indexmap", "mech-core/map", "mech-math/map", "mech-compare/map", "mech-combinatorics/map", "mech-logic/map", "mech-matrix/map", "mech-io/map", "mech-stats/map", "mech-range/map"]
  table = ["indexmap", "vectord", "record", "mech-core/table", "mech-math/table", "mech-compare/table", "mech-combinatorics/table", "mech-logic/table", "mech-matrix/table", "mech-io/table", "mech-stats/table", "mech-range/table"]
  tuple = ["mech-core/tuple", "mech-math/tuple", "mech-compare/tuple", "mech-combinatorics/tuple", "mech-logic/tuple", "mech-matrix/tuple", "mech-io/tuple", "mech-stats/tuple", "mech-range/tuple"]
  enum = ["mech-core/enum", "mech-math/enum", "mech-compare/enum", "mech-combinatorics/enum", "mech-logic/enum", "mech-matrix/enum", "mech-io/enum", "mech-stats/enum", "mech-range/enum"]
  record = ["indexmap", "tuple", "mech-core/record", "mech-math/record", "mech-compare/record", "mech-combinatorics/record", "mech-logic/record", "mech-matrix/record", "mech-io/record", "mech-stats/record", "mech-range/record"]
  atom = ["mech-core/atom", "mech-math/atom", "mech-compare/atom", "mech-combinatorics/atom", "mech-logic/atom", "mech-matrix/atom", "mech-io/atom", "mech-stats/atom", "mech-range/atom"]
  
  # Matrix
  matrix = ["nalgebra", "mech-core/matrix", "matrix_horzcat", "matrix_vertcat", "mech-math/matrix", "mech-compare/matrix", "mech-combinatorics/matrix", "mech-logic/matrix", "mech-matrix/matrix", "mech-io/matrix", "mech-stats/matrix", "mech-range/matrix"]
  fixed_row_vector = ["row_vector4", "row_vector3", "row_vector2", "mech-core/fixed_row_vector", "mech-math/fixed_row_vector", "mech-compare/fixed_row_vector", "mech-combinatorics/fixed_row_vector", "mech-logic/fixed_row_vector", "mech-matrix/fixed_row_vector", "mech-io/fixed_row_vector", "mech-stats/fixed_row_vector", "mech-range/fixed_row_vector", "matrix"]
  fixed_vector = ["vector4", "vector3", "vector2", "mech-core/fixed_vector", "mech-math/fixed_vector", "mech-compare/fixed_vector", "mech-combinatorics/fixed_vector", "mech-logic/fixed_vector", "mech-matrix/fixed_vector", "mech-io/fixed_vector", "mech-stats/fixed_vector", "mech-range/fixed_vector", "matrix"]
  fixed_matrix = ["matrix4", "matrix3", "matrix2", "matrix1", "matrix2x3", "matrix3x2", "mech-core/fixed_matrix", "mech-math/fixed_matrix", "mech-compare/fixed_matrix", "mech-combinatorics/fixed_matrix", "mech-logic/fixed_matrix", "mech-matrix/fixed_matrix", "mech-io/fixed_matrix", "mech-stats/fixed_matrix", "mech-range/fixed_matrix", "matrix"]
  dynamic_matrix = ["matrixd", "vectord", "row_vectord", "mech-core/dynamic_matrix", "mech-math/dynamic_matrix", "mech-compare/dynamic_matrix", "mech-combinatorics/dynamic_matrix", "mech-logic/dynamic_matrix", "mech-matrix/dynamic_matrix", "mech-io/dynamic_matrix", "mech-stats/dynamic_matrix", "mech-range/dynamic_matrix", "matrix"]
  row_vector4 = ["matrix", "mech-core/row_vector4", "mech-math/row_vector4", "mech-compare/row_vector4", "mech-combinatorics/row_vector4", "mech-logic/row_vector4", "mech-matrix/row_vector4", "mech-io/row_vector4", "mech-stats/row_vector4", "mech-range/row_vector4"]
  row_vector3 = ["matrix", "mech-core/row_vector3", "mech-math/row_vector3", "mech-compare/row_vector3", "mech-combinatorics/row_vector3", "mech-logic/row_vector3", "mech-matrix/row_vector3", "mech-io/row_vector3", "mech-stats/row_vector3", "mech-range/row_vector3"]
  row_vector2 = ["matrix", "mech-core/row_vector2", "mech-math/row_vector2", "mech-compare/row_vector2", "mech-combinatorics/row_vector2", "mech-logic/row_vector2", "mech-matrix/row_vector2", "mech-io/row_vector2", "mech-stats/row_vector2", "mech-range/row_vector2"]
  vector4 = ["matrix", "mech-core/vector4", "mech-math/vector4", "mech-compare/vector4", "mech-combinatorics/vector4", "mech-logic/vector4", "mech-matrix/vector4", "mech-io/vector4", "mech-stats/vector4", "mech-range/vector4"]
  vector3 = ["matrix", "mech-core/vector3", "mech-math/vector3", "mech-compare/vector3", "mech-combinatorics/vector3", "mech-logic/vector3", "mech-matrix/vector3", "mech-io/vector3", "mech-stats/vector3", "mech-range/vector3"]
  vector2 = ["matrix", "mech-core/vector2", "mech-math/vector2", "mech-compare/vector2", "mech-combinatorics/vector2", "mech-logic/vector2", "mech-matrix/vector2", "mech-io/vector2", "mech-stats/vector2", "mech-range/vector2"]
  matrix4 = ["matrix", "mech-core/matrix4", "mech-math/matrix4", "mech-compare/matrix4", "mech-combinatorics/matrix4", "mech-logic/matrix4", "mech-matrix/matrix4", "mech-io/matrix4", "mech-stats/matrix4", "mech-range/matrix4"]
  matrix3 = ["matrix", "mech-core/matrix3", "mech-math/matrix3", "mech-compare/matrix3", "mech-combinatorics/matrix3", "mech-logic/matrix3", "mech-matrix/matrix3", "mech-io/matrix3", "mech-stats/matrix3", "mech-range/matrix3"]
  matrix2 = ["matrix", "mech-core/matrix2", "mech-math/matrix2", "mech-compare/matrix2", "mech-combinatorics/matrix2", "mech-core/matrix", "mech-logic/matrix2", "mech-matrix/matrix2", "mech-io/matrix2", "mech-stats/matrix2", "mech-range/matrix2"]
  matrix1 = ["matrix", "mech-core/matrix1", "mech-math/matrix1", "mech-compare/matrix1", "mech-combinatorics/matrix1", "mech-logic/matrix1", "mech-matrix/matrix1", "mech-io/matrix1", "mech-stats/matrix1", "mech-range/matrix1"]
  matrix2x3 = ["matrix", "mech-core/matrix2x3", "mech-math/matrix2x3", "mech-compare/matrix2x3", "mech-combinatorics/matrix2x3", "mech-logic/matrix2x3", "mech-matrix/matrix2x3", "mech-io/matrix2x3", "mech-stats/matrix2x3", "mech-range/matrix2x3"]
  matrix3x2 = ["matrix", "mech-core/matrix3x2", "mech-math/matrix3x2", "mech-compare/matrix3x2", "mech-combinatorics/matrix3x2", "mech-logic/matrix3x2", "mech-matrix/matrix3x2", "mech-io/matrix3x2", "mech-stats/matrix3x2", "mech-range/matrix3x2"]
  row_vectord =["matrix", "mech-core/row_vectord", "mech-math/row_vectord", "mech-compare/row_vectord", "mech-combinatorics/row_vectord", "mech-logic/row_vectord", "mech-matrix/row_vectord", "mech-io/row_vectord", "mech-stats/row_vectord", "mech-range/row_vectord"]
  vectord = ["matrix", "mech-core/vectord", "mech-math/vectord", "mech-compare/vectord", "mech-combinatorics/vectord", "mech-logic/vectord", "mech-matrix/vectord", "mech-io/vectord", "mech-stats/vectord", "mech-range/vectord"]
  matrixd = ["matrix", "mech-core/matrixd", "mech-math/matrixd", "mech-compare/matrixd", "mech-combinatorics/matrixd", "mech-logic/matrixd", "mech-matrix/matrixd", "mech-io/matrixd", "mech-stats/matrixd", "mech-range/matrixd"]
  
  # Subscripts
  subscript = ["mech-core/subscript", "mech-math/subscript", "mech-compare/subscript", "mech-combinatorics/subscript", "mech-logic/subscript", "mech-matrix/subscript", "mech-io/subscript", "mech-stats/subscript", "mech-range/subscript"]
  subscript_slice = ["subscript", "vectord", "mech-core/subscript_slice", "mech-math/subscript_slice", "mech-compare/subscript_slice", "mech-combinatorics/subscript_slice", "mech-logic/subscript_slice", "mech-matrix/subscript_slice", "mech-io/subscript_slice", "mech-stats/subscript_slice", "mech-range/subscript_slice"]
  subscript_range = ["range", "subscript_slice","vectord", "mech-core/subscript_range", "mech-math/subscript_range", "mech-compare/subscript_range", "mech-combinatorics/subscript_range", "mech-logic/subscript_range", "mech-matrix/subscript_range", "mech-io/subscript_range", "mech-stats/subscript_range", "mech-range/subscript_range"]
  subscript_formula = ["subscript_slice","formulas", "mech-core/subscript_formula", "mech-math/subscript_formula", "mech-compare/subscript_formula", "mech-combinatorics/subscript_formula", "mech-logic/subscript_formula", "mech-matrix/subscript_formula", "mech-io/subscript_formula", "mech-stats/subscript_formula", "mech-range/subscript_formula"]
  logical_indexing = ["subscript","vectord","bool", "mech-core/logical_indexing", "mech-math/logical_indexing", "mech-compare/logical_indexing", "mech-combinatorics/logical_indexing", "mech-logic/logical_indexing", "mech-matrix/logical_indexing", "mech-io/logical_indexing", "mech-stats/logical_indexing", "mech-range/logical_indexing"]
  dot_indexing = ["subscript", "mech-core/dot_indexing", "mech-math/dot_indexing", "mech-compare/dot_indexing", "mech-combinatorics/dot_indexing", "mech-logic/dot_indexing", "mech-matrix/dot_indexing", "mech-io/dot_indexing", "mech-stats/dot_indexing", "mech-range/dot_indexing"]
  swizzle = ["subscript", "mech-core/swizzle", "mech-math/swizzle", "mech-compare/swizzle", "mech-combinatorics/swizzle", "mech-logic/swizzle", "mech-matrix/swizzle", "mech-io/swizzle", "mech-stats/swizzle", "mech-range/swizzle"]
  
  # Libs
  # -----------------------------------------------------------------------------
  
  # Stats
  stats_default = ["stats_sum"]
  stats = ["num-traits", "functions", "mech-stats/stats"]
  stats_sum = ["stats", "mech-stats/sum"]
  
  # Io
  io_default = ["io_print", "io_println", "mech-io/io_default"]
  io = ["functions"]
  io_print = ["io", "mech-io/print"]
  io_println = ["io", "mech-io/println"]
  
  # Matrix
  matrix_default = ["matrix_dot", "matrix_horzcat", "matrix_vertcat", "matrix_matmul", "matrix_transpose", "mech-matrix/matrix_default"]
  matrix_horzcat = ["matrix", "functions"]
  matrix_vertcat = ["matrix", "functions"]
  matrix_matmul = ["matrix", "mech-matrix/matmul"]
  matrix_transpose = ["matrix", "mech-matrix/transpose"]
  matrix_dot = ["matrix", "mech-matrix/dot"]
  
  # Logic
  logic_default = ["logic_and", "logic_or", "logic_not", "logic_xor", "mech-logic/logic_default"]
  logic = ["bool", "mech-logic/logic"]
  logic_and = ["logic", "mech-logic/and"]
  logic_or = ["logic", "mech-logic/or"]
  logic_not = ["logic", "mech-logic/not"]
  logic_xor = ["logic", "mech-logic/xor"]
  
  # Combinatorics
  combinatorics_default = ["combinatorics_n_choose_k", "mech-combinatorics/combinatorics_default"]
  combinatorics = ["num-traits", "functions", "mech-combinatorics/combinatorics"]
  combinatorics_n_choose_k = ["combinatorics", "mech-combinatorics/n_choose_k"]
  
  # Compare
  compare_default = ["compare_lt", "compare_gt", "compare_lte", "compare_gte", "compare_eq", "compare_neq", "mech-compare/compare_default"]
  compare = ["functions", "bool", "mech-compare/compare"]
  compare_eq = ["compare", "mech-compare/eq"]
  compare_neq = ["compare", "mech-compare/neq"]
  compare_lt = ["compare", "mech-compare/lt"]
  compare_gt = ["compare", "mech-compare/gt"]
  compare_lte = ["compare", "mech-compare/lte"]
  compare_gte = ["compare", "mech-compare/gte"]
  
  # Range
  range_default = ["range_inclusive", "range_exclusive", "mech-range/range_default"]
  range = ["functions", "formulas", "mech-range/range"]
  range_inclusive = ["range", "mech-range/inclusive"]
  range_exclusive = ["range", "mech-range/exclusive"]
  
  # Math
  math_default = ["math_ops_default", "math_root_default", "math_ops_assign_default", "math_trig_default", "mech-math/math_default"]
  math = ["mech-math/math", "formulas", "functions"]
  math_ops_default = ["math_add", "math_sub", "math_mul", "math_div", "math_exp", "math_mod", "math_neg"]
  math_root_default = ["math_sqrt", "mech-math/root_default"]
  math_ops_assign_default = ["math_add_assign", "math_sub_assign", "math_mul_assign", "math_div_assign"]
  math_trig_default = ["math_acos", "math_acosh", "math_acot", "math_acsc", "math_asec", "math_asin", "math_asinh", "math_atan", "math_atan2", "math_atanh", "math_cos", "math_cosh", "math_cot", "math_csc", "math_sec", "math_sin", "math_sinh", "math_tan", "math_tanh"]
  math_trig = ["math", "mech-math/trig"]
  math_root = ["math", "mech-math/root"]
  math_ops = ["math", "mech-math/ops"]
  math_op_assign = ["math", "mech-math/op_assign"]
  math_add_assign = ["math_op_assign", "mech-math/add_assign"]
  math_sub_assign = ["math_op_assign", "mech-math/sub_assign"]
  math_mul_assign = ["math_op_assign", "mech-math/mul_assign"]
  math_div_assign = ["math_op_assign", "mech-math/div_assign"]
  math_acos = ["math_trig", "mech-math/acos"]
  math_acosh = ["math_trig", "mech-math/acosh"]
  math_acot = ["math_trig", "mech-math/acot"]
  math_acsc = ["math_trig", "mech-math/acsc"]
  math_asec = ["math_trig", "mech-math/asec"]
  math_asin = ["math_trig", "mech-math/asin"]
  math_asinh = ["math_trig", "mech-math/asinh"]
  math_atan = ["math_trig", "mech-math/atan"]
  math_atan2 = ["math_trig", "mech-math/atan2"]
  math_atanh = ["math_trig", "mech-math/atanh"]
  math_cos = ["math_trig", "mech-math/cos"]
  math_cosh = ["math_trig", "mech-math/cosh"]
  math_cot = ["math_trig", "mech-math/cot"]
  math_csc = ["math_trig", "mech-math/csc"]
  math_sec = ["math_trig", "mech-math/sec"]
  math_sin = ["math_trig", "mech-math/sin"]
  math_sinh = ["math_trig", "mech-math/sinh"]
  math_tan = ["math_trig", "mech-math/tan"]
  math_tanh = ["math_trig", "mech-math/tanh"]
  math_add = ["math_ops", "mech-math/add"]
  math_sub = ["math_ops", "mech-math/sub"]
  math_mul = ["math_ops", "mech-math/mul"]
  math_div = ["math_ops", "mech-math/div"]
  math_exp = ["math_ops", "mech-math/exp"]
  math_mod = ["math_ops", "mech-math/mod"]
  math_neg = ["math_ops", "mech-math/neg"]
  math_sqrt = ["math_root", "mech-math/sqrt"]
  
  [dependencies]
  mech-core = { version = "0.2.60", default-features = false }
  mech-math = { version = "0.2.60", default-features = false, optional = true}
  mech-logic = { version = "0.2.60", default-features = false, optional = true }
  mech-range = { version = "0.2.60", default-features = false, optional = true }
  mech-matrix = { version = "0.2.60", default-features = false, optional = true }
  mech-compare = { version = "0.2.60", default-features = false, optional = true }
  mech-stats = { version = "0.2.60", default-features = false, optional = true }
  mech-io = { version = "0.2.60", default-features = false, optional = true }
  mech-combinatorics = { version = "0.2.60", default-features = false, optional = true }
  
  paste = "1.0.15"
  byteorder = "1.5.0"
  inventory = "0.3.21"
  nalgebra = {version = "0.34.0", optional = true}
  indexmap = {version = "2.10.0", optional = true}
  bincode = {version = "2.0.1", optional = true}
  
  [dependencies.num-traits]
  version = "0.2.19"
  default-features = false
  features = ["libm"]
  optional = true