RubyGems - kumi - Versions diffs - 0.0.22 → 0.0.24 - Mend

kumi 0.0.22 → 0.0.24

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (112) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +7 -0
data/README.md +60 -116
data/golden/array_element/expected/schema_ruby.rb +1 -1
data/golden/array_index/expected/schema_ruby.rb +1 -1
data/golden/array_operations/expected/schema_ruby.rb +1 -1
data/golden/cascade_logic/expected/schema_ruby.rb +1 -1
data/golden/chained_fusion/expected/schema_ruby.rb +1 -1
data/golden/element_arrays/expected/schema_ruby.rb +1 -1
data/golden/empty_and_null_inputs/expected/schema_ruby.rb +1 -1
data/golden/game_of_life/expected/lir_00_unoptimized.txt +33 -33
data/golden/game_of_life/expected/lir_01_hoist_scalar_references.txt +33 -33
data/golden/game_of_life/expected/lir_02_inlined.txt +296 -296
data/golden/game_of_life/expected/lir_03_cse.txt +128 -128
data/golden/game_of_life/expected/lir_04_1_loop_fusion.txt +128 -128
data/golden/game_of_life/expected/lir_04_loop_invcm.txt +128 -128
data/golden/game_of_life/expected/lir_06_const_prop.txt +128 -128
data/golden/game_of_life/expected/schema_ruby.rb +1 -1
data/golden/hash_keys/expected/schema_ruby.rb +1 -1
data/golden/hash_keys/schema.kumi +4 -5
data/golden/hash_value/expected/schema_ruby.rb +1 -1
data/golden/hierarchical_complex/expected/schema_ruby.rb +1 -1
data/golden/inline_rename_scope_leak/expected/ast.txt +48 -0
data/golden/inline_rename_scope_leak/expected/input_plan.txt +10 -0
data/golden/inline_rename_scope_leak/expected/lir_00_unoptimized.txt +35 -0
data/golden/inline_rename_scope_leak/expected/lir_01_hoist_scalar_references.txt +35 -0
data/golden/inline_rename_scope_leak/expected/lir_02_inlined.txt +49 -0
data/golden/inline_rename_scope_leak/expected/lir_03_cse.txt +49 -0
data/golden/inline_rename_scope_leak/expected/lir_04_1_loop_fusion.txt +49 -0
data/golden/inline_rename_scope_leak/expected/lir_04_loop_invcm.txt +49 -0
data/golden/inline_rename_scope_leak/expected/lir_06_const_prop.txt +49 -0
data/golden/inline_rename_scope_leak/expected/nast.txt +31 -0
data/golden/inline_rename_scope_leak/expected/schema_javascript.mjs +51 -0
data/golden/inline_rename_scope_leak/expected/schema_ruby.rb +82 -0
data/golden/inline_rename_scope_leak/expected/snast.txt +31 -0
data/golden/inline_rename_scope_leak/expected.json +7 -0
data/golden/inline_rename_scope_leak/input.json +4 -0
data/golden/inline_rename_scope_leak/schema.kumi +24 -0
data/golden/input_reference/expected/schema_ruby.rb +1 -1
data/golden/interleaved_fusion/expected/schema_ruby.rb +1 -1
data/golden/let_inline/expected/schema_ruby.rb +1 -1
data/golden/loop_fusion/expected/schema_ruby.rb +1 -1
data/golden/min_reduce_scope/expected/schema_ruby.rb +1 -1
data/golden/mixed_dimensions/expected/schema_ruby.rb +1 -1
data/golden/multirank_hoisting/expected/schema_ruby.rb +1 -1
data/golden/nested_hash/expected/schema_ruby.rb +1 -1
data/golden/reduction_broadcast/expected/schema_ruby.rb +1 -1
data/golden/roll/expected/lir_00_unoptimized.txt +8 -8
data/golden/roll/expected/lir_01_hoist_scalar_references.txt +8 -8
data/golden/roll/expected/lir_02_inlined.txt +8 -8
data/golden/roll/expected/lir_03_cse.txt +8 -8
data/golden/roll/expected/lir_04_1_loop_fusion.txt +8 -8
data/golden/roll/expected/lir_04_loop_invcm.txt +8 -8
data/golden/roll/expected/lir_06_const_prop.txt +8 -8
data/golden/roll/expected/schema_ruby.rb +1 -1
data/golden/shift/expected/lir_00_unoptimized.txt +12 -12
data/golden/shift/expected/lir_01_hoist_scalar_references.txt +12 -12
data/golden/shift/expected/lir_02_inlined.txt +12 -12
data/golden/shift/expected/lir_03_cse.txt +12 -12
data/golden/shift/expected/lir_04_1_loop_fusion.txt +12 -12
data/golden/shift/expected/lir_04_loop_invcm.txt +12 -12
data/golden/shift/expected/lir_06_const_prop.txt +12 -12
data/golden/shift/expected/schema_ruby.rb +1 -1
data/golden/shift_2d/expected/lir_00_unoptimized.txt +48 -48
data/golden/shift_2d/expected/lir_01_hoist_scalar_references.txt +48 -48
data/golden/shift_2d/expected/lir_02_inlined.txt +48 -48
data/golden/shift_2d/expected/lir_03_cse.txt +48 -48
data/golden/shift_2d/expected/lir_04_1_loop_fusion.txt +48 -48
data/golden/shift_2d/expected/lir_04_loop_invcm.txt +48 -48
data/golden/shift_2d/expected/lir_06_const_prop.txt +48 -48
data/golden/shift_2d/expected/schema_ruby.rb +1 -1
data/golden/simple_math/expected/schema_ruby.rb +1 -1
data/golden/streaming_basics/expected/schema_ruby.rb +1 -1
data/golden/tuples/expected/lir_00_unoptimized.txt +4 -4
data/golden/tuples/expected/lir_01_hoist_scalar_references.txt +4 -4
data/golden/tuples/expected/lir_02_inlined.txt +4 -4
data/golden/tuples/expected/lir_03_cse.txt +4 -4
data/golden/tuples/expected/lir_04_1_loop_fusion.txt +4 -4
data/golden/tuples/expected/lir_04_loop_invcm.txt +4 -4
data/golden/tuples/expected/lir_06_const_prop.txt +4 -4
data/golden/tuples/expected/schema_ruby.rb +1 -1
data/golden/tuples_and_arrays/expected/lir_00_unoptimized.txt +1 -1
data/golden/tuples_and_arrays/expected/lir_01_hoist_scalar_references.txt +1 -1
data/golden/tuples_and_arrays/expected/lir_02_inlined.txt +2 -2
data/golden/tuples_and_arrays/expected/lir_03_cse.txt +2 -2
data/golden/tuples_and_arrays/expected/lir_04_1_loop_fusion.txt +2 -2
data/golden/tuples_and_arrays/expected/lir_04_loop_invcm.txt +2 -2
data/golden/tuples_and_arrays/expected/lir_06_const_prop.txt +2 -2
data/golden/tuples_and_arrays/expected/schema_ruby.rb +1 -1
data/golden/us_tax_2024/expected/ast.txt +865 -0
data/golden/us_tax_2024/expected/input_plan.txt +61 -0
data/golden/us_tax_2024/expected/lir_00_unoptimized.txt +901 -0
data/golden/us_tax_2024/expected/lir_01_hoist_scalar_references.txt +901 -0
data/golden/us_tax_2024/expected/lir_02_inlined.txt +5178 -0
data/golden/us_tax_2024/expected/lir_03_cse.txt +2499 -0
data/golden/us_tax_2024/expected/lir_04_1_loop_fusion.txt +2519 -0
data/golden/us_tax_2024/expected/lir_04_loop_invcm.txt +2439 -0
data/golden/us_tax_2024/expected/lir_06_const_prop.txt +2439 -0
data/golden/us_tax_2024/expected/nast.txt +976 -0
data/golden/us_tax_2024/expected/schema_javascript.mjs +584 -0
data/golden/us_tax_2024/expected/schema_ruby.rb +639 -0
data/golden/us_tax_2024/expected/snast.txt +976 -0
data/golden/us_tax_2024/expected.json +1 -0
data/golden/us_tax_2024/input.json +168 -0
data/golden/us_tax_2024/schema.kumi +203 -0
data/golden/with_constants/expected/schema_ruby.rb +1 -1
data/lib/kumi/core/analyzer/passes/lir/inline_declarations_pass.rb +181 -105
data/lib/kumi/core/analyzer/passes/output_schema_pass.rb +6 -4
data/lib/kumi/core/functions/function_spec.rb +14 -8
data/lib/kumi/core/functions/loader.rb +1 -1
data/lib/kumi/version.rb +1 -1
metadata +33 -1

data/golden/us_tax_2024/expected/nast.txt ADDED Viewed

@@ -0,0 +1,976 @@
+(NAST
+  (VALUE state_tax
+    (Call :"core.mul"
+    (InputRef [:income])
+    (InputRef [:state_rate])
+  )
+  )
+  (VALUE local_tax
+    (Call :"core.mul"
+    (InputRef [:income])
+    (InputRef [:local_rate])
+  )
+  )
+  (VALUE taxable_single
+    (Call :"agg.max"
+    (Tuple
+      (Call :"core.sub"
+        (InputRef [:income])
+        (InputRef [:fed, :single, :std])
+      )
+      (Const 0)
+    )
+  )
+  )
+  (VALUE lo_s
+    (InputRef [:fed, :single, :rates, :bracket, :lo])
+  )
+  (VALUE hi_s
+    (InputRef [:fed, :single, :rates, :bracket, :hi])
+  )
+  (VALUE rate_s
+    (InputRef [:fed, :single, :rates, :bracket, :rate])
+  )
+  (VALUE big_hi
+    (Const 100000000000.0)
+  )
+  (VALUE hi_s_eff
+    (Call :__select__
+    (Call :"core.eq"
+      (Ref hi_s)
+      (Const -1)
+    )
+    (Ref big_hi)
+    (Ref hi_s)
+  )
+  )
+  (VALUE amt_s
+    (Call :"core.clamp"
+    (Call :"core.sub"
+      (Ref taxable_single)
+      (Ref lo_s)
+    )
+    (Const 0)
+    (Call :"core.sub"
+      (Ref hi_s_eff)
+      (Ref lo_s)
+    )
+  )
+  )
+  (VALUE fed_tax_single
+    (Call :"agg.sum"
+    (Call :"core.mul"
+      (Ref amt_s)
+      (Ref rate_s)
+    )
+  )
+  )
+  (VALUE in_br_s
+    (Call :"core.and"
+    (Call :"core.gte"
+      (Ref taxable_single)
+      (Ref lo_s)
+    )
+    (Call :"core.lt"
+      (Ref taxable_single)
+      (Ref hi_s_eff)
+    )
+  )
+  )
+  (VALUE fed_marginal_single
+    (Call :sum
+    (Call :__select__
+      (Ref in_br_s)
+      (Ref rate_s)
+      (Const 0)
+    )
+  )
+  )
+  (VALUE fed_eff_single
+    (Call :"core.div"
+    (Ref fed_tax_single)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE ss_wage_base
+    (Const 168600.0)
+  )
+  (VALUE ss_rate
+    (Const 0.062)
+  )
+  (VALUE ss_tax_s
+    (Call :"core.mul"
+    (Call :"agg.min"
+      (Tuple
+        (InputRef [:income])
+        (Ref ss_wage_base)
+      )
+    )
+    (Ref ss_rate)
+  )
+  )
+  (VALUE med_base_rate
+    (Const 0.0145)
+  )
+  (VALUE med_tax_s
+    (Call :"core.mul"
+    (InputRef [:income])
+    (Ref med_base_rate)
+  )
+  )
+  (VALUE addl_threshold_single
+    (Const 200000.0)
+  )
+  (VALUE addl_med_rate
+    (Const 0.009)
+  )
+  (VALUE addl_med_tax_s
+    (Call :"core.mul"
+    (Call :"agg.max"
+      (Tuple
+        (Call :"core.sub"
+          (InputRef [:income])
+          (Ref addl_threshold_single)
+        )
+        (Const 0)
+      )
+    )
+    (Ref addl_med_rate)
+  )
+  )
+  (VALUE fica_tax_single
+    (Call :"core.add"
+    (Call :"core.add"
+      (Ref ss_tax_s)
+      (Ref med_tax_s)
+    )
+    (Ref addl_med_tax_s)
+  )
+  )
+  (VALUE fica_eff_single
+    (Call :"core.div"
+    (Ref fica_tax_single)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE total_tax_single
+    (Call :"core.add"
+    (Call :"core.add"
+      (Call :"core.add"
+        (Ref fed_tax_single)
+        (Ref fica_tax_single)
+      )
+      (Ref state_tax)
+    )
+    (Ref local_tax)
+  )
+  )
+  (VALUE total_eff_single
+    (Call :"core.div"
+    (Ref total_tax_single)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE after_tax_single
+    (Call :"core.sub"
+    (InputRef [:income])
+    (Ref total_tax_single)
+  )
+  )
+  (VALUE take_home_single
+    (Call :"core.sub"
+    (Ref after_tax_single)
+    (InputRef [:retirement_contrib])
+  )
+  )
+  (VALUE taxable_mj
+    (Call :"agg.max"
+    (Tuple
+      (Call :"core.sub"
+        (InputRef [:income])
+        (InputRef [:fed, :married_joint, :std])
+      )
+      (Const 0)
+    )
+  )
+  )
+  (VALUE lo_mj
+    (InputRef [:fed, :married_joint, :rates, :bracket, :lo])
+  )
+  (VALUE hi_mj
+    (InputRef [:fed, :married_joint, :rates, :bracket, :hi])
+  )
+  (VALUE rate_mj
+    (InputRef [:fed, :married_joint, :rates, :bracket, :rate])
+  )
+  (VALUE hi_mj_eff
+    (Call :__select__
+    (Call :"core.eq"
+      (Ref hi_mj)
+      (Const -1)
+    )
+    (Ref big_hi)
+    (Ref hi_mj)
+  )
+  )
+  (VALUE amt_mj
+    (Call :"core.clamp"
+    (Call :"core.sub"
+      (Ref taxable_mj)
+      (Ref lo_mj)
+    )
+    (Const 0)
+    (Call :"core.sub"
+      (Ref hi_mj_eff)
+      (Ref lo_mj)
+    )
+  )
+  )
+  (VALUE fed_tax_mj
+    (Call :"agg.sum"
+    (Call :"core.mul"
+      (Ref amt_mj)
+      (Ref rate_mj)
+    )
+  )
+  )
+  (VALUE in_br_mj
+    (Call :"core.and"
+    (Call :"core.gte"
+      (Ref taxable_mj)
+      (Ref lo_mj)
+    )
+    (Call :"core.lt"
+      (Ref taxable_mj)
+      (Ref hi_mj_eff)
+    )
+  )
+  )
+  (VALUE fed_marginal_mj
+    (Call :sum
+    (Call :__select__
+      (Ref in_br_mj)
+      (Ref rate_mj)
+      (Const 0)
+    )
+  )
+  )
+  (VALUE fed_eff_mj
+    (Call :"core.div"
+    (Ref fed_tax_mj)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE ss_tax_mj
+    (Ref ss_tax_s)
+  )
+  (VALUE med_tax_mj
+    (Ref med_tax_s)
+  )
+  (VALUE addl_threshold_mj
+    (Const 250000.0)
+  )
+  (VALUE addl_med_tax_mj
+    (Call :"core.mul"
+    (Call :"agg.max"
+      (Tuple
+        (Call :"core.sub"
+          (InputRef [:income])
+          (Ref addl_threshold_mj)
+        )
+        (Const 0)
+      )
+    )
+    (Ref addl_med_rate)
+  )
+  )
+  (VALUE fica_tax_mj
+    (Call :"core.add"
+    (Call :"core.add"
+      (Ref ss_tax_mj)
+      (Ref med_tax_mj)
+    )
+    (Ref addl_med_tax_mj)
+  )
+  )
+  (VALUE fica_eff_mj
+    (Call :"core.div"
+    (Ref fica_tax_mj)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE total_tax_mj
+    (Call :"core.add"
+    (Call :"core.add"
+      (Call :"core.add"
+        (Ref fed_tax_mj)
+        (Ref fica_tax_mj)
+      )
+      (Ref state_tax)
+    )
+    (Ref local_tax)
+  )
+  )
+  (VALUE total_eff_mj
+    (Call :"core.div"
+    (Ref total_tax_mj)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE after_tax_mj
+    (Call :"core.sub"
+    (InputRef [:income])
+    (Ref total_tax_mj)
+  )
+  )
+  (VALUE take_home_mj
+    (Call :"core.sub"
+    (Ref after_tax_mj)
+    (InputRef [:retirement_contrib])
+  )
+  )
+  (VALUE taxable_ms
+    (Call :"agg.max"
+    (Tuple
+      (Call :"core.sub"
+        (InputRef [:income])
+        (InputRef [:fed, :married_separate, :std])
+      )
+      (Const 0)
+    )
+  )
+  )
+  (VALUE lo_ms
+    (InputRef [:fed, :married_separate, :rates, :bracket, :lo])
+  )
+  (VALUE hi_ms
+    (InputRef [:fed, :married_separate, :rates, :bracket, :hi])
+  )
+  (VALUE rate_ms
+    (InputRef [:fed, :married_separate, :rates, :bracket, :rate])
+  )
+  (VALUE hi_ms_eff
+    (Call :__select__
+    (Call :"core.eq"
+      (Ref hi_ms)
+      (Const -1)
+    )
+    (Ref big_hi)
+    (Ref hi_ms)
+  )
+  )
+  (VALUE amt_ms
+    (Call :"core.clamp"
+    (Call :"core.sub"
+      (Ref taxable_ms)
+      (Ref lo_ms)
+    )
+    (Const 0)
+    (Call :"core.sub"
+      (Ref hi_ms_eff)
+      (Ref lo_ms)
+    )
+  )
+  )
+  (VALUE fed_tax_ms
+    (Call :"agg.sum"
+    (Call :"core.mul"
+      (Ref amt_ms)
+      (Ref rate_ms)
+    )
+  )
+  )
+  (VALUE in_br_ms
+    (Call :"core.and"
+    (Call :"core.gte"
+      (Ref taxable_ms)
+      (Ref lo_ms)
+    )
+    (Call :"core.lt"
+      (Ref taxable_ms)
+      (Ref hi_ms_eff)
+    )
+  )
+  )
+  (VALUE fed_marginal_ms
+    (Call :sum
+    (Call :__select__
+      (Ref in_br_ms)
+      (Ref rate_ms)
+      (Const 0)
+    )
+  )
+  )
+  (VALUE fed_eff_ms
+    (Call :"core.div"
+    (Ref fed_tax_ms)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE ss_tax_ms
+    (Ref ss_tax_s)
+  )
+  (VALUE med_tax_ms
+    (Ref med_tax_s)
+  )
+  (VALUE addl_threshold_ms
+    (Const 125000.0)
+  )
+  (VALUE addl_med_tax_ms
+    (Call :"core.mul"
+    (Call :"agg.max"
+      (Tuple
+        (Call :"core.sub"
+          (InputRef [:income])
+          (Ref addl_threshold_ms)
+        )
+        (Const 0)
+      )
+    )
+    (Ref addl_med_rate)
+  )
+  )
+  (VALUE fica_tax_ms
+    (Call :"core.add"
+    (Call :"core.add"
+      (Ref ss_tax_ms)
+      (Ref med_tax_ms)
+    )
+    (Ref addl_med_tax_ms)
+  )
+  )
+  (VALUE fica_eff_ms
+    (Call :"core.div"
+    (Ref fica_tax_ms)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE total_tax_ms
+    (Call :"core.add"
+    (Call :"core.add"
+      (Call :"core.add"
+        (Ref fed_tax_ms)
+        (Ref fica_tax_ms)
+      )
+      (Ref state_tax)
+    )
+    (Ref local_tax)
+  )
+  )
+  (VALUE total_eff_ms
+    (Call :"core.div"
+    (Ref total_tax_ms)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE after_tax_ms
+    (Call :"core.sub"
+    (InputRef [:income])
+    (Ref total_tax_ms)
+  )
+  )
+  (VALUE take_home_ms
+    (Call :"core.sub"
+    (Ref after_tax_ms)
+    (InputRef [:retirement_contrib])
+  )
+  )
+  (VALUE taxable_hoh
+    (Call :"agg.max"
+    (Tuple
+      (Call :"core.sub"
+        (InputRef [:income])
+        (InputRef [:fed, :head_of_household, :std])
+      )
+      (Const 0)
+    )
+  )
+  )
+  (VALUE lo_h
+    (InputRef [:fed, :head_of_household, :rates, :bracket, :lo])
+  )
+  (VALUE hi_h
+    (InputRef [:fed, :head_of_household, :rates, :bracket, :hi])
+  )
+  (VALUE rate_h
+    (InputRef [:fed, :head_of_household, :rates, :bracket, :rate])
+  )
+  (VALUE hi_h_eff
+    (Call :__select__
+    (Call :"core.eq"
+      (Ref hi_h)
+      (Const -1)
+    )
+    (Ref big_hi)
+    (Ref hi_h)
+  )
+  )
+  (VALUE amt_h
+    (Call :"core.clamp"
+    (Call :"core.sub"
+      (Ref taxable_hoh)
+      (Ref lo_h)
+    )
+    (Const 0)
+    (Call :"core.sub"
+      (Ref hi_h_eff)
+      (Ref lo_h)
+    )
+  )
+  )
+  (VALUE fed_tax_hoh
+    (Call :"agg.sum"
+    (Call :"core.mul"
+      (Ref amt_h)
+      (Ref rate_h)
+    )
+  )
+  )
+  (VALUE in_br_h
+    (Call :"core.and"
+    (Call :"core.gte"
+      (Ref taxable_hoh)
+      (Ref lo_h)
+    )
+    (Call :"core.lt"
+      (Ref taxable_hoh)
+      (Ref hi_h_eff)
+    )
+  )
+  )
+  (VALUE fed_marginal_hoh
+    (Call :sum
+    (Call :__select__
+      (Ref in_br_h)
+      (Ref rate_h)
+      (Const 0)
+    )
+  )
+  )
+  (VALUE fed_eff_hoh
+    (Call :"core.div"
+    (Ref fed_tax_hoh)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE ss_tax_h
+    (Ref ss_tax_s)
+  )
+  (VALUE med_tax_h
+    (Ref med_tax_s)
+  )
+  (VALUE addl_threshold_hoh
+    (Const 200000.0)
+  )
+  (VALUE addl_med_tax_h
+    (Call :"core.mul"
+    (Call :"agg.max"
+      (Tuple
+        (Call :"core.sub"
+          (InputRef [:income])
+          (Ref addl_threshold_hoh)
+        )
+        (Const 0)
+      )
+    )
+    (Ref addl_med_rate)
+  )
+  )
+  (VALUE fica_tax_hoh
+    (Call :"core.add"
+    (Call :"core.add"
+      (Ref ss_tax_h)
+      (Ref med_tax_h)
+    )
+    (Ref addl_med_tax_h)
+  )
+  )
+  (VALUE fica_eff_hoh
+    (Call :"core.div"
+    (Ref fica_tax_hoh)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE total_tax_hoh
+    (Call :"core.add"
+    (Call :"core.add"
+      (Call :"core.add"
+        (Ref fed_tax_hoh)
+        (Ref fica_tax_hoh)
+      )
+      (Ref state_tax)
+    )
+    (Ref local_tax)
+  )
+  )
+  (VALUE total_eff_hoh
+    (Call :"core.div"
+    (Ref total_tax_hoh)
+    (Call :"agg.max"
+      (Tuple
+        (InputRef [:income])
+        (Const 1.0)
+      )
+    )
+  )
+  )
+  (VALUE after_tax_hoh
+    (Call :"core.sub"
+    (InputRef [:income])
+    (Ref total_tax_hoh)
+  )
+  )
+  (VALUE take_home_hoh
+    (Call :"core.sub"
+    (Ref after_tax_hoh)
+    (InputRef [:retirement_contrib])
+  )
+  )
+  (VALUE summary
+    (Hash
+    (Pair single
+      (Hash
+        (Pair federal
+          (Hash
+            (Pair marginal
+              (Ref fed_marginal_single)
+            )
+            (Pair effective
+              (Ref fed_eff_single)
+            )
+            (Pair tax
+              (Ref fed_tax_single)
+            )
+          )
+        )
+        (Pair fica
+          (Hash
+            (Pair effective
+              (Ref fica_eff_single)
+            )
+            (Pair tax
+              (Ref fica_tax_single)
+            )
+          )
+        )
+        (Pair state
+          (Hash
+            (Pair marginal
+              (InputRef [:state_rate])
+            )
+            (Pair effective
+              (InputRef [:state_rate])
+            )
+            (Pair tax
+              (Ref state_tax)
+            )
+          )
+        )
+        (Pair local
+          (Hash
+            (Pair marginal
+              (InputRef [:local_rate])
+            )
+            (Pair effective
+              (InputRef [:local_rate])
+            )
+            (Pair tax
+              (Ref local_tax)
+            )
+          )
+        )
+        (Pair total
+          (Hash
+            (Pair effective
+              (Ref total_eff_single)
+            )
+            (Pair tax
+              (Ref total_tax_single)
+            )
+          )
+        )
+        (Pair after_tax
+          (Ref after_tax_single)
+        )
+        (Pair retirement_contrib
+          (InputRef [:retirement_contrib])
+        )
+        (Pair take_home
+          (Ref take_home_single)
+        )
+      )
+    )
+    (Pair married_joint
+      (Hash
+        (Pair federal
+          (Hash
+            (Pair marginal
+              (Ref fed_marginal_mj)
+            )
+            (Pair effective
+              (Ref fed_eff_mj)
+            )
+            (Pair tax
+              (Ref fed_tax_mj)
+            )
+          )
+        )
+        (Pair fica
+          (Hash
+            (Pair effective
+              (Ref fica_eff_mj)
+            )
+            (Pair tax
+              (Ref fica_tax_mj)
+            )
+          )
+        )
+        (Pair state
+          (Hash
+            (Pair marginal
+              (InputRef [:state_rate])
+            )
+            (Pair effective
+              (InputRef [:state_rate])
+            )
+            (Pair tax
+              (Ref state_tax)
+            )
+          )
+        )
+        (Pair local
+          (Hash
+            (Pair marginal
+              (InputRef [:local_rate])
+            )
+            (Pair effective
+              (InputRef [:local_rate])
+            )
+            (Pair tax
+              (Ref local_tax)
+            )
+          )
+        )
+        (Pair total
+          (Hash
+            (Pair effective
+              (Ref total_eff_mj)
+            )
+            (Pair tax
+              (Ref total_tax_mj)
+            )
+          )
+        )
+        (Pair after_tax
+          (Ref after_tax_mj)
+        )
+        (Pair retirement_contrib
+          (InputRef [:retirement_contrib])
+        )
+        (Pair take_home
+          (Ref take_home_mj)
+        )
+      )
+    )
+    (Pair married_separate
+      (Hash
+        (Pair federal
+          (Hash
+            (Pair marginal
+              (Ref fed_marginal_ms)
+            )
+            (Pair effective
+              (Ref fed_eff_ms)
+            )
+            (Pair tax
+              (Ref fed_tax_ms)
+            )
+          )
+        )
+        (Pair fica
+          (Hash
+            (Pair effective
+              (Ref fica_eff_ms)
+            )
+            (Pair tax
+              (Ref fica_tax_ms)
+            )
+          )
+        )
+        (Pair state
+          (Hash
+            (Pair marginal
+              (InputRef [:state_rate])
+            )
+            (Pair effective
+              (InputRef [:state_rate])
+            )
+            (Pair tax
+              (Ref state_tax)
+            )
+          )
+        )
+        (Pair local
+          (Hash
+            (Pair marginal
+              (InputRef [:local_rate])
+            )
+            (Pair effective
+              (InputRef [:local_rate])
+            )
+            (Pair tax
+              (Ref local_tax)
+            )
+          )
+        )
+        (Pair total
+          (Hash
+            (Pair effective
+              (Ref total_eff_ms)
+            )
+            (Pair tax
+              (Ref total_tax_ms)
+            )
+          )
+        )
+        (Pair after_tax
+          (Ref after_tax_ms)
+        )
+        (Pair retirement_contrib
+          (InputRef [:retirement_contrib])
+        )
+        (Pair take_home
+          (Ref take_home_ms)
+        )
+      )
+    )
+    (Pair head_of_household
+      (Hash
+        (Pair federal
+          (Hash
+            (Pair marginal
+              (Ref fed_marginal_hoh)
+            )
+            (Pair effective
+              (Ref fed_eff_hoh)
+            )
+            (Pair tax
+              (Ref fed_tax_hoh)
+            )
+          )
+        )
+        (Pair fica
+          (Hash
+            (Pair effective
+              (Ref fica_eff_hoh)
+            )
+            (Pair tax
+              (Ref fica_tax_hoh)
+            )
+          )
+        )
+        (Pair state
+          (Hash
+            (Pair marginal
+              (InputRef [:state_rate])
+            )
+            (Pair effective
+              (InputRef [:state_rate])
+            )
+            (Pair tax
+              (Ref state_tax)
+            )
+          )
+        )
+        (Pair local
+          (Hash
+            (Pair marginal
+              (InputRef [:local_rate])
+            )
+            (Pair effective
+              (InputRef [:local_rate])
+            )
+            (Pair tax
+              (Ref local_tax)
+            )
+          )
+        )
+        (Pair total
+          (Hash
+            (Pair effective
+              (Ref total_eff_hoh)
+            )
+            (Pair tax
+              (Ref total_tax_hoh)
+            )
+          )
+        )
+        (Pair after_tax
+          (Ref after_tax_hoh)
+        )
+        (Pair retirement_contrib
+          (InputRef [:retirement_contrib])
+        )
+        (Pair take_home
+          (Ref take_home_hoh)
+        )
+      )
+    )
+  )
+  )
+)