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/lir_06_const_prop.txt ADDED Viewed

@@ -0,0 +1,2439 @@
+(LIR
+  (Declaration state_tax
+    %t1 = load_input "income" :: float
+    %t2 = load_input "state_rate" :: float
+    %t3 = call core.mul(%t1, %t2) :: float
+    yield %t3
+  )
+  (Declaration local_tax
+    %t4 = load_input "income" :: float
+    %t5 = load_input "local_rate" :: float
+    %t6 = call core.mul(%t4, %t5) :: float
+    yield %t6
+  )
+  (Declaration taxable_single
+    %t7 = load_input "income" :: float
+    %t8 = load_input "fed" :: any
+    %t9 = load_field t8["single"] :: any
+    %t10 = load_field t9["std"] :: float
+    %t11 = call core.sub(%t7, %t10) :: float
+    %t12 = const 0 :: integer
+    %t13 = make_tuple(%t11, %t12) :: tuple<float, integer>
+    %t14 = fold %t13 fn="agg.max" :: float
+    yield %t14
+  )
+  (Declaration lo_s
+    %t15 = load_input "fed" :: array
+    %t16 = load_field t15["single"] :: any
+    %t17 = load_field t16["rates"] :: any
+    loop rates id=L1 in %t17 as el=%rates_el_18, idx=%rates_i_19
+      %t20 = load_field rates_el_18["lo"] :: float
+      yield %t20
+    end_loop
+  )
+  (Declaration hi_s
+    %t21 = load_input "fed" :: array
+    %t22 = load_field t21["single"] :: any
+    %t23 = load_field t22["rates"] :: any
+    loop rates id=L2 in %t23 as el=%rates_el_24, idx=%rates_i_25
+      %t26 = load_field rates_el_24["hi"] :: float
+      yield %t26
+    end_loop
+  )
+  (Declaration rate_s
+    %t27 = load_input "fed" :: array
+    %t28 = load_field t27["single"] :: any
+    %t29 = load_field t28["rates"] :: any
+    loop rates id=L3 in %t29 as el=%rates_el_30, idx=%rates_i_31
+      %t32 = load_field rates_el_30["rate"] :: float
+      yield %t32
+    end_loop
+  )
+  (Declaration big_hi
+    %t33 = const 100000000000.0 :: float
+    yield %t33
+  )
+  (Declaration hi_s_eff
+    %t34 = load_input "fed" :: array
+    %t35 = load_field t34["single"] :: any
+    %t36 = load_field t35["rates"] :: any
+    %t40 = const -1 :: integer
+    %t42 = const 100000000000.0 :: float
+    loop rates id=L4 in %t36 as el=%rates_el_37, idx=%rates_i_38
+      %t631 = load_field rates_el_37["hi"] :: float
+      %t41 = call core.eq(%t631, %t40) :: boolean
+      %t44 = select %t41, %t42, %t631 :: float
+      yield %t44
+    end_loop
+  )
+  (Declaration amt_s
+    %t45 = load_input "fed" :: array
+    %t46 = load_field t45["single"] :: any
+    %t47 = load_field t46["rates"] :: any
+    %t641 = const 0 :: integer
+    %t652 = const -1 :: integer
+    %t654 = const 100000000000.0 :: float
+    loop rates id=L5 in %t47 as el=%rates_el_48, idx=%rates_i_49
+      %t647 = load_field rates_el_48["lo"] :: float
+      %t660 = load_field rates_el_48["hi"] :: float
+      %t52 = call core.sub(%t50, %t647) :: float
+      %t653 = call core.eq(%t660, %t652) :: boolean
+      %t656 = select %t653, %t654, %t660 :: float
+      %t56 = call core.sub(%t656, %t647) :: float
+      %t57 = call core.clamp(%t52, %t641, %t56) :: float
+      yield %t57
+    end_loop
+  )
+  (Declaration fed_tax_single
+    %acc_58 = decl_acc :: float
+    %t59 = load_input "fed" :: array
+    %t60 = load_field t59["single"] :: any
+    %t61 = load_field t60["rates"] :: any
+    %t680 = load_input "income" :: float
+    %t681 = load_input "fed" :: any
+    %t685 = const 0 :: integer
+    %t696 = const -1 :: integer
+    %t698 = const 100000000000.0 :: float
+    %t682 = load_field t681["single"] :: any
+    %t683 = load_field t682["std"] :: float
+    %t684 = call core.sub(%t680, %t683) :: float
+    %t686 = make_tuple(%t684, %t685) :: tuple<float, integer>
+    %t687 = fold %t686 fn="agg.max" :: float
+    loop rates id=L6 in %t61 as el=%rates_el_62, idx=%rates_i_63
+      %t691 = load_field rates_el_62["lo"] :: float
+      %t704 = load_field rates_el_62["hi"] :: float
+      %t716 = load_field rates_el_62["rate"] :: float
+      %t697 = call core.eq(%t704, %t696) :: boolean
+      %t700 = select %t697, %t698, %t704 :: float
+      %t678 = call core.sub(%t700, %t691) :: float
+      %t674 = call core.sub(%t687, %t691) :: float
+      %t679 = call core.clamp(%t674, %t685, %t678) :: float
+      %t66 = call core.mul(%t679, %t716) :: float
+      %acc_58 = acc_add agg.sum(%acc_58, %t66) :: float
+    end_loop
+    %t67 = acc_load %acc_58 :: float
+    yield %t67
+  )
+  (Declaration in_br_s
+    %t68 = load_input "fed" :: array
+    %t69 = load_field t68["single"] :: any
+    %t70 = load_field t69["rates"] :: any
+    %t741 = const -1 :: integer
+    %t743 = const 100000000000.0 :: float
+    loop rates id=L7 in %t70 as el=%rates_el_71, idx=%rates_i_72
+      %t736 = load_field rates_el_71["lo"] :: float
+      %t749 = load_field rates_el_71["hi"] :: float
+      %t75 = call core.gte(%t73, %t736) :: boolean
+      %t742 = call core.eq(%t749, %t741) :: boolean
+      %t745 = select %t742, %t743, %t749 :: float
+      %t78 = call core.lt(%t76, %t745) :: boolean
+      %t79 = call core.and(%t75, %t78) :: boolean
+      yield %t79
+    end_loop
+  )
+  (Declaration fed_marginal_single
+    %acc_80 = decl_acc :: float
+    %t81 = load_input "fed" :: array
+    %t82 = load_field t81["single"] :: any
+    %t83 = load_field t82["rates"] :: any
+    %t764 = load_input "income" :: float
+    %t765 = load_input "fed" :: any
+    %t769 = const 0 :: integer
+    %t788 = const -1 :: integer
+    %t790 = const 100000000000.0 :: float
+    %t766 = load_field t765["single"] :: any
+    %t767 = load_field t766["std"] :: float
+    %t768 = call core.sub(%t764, %t767) :: float
+    %t770 = make_tuple(%t768, %t769) :: tuple<float, integer>
+    %t771 = fold %t770 fn="agg.max" :: float
+    loop rates id=L8 in %t83 as el=%rates_el_84, idx=%rates_i_85
+      %t783 = load_field rates_el_84["lo"] :: float
+      %t796 = load_field rates_el_84["hi"] :: float
+      %t804 = load_field rates_el_84["rate"] :: float
+      %t789 = call core.eq(%t796, %t788) :: boolean
+      %t792 = select %t789, %t790, %t796 :: float
+      %t760 = call core.gte(%t771, %t783) :: boolean
+      %t762 = call core.lt(%t771, %t792) :: boolean
+      %t763 = call core.and(%t760, %t762) :: boolean
+      %t89 = select %t763, %t804, %t769 :: float
+      %acc_80 = acc_add agg.sum(%acc_80, %t89) :: float
+    end_loop
+    %t90 = acc_load %acc_80 :: float
+    yield %t90
+  )
+  (Declaration fed_eff_single
+    %acc806 = decl_acc :: float
+    %t807 = load_input "fed" :: array
+    %t808 = load_field t807["single"] :: any
+    %t809 = load_field t808["rates"] :: any
+    %t827 = load_input "income" :: float
+    %t828 = load_input "fed" :: any
+    %t832 = const 0 :: integer
+    %t843 = const -1 :: integer
+    %t845 = const 100000000000.0 :: float
+    %t829 = load_field t828["single"] :: any
+    %t830 = load_field t829["std"] :: float
+    %t831 = call core.sub(%t827, %t830) :: float
+    %t833 = make_tuple(%t831, %t832) :: tuple<float, integer>
+    %t834 = fold %t833 fn="agg.max" :: float
+    loop rates id=L33 in %t809 as el=%t810, idx=%t811
+      %t838 = load_field t810["lo"] :: float
+      %t851 = load_field t810["hi"] :: float
+      %t863 = load_field t810["rate"] :: float
+      %t844 = call core.eq(%t851, %t843) :: boolean
+      %t847 = select %t844, %t845, %t851 :: float
+      %t825 = call core.sub(%t847, %t838) :: float
+      %t821 = call core.sub(%t834, %t838) :: float
+      %t826 = call core.clamp(%t821, %t832, %t825) :: float
+      %t814 = call core.mul(%t826, %t863) :: float
+      %acc806 = acc_add agg.sum(%acc806, %t814) :: float
+    end_loop
+    %t815 = acc_load %acc806 :: float
+    %t93 = const 1.0 :: float
+    %t94 = make_tuple(%t827, %t93) :: tuple<float>
+    %t95 = fold %t94 fn="agg.max" :: float
+    %t96 = call core.div(%t815, %t95) :: float
+    yield %t96
+  )
+  (Declaration ss_wage_base
+    %t97 = const 168600.0 :: float
+    yield %t97
+  )
+  (Declaration ss_rate
+    %t98 = const 0.062 :: float
+    yield %t98
+  )
+  (Declaration ss_tax_s
+    %t99 = load_input "income" :: float
+    %t100 = const 168600.0 :: float
+    %t101 = make_tuple(%t99, %t100) :: tuple<float>
+    %t102 = fold %t101 fn="agg.min" :: float
+    %t103 = const 0.062 :: float
+    %t104 = call core.mul(%t102, %t103) :: float
+    yield %t104
+  )
+  (Declaration med_base_rate
+    %t105 = const 0.0145 :: float
+    yield %t105
+  )
+  (Declaration med_tax_s
+    %t106 = load_input "income" :: float
+    %t107 = const 0.0145 :: float
+    %t108 = call core.mul(%t106, %t107) :: float
+    yield %t108
+  )
+  (Declaration addl_threshold_single
+    %t109 = const 200000.0 :: float
+    yield %t109
+  )
+  (Declaration addl_med_rate
+    %t110 = const 0.009 :: float
+    yield %t110
+  )
+  (Declaration addl_med_tax_s
+    %t111 = load_input "income" :: float
+    %t112 = const 200000.0 :: float
+    %t113 = call core.sub(%t111, %t112) :: float
+    %t114 = const 0 :: integer
+    %t115 = make_tuple(%t113, %t114) :: tuple<float, integer>
+    %t116 = fold %t115 fn="agg.max" :: float
+    %t117 = const 0.009 :: float
+    %t118 = call core.mul(%t116, %t117) :: float
+    yield %t118
+  )
+  (Declaration fica_tax_single
+    %t864 = load_input "income" :: float
+    %t865 = const 168600.0 :: float
+    %t866 = make_tuple(%t864, %t865) :: tuple<float>
+    %t867 = fold %t866 fn="agg.min" :: float
+    %t868 = const 0.062 :: float
+    %t869 = call core.mul(%t867, %t868) :: float
+    %t871 = const 0.0145 :: float
+    %t872 = call core.mul(%t864, %t871) :: float
+    %t121 = call core.add(%t869, %t872) :: float
+    %t874 = const 200000.0 :: float
+    %t875 = call core.sub(%t864, %t874) :: float
+    %t876 = const 0 :: integer
+    %t877 = make_tuple(%t875, %t876) :: tuple<float, integer>
+    %t878 = fold %t877 fn="agg.max" :: float
+    %t879 = const 0.009 :: float
+    %t880 = call core.mul(%t878, %t879) :: float
+    %t123 = call core.add(%t121, %t880) :: float
+    yield %t123
+  )
+  (Declaration fica_eff_single
+    %t886 = load_input "income" :: float
+    %t887 = const 168600.0 :: float
+    %t888 = make_tuple(%t886, %t887) :: tuple<float>
+    %t889 = fold %t888 fn="agg.min" :: float
+    %t890 = const 0.062 :: float
+    %t891 = call core.mul(%t889, %t890) :: float
+    %t893 = const 0.0145 :: float
+    %t894 = call core.mul(%t886, %t893) :: float
+    %t883 = call core.add(%t891, %t894) :: float
+    %t896 = const 200000.0 :: float
+    %t897 = call core.sub(%t886, %t896) :: float
+    %t898 = const 0 :: integer
+    %t899 = make_tuple(%t897, %t898) :: tuple<float, integer>
+    %t900 = fold %t899 fn="agg.max" :: float
+    %t901 = const 0.009 :: float
+    %t902 = call core.mul(%t900, %t901) :: float
+    %t885 = call core.add(%t883, %t902) :: float
+    %t126 = const 1.0 :: float
+    %t127 = make_tuple(%t886, %t126) :: tuple<float>
+    %t128 = fold %t127 fn="agg.max" :: float
+    %t129 = call core.div(%t885, %t128) :: float
+    yield %t129
+  )
+  (Declaration total_tax_single
+    %acc904 = decl_acc :: float
+    %t905 = load_input "fed" :: array
+    %t906 = load_field t905["single"] :: any
+    %t907 = load_field t906["rates"] :: any
+    %t925 = load_input "income" :: float
+    %t926 = load_input "fed" :: any
+    %t930 = const 0 :: integer
+    %t941 = const -1 :: integer
+    %t943 = const 100000000000.0 :: float
+    %t927 = load_field t926["single"] :: any
+    %t928 = load_field t927["std"] :: float
+    %t929 = call core.sub(%t925, %t928) :: float
+    %t931 = make_tuple(%t929, %t930) :: tuple<float, integer>
+    %t932 = fold %t931 fn="agg.max" :: float
+    loop rates id=L34 in %t907 as el=%t908, idx=%t909
+      %t936 = load_field t908["lo"] :: float
+      %t949 = load_field t908["hi"] :: float
+      %t961 = load_field t908["rate"] :: float
+      %t942 = call core.eq(%t949, %t941) :: boolean
+      %t945 = select %t942, %t943, %t949 :: float
+      %t923 = call core.sub(%t945, %t936) :: float
+      %t919 = call core.sub(%t932, %t936) :: float
+      %t924 = call core.clamp(%t919, %t930, %t923) :: float
+      %t912 = call core.mul(%t924, %t961) :: float
+      %acc904 = acc_add agg.sum(%acc904, %t912) :: float
+    end_loop
+    %t913 = acc_load %acc904 :: float
+    %t968 = const 168600.0 :: float
+    %t969 = make_tuple(%t925, %t968) :: tuple<float>
+    %t970 = fold %t969 fn="agg.min" :: float
+    %t971 = const 0.062 :: float
+    %t972 = call core.mul(%t970, %t971) :: float
+    %t974 = const 0.0145 :: float
+    %t975 = call core.mul(%t925, %t974) :: float
+    %t964 = call core.add(%t972, %t975) :: float
+    %t977 = const 200000.0 :: float
+    %t978 = call core.sub(%t925, %t977) :: float
+    %t980 = make_tuple(%t978, %t930) :: tuple<float, integer>
+    %t981 = fold %t980 fn="agg.max" :: float
+    %t982 = const 0.009 :: float
+    %t983 = call core.mul(%t981, %t982) :: float
+    %t966 = call core.add(%t964, %t983) :: float
+    %t132 = call core.add(%t913, %t966) :: float
+    %t985 = load_input "state_rate" :: float
+    %t986 = call core.mul(%t925, %t985) :: float
+    %t134 = call core.add(%t132, %t986) :: float
+    %t988 = load_input "local_rate" :: float
+    %t989 = call core.mul(%t925, %t988) :: float
+    %t136 = call core.add(%t134, %t989) :: float
+    yield %t136
+  )
+  (Declaration total_eff_single
+    %acc998 = decl_acc :: float
+    %t999 = load_input "fed" :: array
+    %t1000 = load_field t999["single"] :: any
+    %t1001 = load_field t1000["rates"] :: any
+    %t1019 = load_input "income" :: float
+    %t1020 = load_input "fed" :: any
+    %t1024 = const 0 :: integer
+    %t1035 = const -1 :: integer
+    %t1037 = const 100000000000.0 :: float
+    %t1021 = load_field t1020["single"] :: any
+    %t1022 = load_field t1021["std"] :: float
+    %t1023 = call core.sub(%t1019, %t1022) :: float
+    %t1025 = make_tuple(%t1023, %t1024) :: tuple<float, integer>
+    %t1026 = fold %t1025 fn="agg.max" :: float
+    loop rates id=L35 in %t1001 as el=%t1002, idx=%t1003
+      %t1030 = load_field t1002["lo"] :: float
+      %t1043 = load_field t1002["hi"] :: float
+      %t1055 = load_field t1002["rate"] :: float
+      %t1036 = call core.eq(%t1043, %t1035) :: boolean
+      %t1039 = select %t1036, %t1037, %t1043 :: float
+      %t1017 = call core.sub(%t1039, %t1030) :: float
+      %t1013 = call core.sub(%t1026, %t1030) :: float
+      %t1018 = call core.clamp(%t1013, %t1024, %t1017) :: float
+      %t1006 = call core.mul(%t1018, %t1055) :: float
+      %acc998 = acc_add agg.sum(%acc998, %t1006) :: float
+    end_loop
+    %t1007 = acc_load %acc998 :: float
+    %t1062 = const 168600.0 :: float
+    %t1063 = make_tuple(%t1019, %t1062) :: tuple<float>
+    %t1064 = fold %t1063 fn="agg.min" :: float
+    %t1065 = const 0.062 :: float
+    %t1066 = call core.mul(%t1064, %t1065) :: float
+    %t1068 = const 0.0145 :: float
+    %t1069 = call core.mul(%t1019, %t1068) :: float
+    %t1058 = call core.add(%t1066, %t1069) :: float
+    %t1071 = const 200000.0 :: float
+    %t1072 = call core.sub(%t1019, %t1071) :: float
+    %t1074 = make_tuple(%t1072, %t1024) :: tuple<float, integer>
+    %t1075 = fold %t1074 fn="agg.max" :: float
+    %t1076 = const 0.009 :: float
+    %t1077 = call core.mul(%t1075, %t1076) :: float
+    %t1060 = call core.add(%t1058, %t1077) :: float
+    %t992 = call core.add(%t1007, %t1060) :: float
+    %t1079 = load_input "state_rate" :: float
+    %t1080 = call core.mul(%t1019, %t1079) :: float
+    %t994 = call core.add(%t992, %t1080) :: float
+    %t1082 = load_input "local_rate" :: float
+    %t1083 = call core.mul(%t1019, %t1082) :: float
+    %t996 = call core.add(%t994, %t1083) :: float
+    %t139 = const 1.0 :: float
+    %t140 = make_tuple(%t1019, %t139) :: tuple<float>
+    %t141 = fold %t140 fn="agg.max" :: float
+    %t142 = call core.div(%t996, %t141) :: float
+    yield %t142
+  )
+  (Declaration after_tax_single
+    %t143 = load_input "income" :: float
+    %acc1092 = decl_acc :: float
+    %t1093 = load_input "fed" :: array
+    %t1094 = load_field t1093["single"] :: any
+    %t1095 = load_field t1094["rates"] :: any
+    %t1114 = load_input "fed" :: any
+    %t1118 = const 0 :: integer
+    %t1129 = const -1 :: integer
+    %t1131 = const 100000000000.0 :: float
+    %t1115 = load_field t1114["single"] :: any
+    %t1116 = load_field t1115["std"] :: float
+    %t1117 = call core.sub(%t143, %t1116) :: float
+    %t1119 = make_tuple(%t1117, %t1118) :: tuple<float, integer>
+    %t1120 = fold %t1119 fn="agg.max" :: float
+    loop rates id=L36 in %t1095 as el=%t1096, idx=%t1097
+      %t1124 = load_field t1096["lo"] :: float
+      %t1137 = load_field t1096["hi"] :: float
+      %t1149 = load_field t1096["rate"] :: float
+      %t1130 = call core.eq(%t1137, %t1129) :: boolean
+      %t1133 = select %t1130, %t1131, %t1137 :: float
+      %t1111 = call core.sub(%t1133, %t1124) :: float
+      %t1107 = call core.sub(%t1120, %t1124) :: float
+      %t1112 = call core.clamp(%t1107, %t1118, %t1111) :: float
+      %t1100 = call core.mul(%t1112, %t1149) :: float
+      %acc1092 = acc_add agg.sum(%acc1092, %t1100) :: float
+    end_loop
+    %t1101 = acc_load %acc1092 :: float
+    %t1156 = const 168600.0 :: float
+    %t1157 = make_tuple(%t143, %t1156) :: tuple<float>
+    %t1158 = fold %t1157 fn="agg.min" :: float
+    %t1159 = const 0.062 :: float
+    %t1160 = call core.mul(%t1158, %t1159) :: float
+    %t1162 = const 0.0145 :: float
+    %t1163 = call core.mul(%t143, %t1162) :: float
+    %t1152 = call core.add(%t1160, %t1163) :: float
+    %t1165 = const 200000.0 :: float
+    %t1166 = call core.sub(%t143, %t1165) :: float
+    %t1168 = make_tuple(%t1166, %t1118) :: tuple<float, integer>
+    %t1169 = fold %t1168 fn="agg.max" :: float
+    %t1170 = const 0.009 :: float
+    %t1171 = call core.mul(%t1169, %t1170) :: float
+    %t1154 = call core.add(%t1152, %t1171) :: float
+    %t1086 = call core.add(%t1101, %t1154) :: float
+    %t1173 = load_input "state_rate" :: float
+    %t1174 = call core.mul(%t143, %t1173) :: float
+    %t1088 = call core.add(%t1086, %t1174) :: float
+    %t1176 = load_input "local_rate" :: float
+    %t1177 = call core.mul(%t143, %t1176) :: float
+    %t1090 = call core.add(%t1088, %t1177) :: float
+    %t145 = call core.sub(%t143, %t1090) :: float
+    yield %t145
+  )
+  (Declaration take_home_single
+    %t1178 = load_input "income" :: float
+    %acc1189 = decl_acc :: float
+    %t1190 = load_input "fed" :: array
+    %t1191 = load_field t1190["single"] :: any
+    %t1192 = load_field t1191["rates"] :: any
+    %t1211 = load_input "fed" :: any
+    %t1215 = const 0 :: integer
+    %t1226 = const -1 :: integer
+    %t1228 = const 100000000000.0 :: float
+    %t1212 = load_field t1211["single"] :: any
+    %t1213 = load_field t1212["std"] :: float
+    %t1214 = call core.sub(%t1178, %t1213) :: float
+    %t1216 = make_tuple(%t1214, %t1215) :: tuple<float, integer>
+    %t1217 = fold %t1216 fn="agg.max" :: float
+    loop rates id=L37 in %t1192 as el=%t1193, idx=%t1194
+      %t1221 = load_field t1193["lo"] :: float
+      %t1234 = load_field t1193["hi"] :: float
+      %t1246 = load_field t1193["rate"] :: float
+      %t1227 = call core.eq(%t1234, %t1226) :: boolean
+      %t1230 = select %t1227, %t1228, %t1234 :: float
+      %t1208 = call core.sub(%t1230, %t1221) :: float
+      %t1204 = call core.sub(%t1217, %t1221) :: float
+      %t1209 = call core.clamp(%t1204, %t1215, %t1208) :: float
+      %t1197 = call core.mul(%t1209, %t1246) :: float
+      %acc1189 = acc_add agg.sum(%acc1189, %t1197) :: float
+    end_loop
+    %t1198 = acc_load %acc1189 :: float
+    %t1253 = const 168600.0 :: float
+    %t1254 = make_tuple(%t1178, %t1253) :: tuple<float>
+    %t1255 = fold %t1254 fn="agg.min" :: float
+    %t1256 = const 0.062 :: float
+    %t1257 = call core.mul(%t1255, %t1256) :: float
+    %t1259 = const 0.0145 :: float
+    %t1260 = call core.mul(%t1178, %t1259) :: float
+    %t1249 = call core.add(%t1257, %t1260) :: float
+    %t1262 = const 200000.0 :: float
+    %t1263 = call core.sub(%t1178, %t1262) :: float
+    %t1265 = make_tuple(%t1263, %t1215) :: tuple<float, integer>
+    %t1266 = fold %t1265 fn="agg.max" :: float
+    %t1267 = const 0.009 :: float
+    %t1268 = call core.mul(%t1266, %t1267) :: float
+    %t1251 = call core.add(%t1249, %t1268) :: float
+    %t1183 = call core.add(%t1198, %t1251) :: float
+    %t1270 = load_input "state_rate" :: float
+    %t1271 = call core.mul(%t1178, %t1270) :: float
+    %t1185 = call core.add(%t1183, %t1271) :: float
+    %t1273 = load_input "local_rate" :: float
+    %t1274 = call core.mul(%t1178, %t1273) :: float
+    %t1187 = call core.add(%t1185, %t1274) :: float
+    %t1180 = call core.sub(%t1178, %t1187) :: float
+    %t147 = load_input "retirement_contrib" :: float
+    %t148 = call core.sub(%t1180, %t147) :: float
+    yield %t148
+  )
+  (Declaration taxable_mj
+    %t149 = load_input "income" :: float
+    %t150 = load_input "fed" :: any
+    %t151 = load_field t150["married_joint"] :: any
+    %t152 = load_field t151["std"] :: float
+    %t153 = call core.sub(%t149, %t152) :: float
+    %t154 = const 0 :: integer
+    %t155 = make_tuple(%t153, %t154) :: tuple<float, integer>
+    %t156 = fold %t155 fn="agg.max" :: float
+    yield %t156
+  )
+  (Declaration lo_mj
+    %t157 = load_input "fed" :: array
+    %t158 = load_field t157["married_joint"] :: any
+    %t159 = load_field t158["rates"] :: any
+    loop rates id=L9 in %t159 as el=%rates_el_160, idx=%rates_i_161
+      %t162 = load_field rates_el_160["lo"] :: float
+      yield %t162
+    end_loop
+  )
+  (Declaration hi_mj
+    %t163 = load_input "fed" :: array
+    %t164 = load_field t163["married_joint"] :: any
+    %t165 = load_field t164["rates"] :: any
+    loop rates id=L10 in %t165 as el=%rates_el_166, idx=%rates_i_167
+      %t168 = load_field rates_el_166["hi"] :: float
+      yield %t168
+    end_loop
+  )
+  (Declaration rate_mj
+    %t169 = load_input "fed" :: array
+    %t170 = load_field t169["married_joint"] :: any
+    %t171 = load_field t170["rates"] :: any
+    loop rates id=L11 in %t171 as el=%rates_el_172, idx=%rates_i_173
+      %t174 = load_field rates_el_172["rate"] :: float
+      yield %t174
+    end_loop
+  )
+  (Declaration hi_mj_eff
+    %t175 = load_input "fed" :: array
+    %t176 = load_field t175["married_joint"] :: any
+    %t177 = load_field t176["rates"] :: any
+    %t181 = const -1 :: integer
+    %t183 = const 100000000000.0 :: float
+    loop rates id=L12 in %t177 as el=%rates_el_178, idx=%rates_i_179
+      %t1278 = load_field rates_el_178["hi"] :: float
+      %t182 = call core.eq(%t1278, %t181) :: boolean
+      %t185 = select %t182, %t183, %t1278 :: float
+      yield %t185
+    end_loop
+  )
+  (Declaration amt_mj
+    %t186 = load_input "fed" :: array
+    %t187 = load_field t186["married_joint"] :: any
+    %t188 = load_field t187["rates"] :: any
+    %t1288 = const 0 :: integer
+    %t1299 = const -1 :: integer
+    %t1301 = const 100000000000.0 :: float
+    loop rates id=L13 in %t188 as el=%rates_el_189, idx=%rates_i_190
+      %t1294 = load_field rates_el_189["lo"] :: float
+      %t1307 = load_field rates_el_189["hi"] :: float
+      %t193 = call core.sub(%t191, %t1294) :: float
+      %t1300 = call core.eq(%t1307, %t1299) :: boolean
+      %t1303 = select %t1300, %t1301, %t1307 :: float
+      %t197 = call core.sub(%t1303, %t1294) :: float
+      %t198 = call core.clamp(%t193, %t1288, %t197) :: float
+      yield %t198
+    end_loop
+  )
+  (Declaration fed_tax_mj
+    %acc_199 = decl_acc :: float
+    %t200 = load_input "fed" :: array
+    %t201 = load_field t200["married_joint"] :: any
+    %t202 = load_field t201["rates"] :: any
+    %t1327 = load_input "income" :: float
+    %t1328 = load_input "fed" :: any
+    %t1332 = const 0 :: integer
+    %t1343 = const -1 :: integer
+    %t1345 = const 100000000000.0 :: float
+    %t1329 = load_field t1328["married_joint"] :: any
+    %t1330 = load_field t1329["std"] :: float
+    %t1331 = call core.sub(%t1327, %t1330) :: float
+    %t1333 = make_tuple(%t1331, %t1332) :: tuple<float, integer>
+    %t1334 = fold %t1333 fn="agg.max" :: float
+    loop rates id=L14 in %t202 as el=%rates_el_203, idx=%rates_i_204
+      %t1338 = load_field rates_el_203["lo"] :: float
+      %t1351 = load_field rates_el_203["hi"] :: float
+      %t1363 = load_field rates_el_203["rate"] :: float
+      %t1344 = call core.eq(%t1351, %t1343) :: boolean
+      %t1347 = select %t1344, %t1345, %t1351 :: float
+      %t1325 = call core.sub(%t1347, %t1338) :: float
+      %t1321 = call core.sub(%t1334, %t1338) :: float
+      %t1326 = call core.clamp(%t1321, %t1332, %t1325) :: float
+      %t207 = call core.mul(%t1326, %t1363) :: float
+      %acc_199 = acc_add agg.sum(%acc_199, %t207) :: float
+    end_loop
+    %t208 = acc_load %acc_199 :: float
+    yield %t208
+  )
+  (Declaration in_br_mj
+    %t209 = load_input "fed" :: array
+    %t210 = load_field t209["married_joint"] :: any
+    %t211 = load_field t210["rates"] :: any
+    %t1388 = const -1 :: integer
+    %t1390 = const 100000000000.0 :: float
+    loop rates id=L15 in %t211 as el=%rates_el_212, idx=%rates_i_213
+      %t1383 = load_field rates_el_212["lo"] :: float
+      %t1396 = load_field rates_el_212["hi"] :: float
+      %t216 = call core.gte(%t214, %t1383) :: boolean
+      %t1389 = call core.eq(%t1396, %t1388) :: boolean
+      %t1392 = select %t1389, %t1390, %t1396 :: float
+      %t219 = call core.lt(%t217, %t1392) :: boolean
+      %t220 = call core.and(%t216, %t219) :: boolean
+      yield %t220
+    end_loop
+  )
+  (Declaration fed_marginal_mj
+    %acc_221 = decl_acc :: float
+    %t222 = load_input "fed" :: array
+    %t223 = load_field t222["married_joint"] :: any
+    %t224 = load_field t223["rates"] :: any
+    %t1411 = load_input "income" :: float
+    %t1412 = load_input "fed" :: any
+    %t1416 = const 0 :: integer
+    %t1435 = const -1 :: integer
+    %t1437 = const 100000000000.0 :: float
+    %t1413 = load_field t1412["married_joint"] :: any
+    %t1414 = load_field t1413["std"] :: float
+    %t1415 = call core.sub(%t1411, %t1414) :: float
+    %t1417 = make_tuple(%t1415, %t1416) :: tuple<float, integer>
+    %t1418 = fold %t1417 fn="agg.max" :: float
+    loop rates id=L16 in %t224 as el=%rates_el_225, idx=%rates_i_226
+      %t1430 = load_field rates_el_225["lo"] :: float
+      %t1443 = load_field rates_el_225["hi"] :: float
+      %t1451 = load_field rates_el_225["rate"] :: float
+      %t1436 = call core.eq(%t1443, %t1435) :: boolean
+      %t1439 = select %t1436, %t1437, %t1443 :: float
+      %t1407 = call core.gte(%t1418, %t1430) :: boolean
+      %t1409 = call core.lt(%t1418, %t1439) :: boolean
+      %t1410 = call core.and(%t1407, %t1409) :: boolean
+      %t230 = select %t1410, %t1451, %t1416 :: float
+      %acc_221 = acc_add agg.sum(%acc_221, %t230) :: float
+    end_loop
+    %t231 = acc_load %acc_221 :: float
+    yield %t231
+  )
+  (Declaration fed_eff_mj
+    %acc1453 = decl_acc :: float
+    %t1454 = load_input "fed" :: array
+    %t1455 = load_field t1454["married_joint"] :: any
+    %t1456 = load_field t1455["rates"] :: any
+    %t1474 = load_input "income" :: float
+    %t1475 = load_input "fed" :: any
+    %t1479 = const 0 :: integer
+    %t1490 = const -1 :: integer
+    %t1492 = const 100000000000.0 :: float
+    %t1476 = load_field t1475["married_joint"] :: any
+    %t1477 = load_field t1476["std"] :: float
+    %t1478 = call core.sub(%t1474, %t1477) :: float
+    %t1480 = make_tuple(%t1478, %t1479) :: tuple<float, integer>
+    %t1481 = fold %t1480 fn="agg.max" :: float
+    loop rates id=L38 in %t1456 as el=%t1457, idx=%t1458
+      %t1485 = load_field t1457["lo"] :: float
+      %t1498 = load_field t1457["hi"] :: float
+      %t1510 = load_field t1457["rate"] :: float
+      %t1491 = call core.eq(%t1498, %t1490) :: boolean
+      %t1494 = select %t1491, %t1492, %t1498 :: float
+      %t1472 = call core.sub(%t1494, %t1485) :: float
+      %t1468 = call core.sub(%t1481, %t1485) :: float
+      %t1473 = call core.clamp(%t1468, %t1479, %t1472) :: float
+      %t1461 = call core.mul(%t1473, %t1510) :: float
+      %acc1453 = acc_add agg.sum(%acc1453, %t1461) :: float
+    end_loop
+    %t1462 = acc_load %acc1453 :: float
+    %t234 = const 1.0 :: float
+    %t235 = make_tuple(%t1474, %t234) :: tuple<float>
+    %t236 = fold %t235 fn="agg.max" :: float
+    %t237 = call core.div(%t1462, %t236) :: float
+    yield %t237
+  )
+  (Declaration ss_tax_mj
+    %t1511 = load_input "income" :: float
+    %t1512 = const 168600.0 :: float
+    %t1513 = make_tuple(%t1511, %t1512) :: tuple<float>
+    %t1514 = fold %t1513 fn="agg.min" :: float
+    %t1515 = const 0.062 :: float
+    %t1516 = call core.mul(%t1514, %t1515) :: float
+    yield %t1516
+  )
+  (Declaration med_tax_mj
+    %t1517 = load_input "income" :: float
+    %t1518 = const 0.0145 :: float
+    %t1519 = call core.mul(%t1517, %t1518) :: float
+    yield %t1519
+  )
+  (Declaration addl_threshold_mj
+    %t240 = const 250000.0 :: float
+    yield %t240
+  )
+  (Declaration addl_med_tax_mj
+    %t241 = load_input "income" :: float
+    %t242 = const 250000.0 :: float
+    %t243 = call core.sub(%t241, %t242) :: float
+    %t244 = const 0 :: integer
+    %t245 = make_tuple(%t243, %t244) :: tuple<float, integer>
+    %t246 = fold %t245 fn="agg.max" :: float
+    %t247 = const 0.009 :: float
+    %t248 = call core.mul(%t246, %t247) :: float
+    yield %t248
+  )
+  (Declaration fica_tax_mj
+    %t1521 = load_input "income" :: float
+    %t1522 = const 168600.0 :: float
+    %t1523 = make_tuple(%t1521, %t1522) :: tuple<float>
+    %t1524 = fold %t1523 fn="agg.min" :: float
+    %t1525 = const 0.062 :: float
+    %t1526 = call core.mul(%t1524, %t1525) :: float
+    %t1529 = const 0.0145 :: float
+    %t1530 = call core.mul(%t1521, %t1529) :: float
+    %t251 = call core.add(%t1526, %t1530) :: float
+    %t1532 = const 250000.0 :: float
+    %t1533 = call core.sub(%t1521, %t1532) :: float
+    %t1534 = const 0 :: integer
+    %t1535 = make_tuple(%t1533, %t1534) :: tuple<float, integer>
+    %t1536 = fold %t1535 fn="agg.max" :: float
+    %t1537 = const 0.009 :: float
+    %t1538 = call core.mul(%t1536, %t1537) :: float
+    %t253 = call core.add(%t251, %t1538) :: float
+    yield %t253
+  )
+  (Declaration fica_eff_mj
+    %t1545 = load_input "income" :: float
+    %t1546 = const 168600.0 :: float
+    %t1547 = make_tuple(%t1545, %t1546) :: tuple<float>
+    %t1548 = fold %t1547 fn="agg.min" :: float
+    %t1549 = const 0.062 :: float
+    %t1550 = call core.mul(%t1548, %t1549) :: float
+    %t1553 = const 0.0145 :: float
+    %t1554 = call core.mul(%t1545, %t1553) :: float
+    %t1541 = call core.add(%t1550, %t1554) :: float
+    %t1556 = const 250000.0 :: float
+    %t1557 = call core.sub(%t1545, %t1556) :: float
+    %t1558 = const 0 :: integer
+    %t1559 = make_tuple(%t1557, %t1558) :: tuple<float, integer>
+    %t1560 = fold %t1559 fn="agg.max" :: float
+    %t1561 = const 0.009 :: float
+    %t1562 = call core.mul(%t1560, %t1561) :: float
+    %t1543 = call core.add(%t1541, %t1562) :: float
+    %t256 = const 1.0 :: float
+    %t257 = make_tuple(%t1545, %t256) :: tuple<float>
+    %t258 = fold %t257 fn="agg.max" :: float
+    %t259 = call core.div(%t1543, %t258) :: float
+    yield %t259
+  )
+  (Declaration total_tax_mj
+    %acc1564 = decl_acc :: float
+    %t1565 = load_input "fed" :: array
+    %t1566 = load_field t1565["married_joint"] :: any
+    %t1567 = load_field t1566["rates"] :: any
+    %t1585 = load_input "income" :: float
+    %t1586 = load_input "fed" :: any
+    %t1590 = const 0 :: integer
+    %t1601 = const -1 :: integer
+    %t1603 = const 100000000000.0 :: float
+    %t1587 = load_field t1586["married_joint"] :: any
+    %t1588 = load_field t1587["std"] :: float
+    %t1589 = call core.sub(%t1585, %t1588) :: float
+    %t1591 = make_tuple(%t1589, %t1590) :: tuple<float, integer>
+    %t1592 = fold %t1591 fn="agg.max" :: float
+    loop rates id=L39 in %t1567 as el=%t1568, idx=%t1569
+      %t1596 = load_field t1568["lo"] :: float
+      %t1609 = load_field t1568["hi"] :: float
+      %t1621 = load_field t1568["rate"] :: float
+      %t1602 = call core.eq(%t1609, %t1601) :: boolean
+      %t1605 = select %t1602, %t1603, %t1609 :: float
+      %t1583 = call core.sub(%t1605, %t1596) :: float
+      %t1579 = call core.sub(%t1592, %t1596) :: float
+      %t1584 = call core.clamp(%t1579, %t1590, %t1583) :: float
+      %t1572 = call core.mul(%t1584, %t1621) :: float
+      %acc1564 = acc_add agg.sum(%acc1564, %t1572) :: float
+    end_loop
+    %t1573 = acc_load %acc1564 :: float
+    %t1629 = const 168600.0 :: float
+    %t1630 = make_tuple(%t1585, %t1629) :: tuple<float>
+    %t1631 = fold %t1630 fn="agg.min" :: float
+    %t1632 = const 0.062 :: float
+    %t1633 = call core.mul(%t1631, %t1632) :: float
+    %t1636 = const 0.0145 :: float
+    %t1637 = call core.mul(%t1585, %t1636) :: float
+    %t1624 = call core.add(%t1633, %t1637) :: float
+    %t1639 = const 250000.0 :: float
+    %t1640 = call core.sub(%t1585, %t1639) :: float
+    %t1642 = make_tuple(%t1640, %t1590) :: tuple<float, integer>
+    %t1643 = fold %t1642 fn="agg.max" :: float
+    %t1644 = const 0.009 :: float
+    %t1645 = call core.mul(%t1643, %t1644) :: float
+    %t1626 = call core.add(%t1624, %t1645) :: float
+    %t262 = call core.add(%t1573, %t1626) :: float
+    %t1647 = load_input "state_rate" :: float
+    %t1648 = call core.mul(%t1585, %t1647) :: float
+    %t264 = call core.add(%t262, %t1648) :: float
+    %t1650 = load_input "local_rate" :: float
+    %t1651 = call core.mul(%t1585, %t1650) :: float
+    %t266 = call core.add(%t264, %t1651) :: float
+    yield %t266
+  )
+  (Declaration total_eff_mj
+    %acc1660 = decl_acc :: float
+    %t1661 = load_input "fed" :: array
+    %t1662 = load_field t1661["married_joint"] :: any
+    %t1663 = load_field t1662["rates"] :: any
+    %t1681 = load_input "income" :: float
+    %t1682 = load_input "fed" :: any
+    %t1686 = const 0 :: integer
+    %t1697 = const -1 :: integer
+    %t1699 = const 100000000000.0 :: float
+    %t1683 = load_field t1682["married_joint"] :: any
+    %t1684 = load_field t1683["std"] :: float
+    %t1685 = call core.sub(%t1681, %t1684) :: float
+    %t1687 = make_tuple(%t1685, %t1686) :: tuple<float, integer>
+    %t1688 = fold %t1687 fn="agg.max" :: float
+    loop rates id=L40 in %t1663 as el=%t1664, idx=%t1665
+      %t1692 = load_field t1664["lo"] :: float
+      %t1705 = load_field t1664["hi"] :: float
+      %t1717 = load_field t1664["rate"] :: float
+      %t1698 = call core.eq(%t1705, %t1697) :: boolean
+      %t1701 = select %t1698, %t1699, %t1705 :: float
+      %t1679 = call core.sub(%t1701, %t1692) :: float
+      %t1675 = call core.sub(%t1688, %t1692) :: float
+      %t1680 = call core.clamp(%t1675, %t1686, %t1679) :: float
+      %t1668 = call core.mul(%t1680, %t1717) :: float
+      %acc1660 = acc_add agg.sum(%acc1660, %t1668) :: float
+    end_loop
+    %t1669 = acc_load %acc1660 :: float
+    %t1725 = const 168600.0 :: float
+    %t1726 = make_tuple(%t1681, %t1725) :: tuple<float>
+    %t1727 = fold %t1726 fn="agg.min" :: float
+    %t1728 = const 0.062 :: float
+    %t1729 = call core.mul(%t1727, %t1728) :: float
+    %t1732 = const 0.0145 :: float
+    %t1733 = call core.mul(%t1681, %t1732) :: float
+    %t1720 = call core.add(%t1729, %t1733) :: float
+    %t1735 = const 250000.0 :: float
+    %t1736 = call core.sub(%t1681, %t1735) :: float
+    %t1738 = make_tuple(%t1736, %t1686) :: tuple<float, integer>
+    %t1739 = fold %t1738 fn="agg.max" :: float
+    %t1740 = const 0.009 :: float
+    %t1741 = call core.mul(%t1739, %t1740) :: float
+    %t1722 = call core.add(%t1720, %t1741) :: float
+    %t1654 = call core.add(%t1669, %t1722) :: float
+    %t1743 = load_input "state_rate" :: float
+    %t1744 = call core.mul(%t1681, %t1743) :: float
+    %t1656 = call core.add(%t1654, %t1744) :: float
+    %t1746 = load_input "local_rate" :: float
+    %t1747 = call core.mul(%t1681, %t1746) :: float
+    %t1658 = call core.add(%t1656, %t1747) :: float
+    %t269 = const 1.0 :: float
+    %t270 = make_tuple(%t1681, %t269) :: tuple<float>
+    %t271 = fold %t270 fn="agg.max" :: float
+    %t272 = call core.div(%t1658, %t271) :: float
+    yield %t272
+  )
+  (Declaration after_tax_mj
+    %t273 = load_input "income" :: float
+    %acc1756 = decl_acc :: float
+    %t1757 = load_input "fed" :: array
+    %t1758 = load_field t1757["married_joint"] :: any
+    %t1759 = load_field t1758["rates"] :: any
+    %t1778 = load_input "fed" :: any
+    %t1782 = const 0 :: integer
+    %t1793 = const -1 :: integer
+    %t1795 = const 100000000000.0 :: float
+    %t1779 = load_field t1778["married_joint"] :: any
+    %t1780 = load_field t1779["std"] :: float
+    %t1781 = call core.sub(%t273, %t1780) :: float
+    %t1783 = make_tuple(%t1781, %t1782) :: tuple<float, integer>
+    %t1784 = fold %t1783 fn="agg.max" :: float
+    loop rates id=L41 in %t1759 as el=%t1760, idx=%t1761
+      %t1788 = load_field t1760["lo"] :: float
+      %t1801 = load_field t1760["hi"] :: float
+      %t1813 = load_field t1760["rate"] :: float
+      %t1794 = call core.eq(%t1801, %t1793) :: boolean
+      %t1797 = select %t1794, %t1795, %t1801 :: float
+      %t1775 = call core.sub(%t1797, %t1788) :: float
+      %t1771 = call core.sub(%t1784, %t1788) :: float
+      %t1776 = call core.clamp(%t1771, %t1782, %t1775) :: float
+      %t1764 = call core.mul(%t1776, %t1813) :: float
+      %acc1756 = acc_add agg.sum(%acc1756, %t1764) :: float
+    end_loop
+    %t1765 = acc_load %acc1756 :: float
+    %t1821 = const 168600.0 :: float
+    %t1822 = make_tuple(%t273, %t1821) :: tuple<float>
+    %t1823 = fold %t1822 fn="agg.min" :: float
+    %t1824 = const 0.062 :: float
+    %t1825 = call core.mul(%t1823, %t1824) :: float
+    %t1828 = const 0.0145 :: float
+    %t1829 = call core.mul(%t273, %t1828) :: float
+    %t1816 = call core.add(%t1825, %t1829) :: float
+    %t1831 = const 250000.0 :: float
+    %t1832 = call core.sub(%t273, %t1831) :: float
+    %t1834 = make_tuple(%t1832, %t1782) :: tuple<float, integer>
+    %t1835 = fold %t1834 fn="agg.max" :: float
+    %t1836 = const 0.009 :: float
+    %t1837 = call core.mul(%t1835, %t1836) :: float
+    %t1818 = call core.add(%t1816, %t1837) :: float
+    %t1750 = call core.add(%t1765, %t1818) :: float
+    %t1839 = load_input "state_rate" :: float
+    %t1840 = call core.mul(%t273, %t1839) :: float
+    %t1752 = call core.add(%t1750, %t1840) :: float
+    %t1842 = load_input "local_rate" :: float
+    %t1843 = call core.mul(%t273, %t1842) :: float
+    %t1754 = call core.add(%t1752, %t1843) :: float
+    %t275 = call core.sub(%t273, %t1754) :: float
+    yield %t275
+  )
+  (Declaration take_home_mj
+    %t1844 = load_input "income" :: float
+    %acc1855 = decl_acc :: float
+    %t1856 = load_input "fed" :: array
+    %t1857 = load_field t1856["married_joint"] :: any
+    %t1858 = load_field t1857["rates"] :: any
+    %t1877 = load_input "fed" :: any
+    %t1881 = const 0 :: integer
+    %t1892 = const -1 :: integer
+    %t1894 = const 100000000000.0 :: float
+    %t1878 = load_field t1877["married_joint"] :: any
+    %t1879 = load_field t1878["std"] :: float
+    %t1880 = call core.sub(%t1844, %t1879) :: float
+    %t1882 = make_tuple(%t1880, %t1881) :: tuple<float, integer>
+    %t1883 = fold %t1882 fn="agg.max" :: float
+    loop rates id=L42 in %t1858 as el=%t1859, idx=%t1860
+      %t1887 = load_field t1859["lo"] :: float
+      %t1900 = load_field t1859["hi"] :: float
+      %t1912 = load_field t1859["rate"] :: float
+      %t1893 = call core.eq(%t1900, %t1892) :: boolean
+      %t1896 = select %t1893, %t1894, %t1900 :: float
+      %t1874 = call core.sub(%t1896, %t1887) :: float
+      %t1870 = call core.sub(%t1883, %t1887) :: float
+      %t1875 = call core.clamp(%t1870, %t1881, %t1874) :: float
+      %t1863 = call core.mul(%t1875, %t1912) :: float
+      %acc1855 = acc_add agg.sum(%acc1855, %t1863) :: float
+    end_loop
+    %t1864 = acc_load %acc1855 :: float
+    %t1920 = const 168600.0 :: float
+    %t1921 = make_tuple(%t1844, %t1920) :: tuple<float>
+    %t1922 = fold %t1921 fn="agg.min" :: float
+    %t1923 = const 0.062 :: float
+    %t1924 = call core.mul(%t1922, %t1923) :: float
+    %t1927 = const 0.0145 :: float
+    %t1928 = call core.mul(%t1844, %t1927) :: float
+    %t1915 = call core.add(%t1924, %t1928) :: float
+    %t1930 = const 250000.0 :: float
+    %t1931 = call core.sub(%t1844, %t1930) :: float
+    %t1933 = make_tuple(%t1931, %t1881) :: tuple<float, integer>
+    %t1934 = fold %t1933 fn="agg.max" :: float
+    %t1935 = const 0.009 :: float
+    %t1936 = call core.mul(%t1934, %t1935) :: float
+    %t1917 = call core.add(%t1915, %t1936) :: float
+    %t1849 = call core.add(%t1864, %t1917) :: float
+    %t1938 = load_input "state_rate" :: float
+    %t1939 = call core.mul(%t1844, %t1938) :: float
+    %t1851 = call core.add(%t1849, %t1939) :: float
+    %t1941 = load_input "local_rate" :: float
+    %t1942 = call core.mul(%t1844, %t1941) :: float
+    %t1853 = call core.add(%t1851, %t1942) :: float
+    %t1846 = call core.sub(%t1844, %t1853) :: float
+    %t277 = load_input "retirement_contrib" :: float
+    %t278 = call core.sub(%t1846, %t277) :: float
+    yield %t278
+  )
+  (Declaration taxable_ms
+    %t279 = load_input "income" :: float
+    %t280 = load_input "fed" :: any
+    %t281 = load_field t280["married_separate"] :: any
+    %t282 = load_field t281["std"] :: float
+    %t283 = call core.sub(%t279, %t282) :: float
+    %t284 = const 0 :: integer
+    %t285 = make_tuple(%t283, %t284) :: tuple<float, integer>
+    %t286 = fold %t285 fn="agg.max" :: float
+    yield %t286
+  )
+  (Declaration lo_ms
+    %t287 = load_input "fed" :: array
+    %t288 = load_field t287["married_separate"] :: any
+    %t289 = load_field t288["rates"] :: any
+    loop rates id=L17 in %t289 as el=%rates_el_290, idx=%rates_i_291
+      %t292 = load_field rates_el_290["lo"] :: float
+      yield %t292
+    end_loop
+  )
+  (Declaration hi_ms
+    %t293 = load_input "fed" :: array
+    %t294 = load_field t293["married_separate"] :: any
+    %t295 = load_field t294["rates"] :: any
+    loop rates id=L18 in %t295 as el=%rates_el_296, idx=%rates_i_297
+      %t298 = load_field rates_el_296["hi"] :: float
+      yield %t298
+    end_loop
+  )
+  (Declaration rate_ms
+    %t299 = load_input "fed" :: array
+    %t300 = load_field t299["married_separate"] :: any
+    %t301 = load_field t300["rates"] :: any
+    loop rates id=L19 in %t301 as el=%rates_el_302, idx=%rates_i_303
+      %t304 = load_field rates_el_302["rate"] :: float
+      yield %t304
+    end_loop
+  )
+  (Declaration hi_ms_eff
+    %t305 = load_input "fed" :: array
+    %t306 = load_field t305["married_separate"] :: any
+    %t307 = load_field t306["rates"] :: any
+    %t311 = const -1 :: integer
+    %t313 = const 100000000000.0 :: float
+    loop rates id=L20 in %t307 as el=%rates_el_308, idx=%rates_i_309
+      %t1946 = load_field rates_el_308["hi"] :: float
+      %t312 = call core.eq(%t1946, %t311) :: boolean
+      %t315 = select %t312, %t313, %t1946 :: float
+      yield %t315
+    end_loop
+  )
+  (Declaration amt_ms
+    %t316 = load_input "fed" :: array
+    %t317 = load_field t316["married_separate"] :: any
+    %t318 = load_field t317["rates"] :: any
+    %t1956 = const 0 :: integer
+    %t1967 = const -1 :: integer
+    %t1969 = const 100000000000.0 :: float
+    loop rates id=L21 in %t318 as el=%rates_el_319, idx=%rates_i_320
+      %t1962 = load_field rates_el_319["lo"] :: float
+      %t1975 = load_field rates_el_319["hi"] :: float
+      %t323 = call core.sub(%t321, %t1962) :: float
+      %t1968 = call core.eq(%t1975, %t1967) :: boolean
+      %t1971 = select %t1968, %t1969, %t1975 :: float
+      %t327 = call core.sub(%t1971, %t1962) :: float
+      %t328 = call core.clamp(%t323, %t1956, %t327) :: float
+      yield %t328
+    end_loop
+  )
+  (Declaration fed_tax_ms
+    %acc_329 = decl_acc :: float
+    %t330 = load_input "fed" :: array
+    %t331 = load_field t330["married_separate"] :: any
+    %t332 = load_field t331["rates"] :: any
+    %t1995 = load_input "income" :: float
+    %t1996 = load_input "fed" :: any
+    %t2000 = const 0 :: integer
+    %t2011 = const -1 :: integer
+    %t2013 = const 100000000000.0 :: float
+    %t1997 = load_field t1996["married_separate"] :: any
+    %t1998 = load_field t1997["std"] :: float
+    %t1999 = call core.sub(%t1995, %t1998) :: float
+    %t2001 = make_tuple(%t1999, %t2000) :: tuple<float, integer>
+    %t2002 = fold %t2001 fn="agg.max" :: float
+    loop rates id=L22 in %t332 as el=%rates_el_333, idx=%rates_i_334
+      %t2006 = load_field rates_el_333["lo"] :: float
+      %t2019 = load_field rates_el_333["hi"] :: float
+      %t2031 = load_field rates_el_333["rate"] :: float
+      %t2012 = call core.eq(%t2019, %t2011) :: boolean
+      %t2015 = select %t2012, %t2013, %t2019 :: float
+      %t1993 = call core.sub(%t2015, %t2006) :: float
+      %t1989 = call core.sub(%t2002, %t2006) :: float
+      %t1994 = call core.clamp(%t1989, %t2000, %t1993) :: float
+      %t337 = call core.mul(%t1994, %t2031) :: float
+      %acc_329 = acc_add agg.sum(%acc_329, %t337) :: float
+    end_loop
+    %t338 = acc_load %acc_329 :: float
+    yield %t338
+  )
+  (Declaration in_br_ms
+    %t339 = load_input "fed" :: array
+    %t340 = load_field t339["married_separate"] :: any
+    %t341 = load_field t340["rates"] :: any
+    %t2056 = const -1 :: integer
+    %t2058 = const 100000000000.0 :: float
+    loop rates id=L23 in %t341 as el=%rates_el_342, idx=%rates_i_343
+      %t2051 = load_field rates_el_342["lo"] :: float
+      %t2064 = load_field rates_el_342["hi"] :: float
+      %t346 = call core.gte(%t344, %t2051) :: boolean
+      %t2057 = call core.eq(%t2064, %t2056) :: boolean
+      %t2060 = select %t2057, %t2058, %t2064 :: float
+      %t349 = call core.lt(%t347, %t2060) :: boolean
+      %t350 = call core.and(%t346, %t349) :: boolean
+      yield %t350
+    end_loop
+  )
+  (Declaration fed_marginal_ms
+    %acc_351 = decl_acc :: float
+    %t352 = load_input "fed" :: array
+    %t353 = load_field t352["married_separate"] :: any
+    %t354 = load_field t353["rates"] :: any
+    %t2079 = load_input "income" :: float
+    %t2080 = load_input "fed" :: any
+    %t2084 = const 0 :: integer
+    %t2103 = const -1 :: integer
+    %t2105 = const 100000000000.0 :: float
+    %t2081 = load_field t2080["married_separate"] :: any
+    %t2082 = load_field t2081["std"] :: float
+    %t2083 = call core.sub(%t2079, %t2082) :: float
+    %t2085 = make_tuple(%t2083, %t2084) :: tuple<float, integer>
+    %t2086 = fold %t2085 fn="agg.max" :: float
+    loop rates id=L24 in %t354 as el=%rates_el_355, idx=%rates_i_356
+      %t2098 = load_field rates_el_355["lo"] :: float
+      %t2111 = load_field rates_el_355["hi"] :: float
+      %t2119 = load_field rates_el_355["rate"] :: float
+      %t2104 = call core.eq(%t2111, %t2103) :: boolean
+      %t2107 = select %t2104, %t2105, %t2111 :: float
+      %t2075 = call core.gte(%t2086, %t2098) :: boolean
+      %t2077 = call core.lt(%t2086, %t2107) :: boolean
+      %t2078 = call core.and(%t2075, %t2077) :: boolean
+      %t360 = select %t2078, %t2119, %t2084 :: float
+      %acc_351 = acc_add agg.sum(%acc_351, %t360) :: float
+    end_loop
+    %t361 = acc_load %acc_351 :: float
+    yield %t361
+  )
+  (Declaration fed_eff_ms
+    %acc2121 = decl_acc :: float
+    %t2122 = load_input "fed" :: array
+    %t2123 = load_field t2122["married_separate"] :: any
+    %t2124 = load_field t2123["rates"] :: any
+    %t2142 = load_input "income" :: float
+    %t2143 = load_input "fed" :: any
+    %t2147 = const 0 :: integer
+    %t2158 = const -1 :: integer
+    %t2160 = const 100000000000.0 :: float
+    %t2144 = load_field t2143["married_separate"] :: any
+    %t2145 = load_field t2144["std"] :: float
+    %t2146 = call core.sub(%t2142, %t2145) :: float
+    %t2148 = make_tuple(%t2146, %t2147) :: tuple<float, integer>
+    %t2149 = fold %t2148 fn="agg.max" :: float
+    loop rates id=L43 in %t2124 as el=%t2125, idx=%t2126
+      %t2153 = load_field t2125["lo"] :: float
+      %t2166 = load_field t2125["hi"] :: float
+      %t2178 = load_field t2125["rate"] :: float
+      %t2159 = call core.eq(%t2166, %t2158) :: boolean
+      %t2162 = select %t2159, %t2160, %t2166 :: float
+      %t2140 = call core.sub(%t2162, %t2153) :: float
+      %t2136 = call core.sub(%t2149, %t2153) :: float
+      %t2141 = call core.clamp(%t2136, %t2147, %t2140) :: float
+      %t2129 = call core.mul(%t2141, %t2178) :: float
+      %acc2121 = acc_add agg.sum(%acc2121, %t2129) :: float
+    end_loop
+    %t2130 = acc_load %acc2121 :: float
+    %t364 = const 1.0 :: float
+    %t365 = make_tuple(%t2142, %t364) :: tuple<float>
+    %t366 = fold %t365 fn="agg.max" :: float
+    %t367 = call core.div(%t2130, %t366) :: float
+    yield %t367
+  )
+  (Declaration ss_tax_ms
+    %t2179 = load_input "income" :: float
+    %t2180 = const 168600.0 :: float
+    %t2181 = make_tuple(%t2179, %t2180) :: tuple<float>
+    %t2182 = fold %t2181 fn="agg.min" :: float
+    %t2183 = const 0.062 :: float
+    %t2184 = call core.mul(%t2182, %t2183) :: float
+    yield %t2184
+  )
+  (Declaration med_tax_ms
+    %t2185 = load_input "income" :: float
+    %t2186 = const 0.0145 :: float
+    %t2187 = call core.mul(%t2185, %t2186) :: float
+    yield %t2187
+  )
+  (Declaration addl_threshold_ms
+    %t370 = const 125000.0 :: float
+    yield %t370
+  )
+  (Declaration addl_med_tax_ms
+    %t371 = load_input "income" :: float
+    %t372 = const 125000.0 :: float
+    %t373 = call core.sub(%t371, %t372) :: float
+    %t374 = const 0 :: integer
+    %t375 = make_tuple(%t373, %t374) :: tuple<float, integer>
+    %t376 = fold %t375 fn="agg.max" :: float
+    %t377 = const 0.009 :: float
+    %t378 = call core.mul(%t376, %t377) :: float
+    yield %t378
+  )
+  (Declaration fica_tax_ms
+    %t2189 = load_input "income" :: float
+    %t2190 = const 168600.0 :: float
+    %t2191 = make_tuple(%t2189, %t2190) :: tuple<float>
+    %t2192 = fold %t2191 fn="agg.min" :: float
+    %t2193 = const 0.062 :: float
+    %t2194 = call core.mul(%t2192, %t2193) :: float
+    %t2197 = const 0.0145 :: float
+    %t2198 = call core.mul(%t2189, %t2197) :: float
+    %t381 = call core.add(%t2194, %t2198) :: float
+    %t2200 = const 125000.0 :: float
+    %t2201 = call core.sub(%t2189, %t2200) :: float
+    %t2202 = const 0 :: integer
+    %t2203 = make_tuple(%t2201, %t2202) :: tuple<float, integer>
+    %t2204 = fold %t2203 fn="agg.max" :: float
+    %t2205 = const 0.009 :: float
+    %t2206 = call core.mul(%t2204, %t2205) :: float
+    %t383 = call core.add(%t381, %t2206) :: float
+    yield %t383
+  )
+  (Declaration fica_eff_ms
+    %t2213 = load_input "income" :: float
+    %t2214 = const 168600.0 :: float
+    %t2215 = make_tuple(%t2213, %t2214) :: tuple<float>
+    %t2216 = fold %t2215 fn="agg.min" :: float
+    %t2217 = const 0.062 :: float
+    %t2218 = call core.mul(%t2216, %t2217) :: float
+    %t2221 = const 0.0145 :: float
+    %t2222 = call core.mul(%t2213, %t2221) :: float
+    %t2209 = call core.add(%t2218, %t2222) :: float
+    %t2224 = const 125000.0 :: float
+    %t2225 = call core.sub(%t2213, %t2224) :: float
+    %t2226 = const 0 :: integer
+    %t2227 = make_tuple(%t2225, %t2226) :: tuple<float, integer>
+    %t2228 = fold %t2227 fn="agg.max" :: float
+    %t2229 = const 0.009 :: float
+    %t2230 = call core.mul(%t2228, %t2229) :: float
+    %t2211 = call core.add(%t2209, %t2230) :: float
+    %t386 = const 1.0 :: float
+    %t387 = make_tuple(%t2213, %t386) :: tuple<float>
+    %t388 = fold %t387 fn="agg.max" :: float
+    %t389 = call core.div(%t2211, %t388) :: float
+    yield %t389
+  )
+  (Declaration total_tax_ms
+    %acc2232 = decl_acc :: float
+    %t2233 = load_input "fed" :: array
+    %t2234 = load_field t2233["married_separate"] :: any
+    %t2235 = load_field t2234["rates"] :: any
+    %t2253 = load_input "income" :: float
+    %t2254 = load_input "fed" :: any
+    %t2258 = const 0 :: integer
+    %t2269 = const -1 :: integer
+    %t2271 = const 100000000000.0 :: float
+    %t2255 = load_field t2254["married_separate"] :: any
+    %t2256 = load_field t2255["std"] :: float
+    %t2257 = call core.sub(%t2253, %t2256) :: float
+    %t2259 = make_tuple(%t2257, %t2258) :: tuple<float, integer>
+    %t2260 = fold %t2259 fn="agg.max" :: float
+    loop rates id=L44 in %t2235 as el=%t2236, idx=%t2237
+      %t2264 = load_field t2236["lo"] :: float
+      %t2277 = load_field t2236["hi"] :: float
+      %t2289 = load_field t2236["rate"] :: float
+      %t2270 = call core.eq(%t2277, %t2269) :: boolean
+      %t2273 = select %t2270, %t2271, %t2277 :: float
+      %t2251 = call core.sub(%t2273, %t2264) :: float
+      %t2247 = call core.sub(%t2260, %t2264) :: float
+      %t2252 = call core.clamp(%t2247, %t2258, %t2251) :: float
+      %t2240 = call core.mul(%t2252, %t2289) :: float
+      %acc2232 = acc_add agg.sum(%acc2232, %t2240) :: float
+    end_loop
+    %t2241 = acc_load %acc2232 :: float
+    %t2297 = const 168600.0 :: float
+    %t2298 = make_tuple(%t2253, %t2297) :: tuple<float>
+    %t2299 = fold %t2298 fn="agg.min" :: float
+    %t2300 = const 0.062 :: float
+    %t2301 = call core.mul(%t2299, %t2300) :: float
+    %t2304 = const 0.0145 :: float
+    %t2305 = call core.mul(%t2253, %t2304) :: float
+    %t2292 = call core.add(%t2301, %t2305) :: float
+    %t2307 = const 125000.0 :: float
+    %t2308 = call core.sub(%t2253, %t2307) :: float
+    %t2310 = make_tuple(%t2308, %t2258) :: tuple<float, integer>
+    %t2311 = fold %t2310 fn="agg.max" :: float
+    %t2312 = const 0.009 :: float
+    %t2313 = call core.mul(%t2311, %t2312) :: float
+    %t2294 = call core.add(%t2292, %t2313) :: float
+    %t392 = call core.add(%t2241, %t2294) :: float
+    %t2315 = load_input "state_rate" :: float
+    %t2316 = call core.mul(%t2253, %t2315) :: float
+    %t394 = call core.add(%t392, %t2316) :: float
+    %t2318 = load_input "local_rate" :: float
+    %t2319 = call core.mul(%t2253, %t2318) :: float
+    %t396 = call core.add(%t394, %t2319) :: float
+    yield %t396
+  )
+  (Declaration total_eff_ms
+    %acc2328 = decl_acc :: float
+    %t2329 = load_input "fed" :: array
+    %t2330 = load_field t2329["married_separate"] :: any
+    %t2331 = load_field t2330["rates"] :: any
+    %t2349 = load_input "income" :: float
+    %t2350 = load_input "fed" :: any
+    %t2354 = const 0 :: integer
+    %t2365 = const -1 :: integer
+    %t2367 = const 100000000000.0 :: float
+    %t2351 = load_field t2350["married_separate"] :: any
+    %t2352 = load_field t2351["std"] :: float
+    %t2353 = call core.sub(%t2349, %t2352) :: float
+    %t2355 = make_tuple(%t2353, %t2354) :: tuple<float, integer>
+    %t2356 = fold %t2355 fn="agg.max" :: float
+    loop rates id=L45 in %t2331 as el=%t2332, idx=%t2333
+      %t2360 = load_field t2332["lo"] :: float
+      %t2373 = load_field t2332["hi"] :: float
+      %t2385 = load_field t2332["rate"] :: float
+      %t2366 = call core.eq(%t2373, %t2365) :: boolean
+      %t2369 = select %t2366, %t2367, %t2373 :: float
+      %t2347 = call core.sub(%t2369, %t2360) :: float
+      %t2343 = call core.sub(%t2356, %t2360) :: float
+      %t2348 = call core.clamp(%t2343, %t2354, %t2347) :: float
+      %t2336 = call core.mul(%t2348, %t2385) :: float
+      %acc2328 = acc_add agg.sum(%acc2328, %t2336) :: float
+    end_loop
+    %t2337 = acc_load %acc2328 :: float
+    %t2393 = const 168600.0 :: float
+    %t2394 = make_tuple(%t2349, %t2393) :: tuple<float>
+    %t2395 = fold %t2394 fn="agg.min" :: float
+    %t2396 = const 0.062 :: float
+    %t2397 = call core.mul(%t2395, %t2396) :: float
+    %t2400 = const 0.0145 :: float
+    %t2401 = call core.mul(%t2349, %t2400) :: float
+    %t2388 = call core.add(%t2397, %t2401) :: float
+    %t2403 = const 125000.0 :: float
+    %t2404 = call core.sub(%t2349, %t2403) :: float
+    %t2406 = make_tuple(%t2404, %t2354) :: tuple<float, integer>
+    %t2407 = fold %t2406 fn="agg.max" :: float
+    %t2408 = const 0.009 :: float
+    %t2409 = call core.mul(%t2407, %t2408) :: float
+    %t2390 = call core.add(%t2388, %t2409) :: float
+    %t2322 = call core.add(%t2337, %t2390) :: float
+    %t2411 = load_input "state_rate" :: float
+    %t2412 = call core.mul(%t2349, %t2411) :: float
+    %t2324 = call core.add(%t2322, %t2412) :: float
+    %t2414 = load_input "local_rate" :: float
+    %t2415 = call core.mul(%t2349, %t2414) :: float
+    %t2326 = call core.add(%t2324, %t2415) :: float
+    %t399 = const 1.0 :: float
+    %t400 = make_tuple(%t2349, %t399) :: tuple<float>
+    %t401 = fold %t400 fn="agg.max" :: float
+    %t402 = call core.div(%t2326, %t401) :: float
+    yield %t402
+  )
+  (Declaration after_tax_ms
+    %t403 = load_input "income" :: float
+    %acc2424 = decl_acc :: float
+    %t2425 = load_input "fed" :: array
+    %t2426 = load_field t2425["married_separate"] :: any
+    %t2427 = load_field t2426["rates"] :: any
+    %t2446 = load_input "fed" :: any
+    %t2450 = const 0 :: integer
+    %t2461 = const -1 :: integer
+    %t2463 = const 100000000000.0 :: float
+    %t2447 = load_field t2446["married_separate"] :: any
+    %t2448 = load_field t2447["std"] :: float
+    %t2449 = call core.sub(%t403, %t2448) :: float
+    %t2451 = make_tuple(%t2449, %t2450) :: tuple<float, integer>
+    %t2452 = fold %t2451 fn="agg.max" :: float
+    loop rates id=L46 in %t2427 as el=%t2428, idx=%t2429
+      %t2456 = load_field t2428["lo"] :: float
+      %t2469 = load_field t2428["hi"] :: float
+      %t2481 = load_field t2428["rate"] :: float
+      %t2462 = call core.eq(%t2469, %t2461) :: boolean
+      %t2465 = select %t2462, %t2463, %t2469 :: float
+      %t2443 = call core.sub(%t2465, %t2456) :: float
+      %t2439 = call core.sub(%t2452, %t2456) :: float
+      %t2444 = call core.clamp(%t2439, %t2450, %t2443) :: float
+      %t2432 = call core.mul(%t2444, %t2481) :: float
+      %acc2424 = acc_add agg.sum(%acc2424, %t2432) :: float
+    end_loop
+    %t2433 = acc_load %acc2424 :: float
+    %t2489 = const 168600.0 :: float
+    %t2490 = make_tuple(%t403, %t2489) :: tuple<float>
+    %t2491 = fold %t2490 fn="agg.min" :: float
+    %t2492 = const 0.062 :: float
+    %t2493 = call core.mul(%t2491, %t2492) :: float
+    %t2496 = const 0.0145 :: float
+    %t2497 = call core.mul(%t403, %t2496) :: float
+    %t2484 = call core.add(%t2493, %t2497) :: float
+    %t2499 = const 125000.0 :: float
+    %t2500 = call core.sub(%t403, %t2499) :: float
+    %t2502 = make_tuple(%t2500, %t2450) :: tuple<float, integer>
+    %t2503 = fold %t2502 fn="agg.max" :: float
+    %t2504 = const 0.009 :: float
+    %t2505 = call core.mul(%t2503, %t2504) :: float
+    %t2486 = call core.add(%t2484, %t2505) :: float
+    %t2418 = call core.add(%t2433, %t2486) :: float
+    %t2507 = load_input "state_rate" :: float
+    %t2508 = call core.mul(%t403, %t2507) :: float
+    %t2420 = call core.add(%t2418, %t2508) :: float
+    %t2510 = load_input "local_rate" :: float
+    %t2511 = call core.mul(%t403, %t2510) :: float
+    %t2422 = call core.add(%t2420, %t2511) :: float
+    %t405 = call core.sub(%t403, %t2422) :: float
+    yield %t405
+  )
+  (Declaration take_home_ms
+    %t2512 = load_input "income" :: float
+    %acc2523 = decl_acc :: float
+    %t2524 = load_input "fed" :: array
+    %t2525 = load_field t2524["married_separate"] :: any
+    %t2526 = load_field t2525["rates"] :: any
+    %t2545 = load_input "fed" :: any
+    %t2549 = const 0 :: integer
+    %t2560 = const -1 :: integer
+    %t2562 = const 100000000000.0 :: float
+    %t2546 = load_field t2545["married_separate"] :: any
+    %t2547 = load_field t2546["std"] :: float
+    %t2548 = call core.sub(%t2512, %t2547) :: float
+    %t2550 = make_tuple(%t2548, %t2549) :: tuple<float, integer>
+    %t2551 = fold %t2550 fn="agg.max" :: float
+    loop rates id=L47 in %t2526 as el=%t2527, idx=%t2528
+      %t2555 = load_field t2527["lo"] :: float
+      %t2568 = load_field t2527["hi"] :: float
+      %t2580 = load_field t2527["rate"] :: float
+      %t2561 = call core.eq(%t2568, %t2560) :: boolean
+      %t2564 = select %t2561, %t2562, %t2568 :: float
+      %t2542 = call core.sub(%t2564, %t2555) :: float
+      %t2538 = call core.sub(%t2551, %t2555) :: float
+      %t2543 = call core.clamp(%t2538, %t2549, %t2542) :: float
+      %t2531 = call core.mul(%t2543, %t2580) :: float
+      %acc2523 = acc_add agg.sum(%acc2523, %t2531) :: float
+    end_loop
+    %t2532 = acc_load %acc2523 :: float
+    %t2588 = const 168600.0 :: float
+    %t2589 = make_tuple(%t2512, %t2588) :: tuple<float>
+    %t2590 = fold %t2589 fn="agg.min" :: float
+    %t2591 = const 0.062 :: float
+    %t2592 = call core.mul(%t2590, %t2591) :: float
+    %t2595 = const 0.0145 :: float
+    %t2596 = call core.mul(%t2512, %t2595) :: float
+    %t2583 = call core.add(%t2592, %t2596) :: float
+    %t2598 = const 125000.0 :: float
+    %t2599 = call core.sub(%t2512, %t2598) :: float
+    %t2601 = make_tuple(%t2599, %t2549) :: tuple<float, integer>
+    %t2602 = fold %t2601 fn="agg.max" :: float
+    %t2603 = const 0.009 :: float
+    %t2604 = call core.mul(%t2602, %t2603) :: float
+    %t2585 = call core.add(%t2583, %t2604) :: float
+    %t2517 = call core.add(%t2532, %t2585) :: float
+    %t2606 = load_input "state_rate" :: float
+    %t2607 = call core.mul(%t2512, %t2606) :: float
+    %t2519 = call core.add(%t2517, %t2607) :: float
+    %t2609 = load_input "local_rate" :: float
+    %t2610 = call core.mul(%t2512, %t2609) :: float
+    %t2521 = call core.add(%t2519, %t2610) :: float
+    %t2514 = call core.sub(%t2512, %t2521) :: float
+    %t407 = load_input "retirement_contrib" :: float
+    %t408 = call core.sub(%t2514, %t407) :: float
+    yield %t408
+  )
+  (Declaration taxable_hoh
+    %t409 = load_input "income" :: float
+    %t410 = load_input "fed" :: any
+    %t411 = load_field t410["head_of_household"] :: any
+    %t412 = load_field t411["std"] :: float
+    %t413 = call core.sub(%t409, %t412) :: float
+    %t414 = const 0 :: integer
+    %t415 = make_tuple(%t413, %t414) :: tuple<float, integer>
+    %t416 = fold %t415 fn="agg.max" :: float
+    yield %t416
+  )
+  (Declaration lo_h
+    %t417 = load_input "fed" :: array
+    %t418 = load_field t417["head_of_household"] :: any
+    %t419 = load_field t418["rates"] :: any
+    loop rates id=L25 in %t419 as el=%rates_el_420, idx=%rates_i_421
+      %t422 = load_field rates_el_420["lo"] :: float
+      yield %t422
+    end_loop
+  )
+  (Declaration hi_h
+    %t423 = load_input "fed" :: array
+    %t424 = load_field t423["head_of_household"] :: any
+    %t425 = load_field t424["rates"] :: any
+    loop rates id=L26 in %t425 as el=%rates_el_426, idx=%rates_i_427
+      %t428 = load_field rates_el_426["hi"] :: float
+      yield %t428
+    end_loop
+  )
+  (Declaration rate_h
+    %t429 = load_input "fed" :: array
+    %t430 = load_field t429["head_of_household"] :: any
+    %t431 = load_field t430["rates"] :: any
+    loop rates id=L27 in %t431 as el=%rates_el_432, idx=%rates_i_433
+      %t434 = load_field rates_el_432["rate"] :: float
+      yield %t434
+    end_loop
+  )
+  (Declaration hi_h_eff
+    %t435 = load_input "fed" :: array
+    %t436 = load_field t435["head_of_household"] :: any
+    %t437 = load_field t436["rates"] :: any
+    %t441 = const -1 :: integer
+    %t443 = const 100000000000.0 :: float
+    loop rates id=L28 in %t437 as el=%rates_el_438, idx=%rates_i_439
+      %t2614 = load_field rates_el_438["hi"] :: float
+      %t442 = call core.eq(%t2614, %t441) :: boolean
+      %t445 = select %t442, %t443, %t2614 :: float
+      yield %t445
+    end_loop
+  )
+  (Declaration amt_h
+    %t446 = load_input "fed" :: array
+    %t447 = load_field t446["head_of_household"] :: any
+    %t448 = load_field t447["rates"] :: any
+    %t2624 = const 0 :: integer
+    %t2635 = const -1 :: integer
+    %t2637 = const 100000000000.0 :: float
+    loop rates id=L29 in %t448 as el=%rates_el_449, idx=%rates_i_450
+      %t2630 = load_field rates_el_449["lo"] :: float
+      %t2643 = load_field rates_el_449["hi"] :: float
+      %t453 = call core.sub(%t451, %t2630) :: float
+      %t2636 = call core.eq(%t2643, %t2635) :: boolean
+      %t2639 = select %t2636, %t2637, %t2643 :: float
+      %t457 = call core.sub(%t2639, %t2630) :: float
+      %t458 = call core.clamp(%t453, %t2624, %t457) :: float
+      yield %t458
+    end_loop
+  )
+  (Declaration fed_tax_hoh
+    %acc_459 = decl_acc :: float
+    %t460 = load_input "fed" :: array
+    %t461 = load_field t460["head_of_household"] :: any
+    %t462 = load_field t461["rates"] :: any
+    %t2663 = load_input "income" :: float
+    %t2664 = load_input "fed" :: any
+    %t2668 = const 0 :: integer
+    %t2679 = const -1 :: integer
+    %t2681 = const 100000000000.0 :: float
+    %t2665 = load_field t2664["head_of_household"] :: any
+    %t2666 = load_field t2665["std"] :: float
+    %t2667 = call core.sub(%t2663, %t2666) :: float
+    %t2669 = make_tuple(%t2667, %t2668) :: tuple<float, integer>
+    %t2670 = fold %t2669 fn="agg.max" :: float
+    loop rates id=L30 in %t462 as el=%rates_el_463, idx=%rates_i_464
+      %t2674 = load_field rates_el_463["lo"] :: float
+      %t2687 = load_field rates_el_463["hi"] :: float
+      %t2699 = load_field rates_el_463["rate"] :: float
+      %t2680 = call core.eq(%t2687, %t2679) :: boolean
+      %t2683 = select %t2680, %t2681, %t2687 :: float
+      %t2661 = call core.sub(%t2683, %t2674) :: float
+      %t2657 = call core.sub(%t2670, %t2674) :: float
+      %t2662 = call core.clamp(%t2657, %t2668, %t2661) :: float
+      %t467 = call core.mul(%t2662, %t2699) :: float
+      %acc_459 = acc_add agg.sum(%acc_459, %t467) :: float
+    end_loop
+    %t468 = acc_load %acc_459 :: float
+    yield %t468
+  )
+  (Declaration in_br_h
+    %t469 = load_input "fed" :: array
+    %t470 = load_field t469["head_of_household"] :: any
+    %t471 = load_field t470["rates"] :: any
+    %t2724 = const -1 :: integer
+    %t2726 = const 100000000000.0 :: float
+    loop rates id=L31 in %t471 as el=%rates_el_472, idx=%rates_i_473
+      %t2719 = load_field rates_el_472["lo"] :: float
+      %t2732 = load_field rates_el_472["hi"] :: float
+      %t476 = call core.gte(%t474, %t2719) :: boolean
+      %t2725 = call core.eq(%t2732, %t2724) :: boolean
+      %t2728 = select %t2725, %t2726, %t2732 :: float
+      %t479 = call core.lt(%t477, %t2728) :: boolean
+      %t480 = call core.and(%t476, %t479) :: boolean
+      yield %t480
+    end_loop
+  )
+  (Declaration fed_marginal_hoh
+    %acc_481 = decl_acc :: float
+    %t482 = load_input "fed" :: array
+    %t483 = load_field t482["head_of_household"] :: any
+    %t484 = load_field t483["rates"] :: any
+    %t2747 = load_input "income" :: float
+    %t2748 = load_input "fed" :: any
+    %t2752 = const 0 :: integer
+    %t2771 = const -1 :: integer
+    %t2773 = const 100000000000.0 :: float
+    %t2749 = load_field t2748["head_of_household"] :: any
+    %t2750 = load_field t2749["std"] :: float
+    %t2751 = call core.sub(%t2747, %t2750) :: float
+    %t2753 = make_tuple(%t2751, %t2752) :: tuple<float, integer>
+    %t2754 = fold %t2753 fn="agg.max" :: float
+    loop rates id=L32 in %t484 as el=%rates_el_485, idx=%rates_i_486
+      %t2766 = load_field rates_el_485["lo"] :: float
+      %t2779 = load_field rates_el_485["hi"] :: float
+      %t2787 = load_field rates_el_485["rate"] :: float
+      %t2772 = call core.eq(%t2779, %t2771) :: boolean
+      %t2775 = select %t2772, %t2773, %t2779 :: float
+      %t2743 = call core.gte(%t2754, %t2766) :: boolean
+      %t2745 = call core.lt(%t2754, %t2775) :: boolean
+      %t2746 = call core.and(%t2743, %t2745) :: boolean
+      %t490 = select %t2746, %t2787, %t2752 :: float
+      %acc_481 = acc_add agg.sum(%acc_481, %t490) :: float
+    end_loop
+    %t491 = acc_load %acc_481 :: float
+    yield %t491
+  )
+  (Declaration fed_eff_hoh
+    %acc2789 = decl_acc :: float
+    %t2790 = load_input "fed" :: array
+    %t2791 = load_field t2790["head_of_household"] :: any
+    %t2792 = load_field t2791["rates"] :: any
+    %t2810 = load_input "income" :: float
+    %t2811 = load_input "fed" :: any
+    %t2815 = const 0 :: integer
+    %t2826 = const -1 :: integer
+    %t2828 = const 100000000000.0 :: float
+    %t2812 = load_field t2811["head_of_household"] :: any
+    %t2813 = load_field t2812["std"] :: float
+    %t2814 = call core.sub(%t2810, %t2813) :: float
+    %t2816 = make_tuple(%t2814, %t2815) :: tuple<float, integer>
+    %t2817 = fold %t2816 fn="agg.max" :: float
+    loop rates id=L48 in %t2792 as el=%t2793, idx=%t2794
+      %t2821 = load_field t2793["lo"] :: float
+      %t2834 = load_field t2793["hi"] :: float
+      %t2846 = load_field t2793["rate"] :: float
+      %t2827 = call core.eq(%t2834, %t2826) :: boolean
+      %t2830 = select %t2827, %t2828, %t2834 :: float
+      %t2808 = call core.sub(%t2830, %t2821) :: float
+      %t2804 = call core.sub(%t2817, %t2821) :: float
+      %t2809 = call core.clamp(%t2804, %t2815, %t2808) :: float
+      %t2797 = call core.mul(%t2809, %t2846) :: float
+      %acc2789 = acc_add agg.sum(%acc2789, %t2797) :: float
+    end_loop
+    %t2798 = acc_load %acc2789 :: float
+    %t494 = const 1.0 :: float
+    %t495 = make_tuple(%t2810, %t494) :: tuple<float>
+    %t496 = fold %t495 fn="agg.max" :: float
+    %t497 = call core.div(%t2798, %t496) :: float
+    yield %t497
+  )
+  (Declaration ss_tax_h
+    %t2847 = load_input "income" :: float
+    %t2848 = const 168600.0 :: float
+    %t2849 = make_tuple(%t2847, %t2848) :: tuple<float>
+    %t2850 = fold %t2849 fn="agg.min" :: float
+    %t2851 = const 0.062 :: float
+    %t2852 = call core.mul(%t2850, %t2851) :: float
+    yield %t2852
+  )
+  (Declaration med_tax_h
+    %t2853 = load_input "income" :: float
+    %t2854 = const 0.0145 :: float
+    %t2855 = call core.mul(%t2853, %t2854) :: float
+    yield %t2855
+  )
+  (Declaration addl_threshold_hoh
+    %t500 = const 200000.0 :: float
+    yield %t500
+  )
+  (Declaration addl_med_tax_h
+    %t501 = load_input "income" :: float
+    %t502 = const 200000.0 :: float
+    %t503 = call core.sub(%t501, %t502) :: float
+    %t504 = const 0 :: integer
+    %t505 = make_tuple(%t503, %t504) :: tuple<float, integer>
+    %t506 = fold %t505 fn="agg.max" :: float
+    %t507 = const 0.009 :: float
+    %t508 = call core.mul(%t506, %t507) :: float
+    yield %t508
+  )
+  (Declaration fica_tax_hoh
+    %t2857 = load_input "income" :: float
+    %t2858 = const 168600.0 :: float
+    %t2859 = make_tuple(%t2857, %t2858) :: tuple<float>
+    %t2860 = fold %t2859 fn="agg.min" :: float
+    %t2861 = const 0.062 :: float
+    %t2862 = call core.mul(%t2860, %t2861) :: float
+    %t2865 = const 0.0145 :: float
+    %t2866 = call core.mul(%t2857, %t2865) :: float
+    %t511 = call core.add(%t2862, %t2866) :: float
+    %t2868 = const 200000.0 :: float
+    %t2869 = call core.sub(%t2857, %t2868) :: float
+    %t2870 = const 0 :: integer
+    %t2871 = make_tuple(%t2869, %t2870) :: tuple<float, integer>
+    %t2872 = fold %t2871 fn="agg.max" :: float
+    %t2873 = const 0.009 :: float
+    %t2874 = call core.mul(%t2872, %t2873) :: float
+    %t513 = call core.add(%t511, %t2874) :: float
+    yield %t513
+  )
+  (Declaration fica_eff_hoh
+    %t2881 = load_input "income" :: float
+    %t2882 = const 168600.0 :: float
+    %t2883 = make_tuple(%t2881, %t2882) :: tuple<float>
+    %t2884 = fold %t2883 fn="agg.min" :: float
+    %t2885 = const 0.062 :: float
+    %t2886 = call core.mul(%t2884, %t2885) :: float
+    %t2889 = const 0.0145 :: float
+    %t2890 = call core.mul(%t2881, %t2889) :: float
+    %t2877 = call core.add(%t2886, %t2890) :: float
+    %t2892 = const 200000.0 :: float
+    %t2893 = call core.sub(%t2881, %t2892) :: float
+    %t2894 = const 0 :: integer
+    %t2895 = make_tuple(%t2893, %t2894) :: tuple<float, integer>
+    %t2896 = fold %t2895 fn="agg.max" :: float
+    %t2897 = const 0.009 :: float
+    %t2898 = call core.mul(%t2896, %t2897) :: float
+    %t2879 = call core.add(%t2877, %t2898) :: float
+    %t516 = const 1.0 :: float
+    %t517 = make_tuple(%t2881, %t516) :: tuple<float>
+    %t518 = fold %t517 fn="agg.max" :: float
+    %t519 = call core.div(%t2879, %t518) :: float
+    yield %t519
+  )
+  (Declaration total_tax_hoh
+    %acc2900 = decl_acc :: float
+    %t2901 = load_input "fed" :: array
+    %t2902 = load_field t2901["head_of_household"] :: any
+    %t2903 = load_field t2902["rates"] :: any
+    %t2921 = load_input "income" :: float
+    %t2922 = load_input "fed" :: any
+    %t2926 = const 0 :: integer
+    %t2937 = const -1 :: integer
+    %t2939 = const 100000000000.0 :: float
+    %t2923 = load_field t2922["head_of_household"] :: any
+    %t2924 = load_field t2923["std"] :: float
+    %t2925 = call core.sub(%t2921, %t2924) :: float
+    %t2927 = make_tuple(%t2925, %t2926) :: tuple<float, integer>
+    %t2928 = fold %t2927 fn="agg.max" :: float
+    loop rates id=L49 in %t2903 as el=%t2904, idx=%t2905
+      %t2932 = load_field t2904["lo"] :: float
+      %t2945 = load_field t2904["hi"] :: float
+      %t2957 = load_field t2904["rate"] :: float
+      %t2938 = call core.eq(%t2945, %t2937) :: boolean
+      %t2941 = select %t2938, %t2939, %t2945 :: float
+      %t2919 = call core.sub(%t2941, %t2932) :: float
+      %t2915 = call core.sub(%t2928, %t2932) :: float
+      %t2920 = call core.clamp(%t2915, %t2926, %t2919) :: float
+      %t2908 = call core.mul(%t2920, %t2957) :: float
+      %acc2900 = acc_add agg.sum(%acc2900, %t2908) :: float
+    end_loop
+    %t2909 = acc_load %acc2900 :: float
+    %t2965 = const 168600.0 :: float
+    %t2966 = make_tuple(%t2921, %t2965) :: tuple<float>
+    %t2967 = fold %t2966 fn="agg.min" :: float
+    %t2968 = const 0.062 :: float
+    %t2969 = call core.mul(%t2967, %t2968) :: float
+    %t2972 = const 0.0145 :: float
+    %t2973 = call core.mul(%t2921, %t2972) :: float
+    %t2960 = call core.add(%t2969, %t2973) :: float
+    %t2975 = const 200000.0 :: float
+    %t2976 = call core.sub(%t2921, %t2975) :: float
+    %t2978 = make_tuple(%t2976, %t2926) :: tuple<float, integer>
+    %t2979 = fold %t2978 fn="agg.max" :: float
+    %t2980 = const 0.009 :: float
+    %t2981 = call core.mul(%t2979, %t2980) :: float
+    %t2962 = call core.add(%t2960, %t2981) :: float
+    %t522 = call core.add(%t2909, %t2962) :: float
+    %t2983 = load_input "state_rate" :: float
+    %t2984 = call core.mul(%t2921, %t2983) :: float
+    %t524 = call core.add(%t522, %t2984) :: float
+    %t2986 = load_input "local_rate" :: float
+    %t2987 = call core.mul(%t2921, %t2986) :: float
+    %t526 = call core.add(%t524, %t2987) :: float
+    yield %t526
+  )
+  (Declaration total_eff_hoh
+    %acc2996 = decl_acc :: float
+    %t2997 = load_input "fed" :: array
+    %t2998 = load_field t2997["head_of_household"] :: any
+    %t2999 = load_field t2998["rates"] :: any
+    %t3017 = load_input "income" :: float
+    %t3018 = load_input "fed" :: any
+    %t3022 = const 0 :: integer
+    %t3033 = const -1 :: integer
+    %t3035 = const 100000000000.0 :: float
+    %t3019 = load_field t3018["head_of_household"] :: any
+    %t3020 = load_field t3019["std"] :: float
+    %t3021 = call core.sub(%t3017, %t3020) :: float
+    %t3023 = make_tuple(%t3021, %t3022) :: tuple<float, integer>
+    %t3024 = fold %t3023 fn="agg.max" :: float
+    loop rates id=L50 in %t2999 as el=%t3000, idx=%t3001
+      %t3028 = load_field t3000["lo"] :: float
+      %t3041 = load_field t3000["hi"] :: float
+      %t3053 = load_field t3000["rate"] :: float
+      %t3034 = call core.eq(%t3041, %t3033) :: boolean
+      %t3037 = select %t3034, %t3035, %t3041 :: float
+      %t3015 = call core.sub(%t3037, %t3028) :: float
+      %t3011 = call core.sub(%t3024, %t3028) :: float
+      %t3016 = call core.clamp(%t3011, %t3022, %t3015) :: float
+      %t3004 = call core.mul(%t3016, %t3053) :: float
+      %acc2996 = acc_add agg.sum(%acc2996, %t3004) :: float
+    end_loop
+    %t3005 = acc_load %acc2996 :: float
+    %t3061 = const 168600.0 :: float
+    %t3062 = make_tuple(%t3017, %t3061) :: tuple<float>
+    %t3063 = fold %t3062 fn="agg.min" :: float
+    %t3064 = const 0.062 :: float
+    %t3065 = call core.mul(%t3063, %t3064) :: float
+    %t3068 = const 0.0145 :: float
+    %t3069 = call core.mul(%t3017, %t3068) :: float
+    %t3056 = call core.add(%t3065, %t3069) :: float
+    %t3071 = const 200000.0 :: float
+    %t3072 = call core.sub(%t3017, %t3071) :: float
+    %t3074 = make_tuple(%t3072, %t3022) :: tuple<float, integer>
+    %t3075 = fold %t3074 fn="agg.max" :: float
+    %t3076 = const 0.009 :: float
+    %t3077 = call core.mul(%t3075, %t3076) :: float
+    %t3058 = call core.add(%t3056, %t3077) :: float
+    %t2990 = call core.add(%t3005, %t3058) :: float
+    %t3079 = load_input "state_rate" :: float
+    %t3080 = call core.mul(%t3017, %t3079) :: float
+    %t2992 = call core.add(%t2990, %t3080) :: float
+    %t3082 = load_input "local_rate" :: float
+    %t3083 = call core.mul(%t3017, %t3082) :: float
+    %t2994 = call core.add(%t2992, %t3083) :: float
+    %t529 = const 1.0 :: float
+    %t530 = make_tuple(%t3017, %t529) :: tuple<float>
+    %t531 = fold %t530 fn="agg.max" :: float
+    %t532 = call core.div(%t2994, %t531) :: float
+    yield %t532
+  )
+  (Declaration after_tax_hoh
+    %t533 = load_input "income" :: float
+    %acc3092 = decl_acc :: float
+    %t3093 = load_input "fed" :: array
+    %t3094 = load_field t3093["head_of_household"] :: any
+    %t3095 = load_field t3094["rates"] :: any
+    %t3114 = load_input "fed" :: any
+    %t3118 = const 0 :: integer
+    %t3129 = const -1 :: integer
+    %t3131 = const 100000000000.0 :: float
+    %t3115 = load_field t3114["head_of_household"] :: any
+    %t3116 = load_field t3115["std"] :: float
+    %t3117 = call core.sub(%t533, %t3116) :: float
+    %t3119 = make_tuple(%t3117, %t3118) :: tuple<float, integer>
+    %t3120 = fold %t3119 fn="agg.max" :: float
+    loop rates id=L51 in %t3095 as el=%t3096, idx=%t3097
+      %t3124 = load_field t3096["lo"] :: float
+      %t3137 = load_field t3096["hi"] :: float
+      %t3149 = load_field t3096["rate"] :: float
+      %t3130 = call core.eq(%t3137, %t3129) :: boolean
+      %t3133 = select %t3130, %t3131, %t3137 :: float
+      %t3111 = call core.sub(%t3133, %t3124) :: float
+      %t3107 = call core.sub(%t3120, %t3124) :: float
+      %t3112 = call core.clamp(%t3107, %t3118, %t3111) :: float
+      %t3100 = call core.mul(%t3112, %t3149) :: float
+      %acc3092 = acc_add agg.sum(%acc3092, %t3100) :: float
+    end_loop
+    %t3101 = acc_load %acc3092 :: float
+    %t3157 = const 168600.0 :: float
+    %t3158 = make_tuple(%t533, %t3157) :: tuple<float>
+    %t3159 = fold %t3158 fn="agg.min" :: float
+    %t3160 = const 0.062 :: float
+    %t3161 = call core.mul(%t3159, %t3160) :: float
+    %t3164 = const 0.0145 :: float
+    %t3165 = call core.mul(%t533, %t3164) :: float
+    %t3152 = call core.add(%t3161, %t3165) :: float
+    %t3167 = const 200000.0 :: float
+    %t3168 = call core.sub(%t533, %t3167) :: float
+    %t3170 = make_tuple(%t3168, %t3118) :: tuple<float, integer>
+    %t3171 = fold %t3170 fn="agg.max" :: float
+    %t3172 = const 0.009 :: float
+    %t3173 = call core.mul(%t3171, %t3172) :: float
+    %t3154 = call core.add(%t3152, %t3173) :: float
+    %t3086 = call core.add(%t3101, %t3154) :: float
+    %t3175 = load_input "state_rate" :: float
+    %t3176 = call core.mul(%t533, %t3175) :: float
+    %t3088 = call core.add(%t3086, %t3176) :: float
+    %t3178 = load_input "local_rate" :: float
+    %t3179 = call core.mul(%t533, %t3178) :: float
+    %t3090 = call core.add(%t3088, %t3179) :: float
+    %t535 = call core.sub(%t533, %t3090) :: float
+    yield %t535
+  )
+  (Declaration take_home_hoh
+    %t3180 = load_input "income" :: float
+    %acc3191 = decl_acc :: float
+    %t3192 = load_input "fed" :: array
+    %t3193 = load_field t3192["head_of_household"] :: any
+    %t3194 = load_field t3193["rates"] :: any
+    %t3213 = load_input "fed" :: any
+    %t3217 = const 0 :: integer
+    %t3228 = const -1 :: integer
+    %t3230 = const 100000000000.0 :: float
+    %t3214 = load_field t3213["head_of_household"] :: any
+    %t3215 = load_field t3214["std"] :: float
+    %t3216 = call core.sub(%t3180, %t3215) :: float
+    %t3218 = make_tuple(%t3216, %t3217) :: tuple<float, integer>
+    %t3219 = fold %t3218 fn="agg.max" :: float
+    loop rates id=L52 in %t3194 as el=%t3195, idx=%t3196
+      %t3223 = load_field t3195["lo"] :: float
+      %t3236 = load_field t3195["hi"] :: float
+      %t3248 = load_field t3195["rate"] :: float
+      %t3229 = call core.eq(%t3236, %t3228) :: boolean
+      %t3232 = select %t3229, %t3230, %t3236 :: float
+      %t3210 = call core.sub(%t3232, %t3223) :: float
+      %t3206 = call core.sub(%t3219, %t3223) :: float
+      %t3211 = call core.clamp(%t3206, %t3217, %t3210) :: float
+      %t3199 = call core.mul(%t3211, %t3248) :: float
+      %acc3191 = acc_add agg.sum(%acc3191, %t3199) :: float
+    end_loop
+    %t3200 = acc_load %acc3191 :: float
+    %t3256 = const 168600.0 :: float
+    %t3257 = make_tuple(%t3180, %t3256) :: tuple<float>
+    %t3258 = fold %t3257 fn="agg.min" :: float
+    %t3259 = const 0.062 :: float
+    %t3260 = call core.mul(%t3258, %t3259) :: float
+    %t3263 = const 0.0145 :: float
+    %t3264 = call core.mul(%t3180, %t3263) :: float
+    %t3251 = call core.add(%t3260, %t3264) :: float
+    %t3266 = const 200000.0 :: float
+    %t3267 = call core.sub(%t3180, %t3266) :: float
+    %t3269 = make_tuple(%t3267, %t3217) :: tuple<float, integer>
+    %t3270 = fold %t3269 fn="agg.max" :: float
+    %t3271 = const 0.009 :: float
+    %t3272 = call core.mul(%t3270, %t3271) :: float
+    %t3253 = call core.add(%t3251, %t3272) :: float
+    %t3185 = call core.add(%t3200, %t3253) :: float
+    %t3274 = load_input "state_rate" :: float
+    %t3275 = call core.mul(%t3180, %t3274) :: float
+    %t3187 = call core.add(%t3185, %t3275) :: float
+    %t3277 = load_input "local_rate" :: float
+    %t3278 = call core.mul(%t3180, %t3277) :: float
+    %t3189 = call core.add(%t3187, %t3278) :: float
+    %t3182 = call core.sub(%t3180, %t3189) :: float
+    %t537 = load_input "retirement_contrib" :: float
+    %t538 = call core.sub(%t3182, %t537) :: float
+    yield %t538
+  )
+  (Declaration summary
+    %acc3280 = decl_acc :: float
+    %t3281 = load_input "fed" :: array
+    %t3282 = load_field t3281["single"] :: any
+    %t3283 = load_field t3282["rates"] :: any
+    %acc3349 = decl_acc :: float
+    %t3301 = load_input "income" :: float
+    %t3302 = load_input "fed" :: any
+    %t3306 = const 0 :: integer
+    %t3325 = const -1 :: integer
+    %t3327 = const 100000000000.0 :: float
+    %t3303 = load_field t3302["single"] :: any
+    %t3304 = load_field t3303["std"] :: float
+    %t3305 = call core.sub(%t3301, %t3304) :: float
+    %t3307 = make_tuple(%t3305, %t3306) :: tuple<float, integer>
+    %t3308 = fold %t3307 fn="agg.max" :: float
+    loop rates id=L53 in %t3283 as el=%t3284, idx=%t3285
+      %t3320 = load_field t3284["lo"] :: float
+      %t3333 = load_field t3284["hi"] :: float
+      %t3341 = load_field t3284["rate"] :: float
+      %t3326 = call core.eq(%t3333, %t3325) :: boolean
+      %t3329 = select %t3326, %t3327, %t3333 :: float
+      %t3297 = call core.gte(%t3308, %t3320) :: boolean
+      %t3299 = call core.lt(%t3308, %t3329) :: boolean
+      %t3300 = call core.and(%t3297, %t3299) :: boolean
+      %t3289 = select %t3300, %t3341, %t3306 :: float
+      %acc3280 = acc_add agg.sum(%acc3280, %t3289) :: float
+      %t3364 = call core.sub(%t3308, %t3320) :: float
+      %t3368 = call core.sub(%t3329, %t3320) :: float
+      %t3369 = call core.clamp(%t3364, %t3306, %t3368) :: float
+      %t3357 = call core.mul(%t3369, %t3341) :: float
+      %acc3349 = acc_add agg.sum(%acc3349, %t3357) :: float
+    end_loop
+    %t3290 = acc_load %acc3280 :: float
+    %t3358 = acc_load %acc3349 :: float
+    %t3344 = const 1.0 :: float
+    %t3345 = make_tuple(%t3301, %t3344) :: tuple<float>
+    %t3346 = fold %t3345 fn="agg.max" :: float
+    %t3347 = call core.div(%t3358, %t3346) :: float
+    %acc3408 = decl_acc :: float
+    loop rates id=L55 in %t3283 as el=%t3412, idx=%t3413
+      %t3440 = load_field t3412["lo"] :: float
+      %t3453 = load_field t3412["hi"] :: float
+      %t3465 = load_field t3412["rate"] :: float
+      %t3423 = call core.sub(%t3308, %t3440) :: float
+      %t3446 = call core.eq(%t3453, %t3325) :: boolean
+      %t3449 = select %t3446, %t3327, %t3453 :: float
+      %t3427 = call core.sub(%t3449, %t3440) :: float
+      %t3428 = call core.clamp(%t3423, %t3306, %t3427) :: float
+      %t3416 = call core.mul(%t3428, %t3465) :: float
+      %acc3408 = acc_add agg.sum(%acc3408, %t3416) :: float
+    end_loop
+    %t3417 = acc_load %acc3408 :: float
+    %t542 = make_object{marginal: %t3290, effective: %t3347, tax: %t3417} :: object
+    %t3478 = const 168600.0 :: float
+    %t3479 = make_tuple(%t3301, %t3478) :: tuple<float>
+    %t3480 = fold %t3479 fn="agg.min" :: float
+    %t3481 = const 0.062 :: float
+    %t3482 = call core.mul(%t3480, %t3481) :: float
+    %t3484 = const 0.0145 :: float
+    %t3485 = call core.mul(%t3301, %t3484) :: float
+    %t3474 = call core.add(%t3482, %t3485) :: float
+    %t3487 = const 200000.0 :: float
+    %t3488 = call core.sub(%t3301, %t3487) :: float
+    %t3490 = make_tuple(%t3488, %t3306) :: tuple<float, integer>
+    %t3491 = fold %t3490 fn="agg.max" :: float
+    %t3492 = const 0.009 :: float
+    %t3493 = call core.mul(%t3491, %t3492) :: float
+    %t3476 = call core.add(%t3474, %t3493) :: float
+    %t3471 = call core.div(%t3476, %t3346) :: float
+    %t545 = make_object{effective: %t3471, tax: %t3476} :: object
+    %t546 = load_input "state_rate" :: float
+    %t3518 = call core.mul(%t3301, %t546) :: float
+    %t549 = make_object{marginal: %t546, effective: %t546, tax: %t3518} :: object
+    %t550 = load_input "local_rate" :: float
+    %t3521 = call core.mul(%t3301, %t550) :: float
+    %t553 = make_object{marginal: %t550, effective: %t550, tax: %t3521} :: object
+    %acc3536 = decl_acc :: float
+    loop rates id=L56 in %t3283 as el=%t3540, idx=%t3541
+      %t3568 = load_field t3540["lo"] :: float
+      %t3581 = load_field t3540["hi"] :: float
+      %t3593 = load_field t3540["rate"] :: float
+      %t3551 = call core.sub(%t3308, %t3568) :: float
+      %t3574 = call core.eq(%t3581, %t3325) :: boolean
+      %t3577 = select %t3574, %t3327, %t3581 :: float
+      %t3555 = call core.sub(%t3577, %t3568) :: float
+      %t3556 = call core.clamp(%t3551, %t3306, %t3555) :: float
+      %t3544 = call core.mul(%t3556, %t3593) :: float
+      %acc3536 = acc_add agg.sum(%acc3536, %t3544) :: float
+    end_loop
+    %t3545 = acc_load %acc3536 :: float
+    %t3530 = call core.add(%t3545, %t3476) :: float
+    %t3532 = call core.add(%t3530, %t3518) :: float
+    %t3534 = call core.add(%t3532, %t3521) :: float
+    %t3527 = call core.div(%t3534, %t3346) :: float
+    %acc3630 = decl_acc :: float
+    loop rates id=L57 in %t3283 as el=%t3634, idx=%t3635
+      %t3662 = load_field t3634["lo"] :: float
+      %t3675 = load_field t3634["hi"] :: float
+      %t3687 = load_field t3634["rate"] :: float
+      %t3645 = call core.sub(%t3308, %t3662) :: float
+      %t3668 = call core.eq(%t3675, %t3325) :: boolean
+      %t3671 = select %t3668, %t3327, %t3675 :: float
+      %t3649 = call core.sub(%t3671, %t3662) :: float
+      %t3650 = call core.clamp(%t3645, %t3306, %t3649) :: float
+      %t3638 = call core.mul(%t3650, %t3687) :: float
+      %acc3630 = acc_add agg.sum(%acc3630, %t3638) :: float
+    end_loop
+    %t3639 = acc_load %acc3630 :: float
+    %t3624 = call core.add(%t3639, %t3476) :: float
+    %t3626 = call core.add(%t3624, %t3518) :: float
+    %t3628 = call core.add(%t3626, %t3521) :: float
+    %t556 = make_object{effective: %t3527, tax: %t3628} :: object
+    %acc3727 = decl_acc :: float
+    loop rates id=L58 in %t3283 as el=%t3731, idx=%t3732
+      %t3759 = load_field t3731["lo"] :: float
+      %t3772 = load_field t3731["hi"] :: float
+      %t3784 = load_field t3731["rate"] :: float
+      %t3742 = call core.sub(%t3308, %t3759) :: float
+      %t3765 = call core.eq(%t3772, %t3325) :: boolean
+      %t3768 = select %t3765, %t3327, %t3772 :: float
+      %t3746 = call core.sub(%t3768, %t3759) :: float
+      %t3747 = call core.clamp(%t3742, %t3306, %t3746) :: float
+      %t3735 = call core.mul(%t3747, %t3784) :: float
+      %acc3727 = acc_add agg.sum(%acc3727, %t3735) :: float
+    end_loop
+    %t3736 = acc_load %acc3727 :: float
+    %t3721 = call core.add(%t3736, %t3476) :: float
+    %t3723 = call core.add(%t3721, %t3518) :: float
+    %t3725 = call core.add(%t3723, %t3521) :: float
+    %t3718 = call core.sub(%t3301, %t3725) :: float
+    %t558 = load_input "retirement_contrib" :: float
+    %acc3827 = decl_acc :: float
+    loop rates id=L59 in %t3283 as el=%t3831, idx=%t3832
+      %t3859 = load_field t3831["lo"] :: float
+      %t3872 = load_field t3831["hi"] :: float
+      %t3884 = load_field t3831["rate"] :: float
+      %t3842 = call core.sub(%t3308, %t3859) :: float
+      %t3865 = call core.eq(%t3872, %t3325) :: boolean
+      %t3868 = select %t3865, %t3327, %t3872 :: float
+      %t3846 = call core.sub(%t3868, %t3859) :: float
+      %t3847 = call core.clamp(%t3842, %t3306, %t3846) :: float
+      %t3835 = call core.mul(%t3847, %t3884) :: float
+      %acc3827 = acc_add agg.sum(%acc3827, %t3835) :: float
+    end_loop
+    %t3836 = acc_load %acc3827 :: float
+    %t3821 = call core.add(%t3836, %t3476) :: float
+    %t3823 = call core.add(%t3821, %t3518) :: float
+    %t3825 = call core.add(%t3823, %t3521) :: float
+    %t3818 = call core.sub(%t3301, %t3825) :: float
+    %t3815 = call core.sub(%t3818, %t558) :: float
+    %t560 = make_object{federal: %t542, fica: %t545, state: %t549, local: %t553, total: %t556, after_tax: %t3718, retirement_contrib: %t558, take_home: %t3815} :: object
+    %acc3914 = decl_acc :: float
+    %t3916 = load_field t3281["married_joint"] :: any
+    %t3917 = load_field t3916["rates"] :: any
+    %acc3983 = decl_acc :: float
+    %t3937 = load_field t3302["married_joint"] :: any
+    %t3938 = load_field t3937["std"] :: float
+    %t3939 = call core.sub(%t3301, %t3938) :: float
+    %t3941 = make_tuple(%t3939, %t3306) :: tuple<float, integer>
+    %t3942 = fold %t3941 fn="agg.max" :: float
+    loop rates id=L60 in %t3917 as el=%t3918, idx=%t3919
+      %t3954 = load_field t3918["lo"] :: float
+      %t3967 = load_field t3918["hi"] :: float
+      %t3975 = load_field t3918["rate"] :: float
+      %t3960 = call core.eq(%t3967, %t3325) :: boolean
+      %t3963 = select %t3960, %t3327, %t3967 :: float
+      %t3931 = call core.gte(%t3942, %t3954) :: boolean
+      %t3933 = call core.lt(%t3942, %t3963) :: boolean
+      %t3934 = call core.and(%t3931, %t3933) :: boolean
+      %t3923 = select %t3934, %t3975, %t3306 :: float
+      %acc3914 = acc_add agg.sum(%acc3914, %t3923) :: float
+      %t3998 = call core.sub(%t3942, %t3954) :: float
+      %t4002 = call core.sub(%t3963, %t3954) :: float
+      %t4003 = call core.clamp(%t3998, %t3306, %t4002) :: float
+      %t3991 = call core.mul(%t4003, %t3975) :: float
+      %acc3983 = acc_add agg.sum(%acc3983, %t3991) :: float
+    end_loop
+    %t3924 = acc_load %acc3914 :: float
+    %t3992 = acc_load %acc3983 :: float
+    %t3981 = call core.div(%t3992, %t3346) :: float
+    %acc4042 = decl_acc :: float
+    loop rates id=L62 in %t3917 as el=%t4046, idx=%t4047
+      %t4074 = load_field t4046["lo"] :: float
+      %t4087 = load_field t4046["hi"] :: float
+      %t4099 = load_field t4046["rate"] :: float
+      %t4057 = call core.sub(%t3942, %t4074) :: float
+      %t4080 = call core.eq(%t4087, %t3325) :: boolean
+      %t4083 = select %t4080, %t3327, %t4087 :: float
+      %t4061 = call core.sub(%t4083, %t4074) :: float
+      %t4062 = call core.clamp(%t4057, %t3306, %t4061) :: float
+      %t4050 = call core.mul(%t4062, %t4099) :: float
+      %acc4042 = acc_add agg.sum(%acc4042, %t4050) :: float
+    end_loop
+    %t4051 = acc_load %acc4042 :: float
+    %t564 = make_object{marginal: %t3924, effective: %t3981, tax: %t4051} :: object
+    %t4123 = const 250000.0 :: float
+    %t4124 = call core.sub(%t3301, %t4123) :: float
+    %t4126 = make_tuple(%t4124, %t3306) :: tuple<float, integer>
+    %t4127 = fold %t4126 fn="agg.max" :: float
+    %t4129 = call core.mul(%t4127, %t3492) :: float
+    %t4110 = call core.add(%t3474, %t4129) :: float
+    %t4105 = call core.div(%t4110, %t3346) :: float
+    %t567 = make_object{effective: %t4105, tax: %t4110} :: object
+    %acc4174 = decl_acc :: float
+    loop rates id=L63 in %t3917 as el=%t4178, idx=%t4179
+      %t4206 = load_field t4178["lo"] :: float
+      %t4219 = load_field t4178["hi"] :: float
+      %t4231 = load_field t4178["rate"] :: float
+      %t4189 = call core.sub(%t3942, %t4206) :: float
+      %t4212 = call core.eq(%t4219, %t3325) :: boolean
+      %t4215 = select %t4212, %t3327, %t4219 :: float
+      %t4193 = call core.sub(%t4215, %t4206) :: float
+      %t4194 = call core.clamp(%t4189, %t3306, %t4193) :: float
+      %t4182 = call core.mul(%t4194, %t4231) :: float
+      %acc4174 = acc_add agg.sum(%acc4174, %t4182) :: float
+    end_loop
+    %t4183 = acc_load %acc4174 :: float
+    %t4168 = call core.add(%t4183, %t4110) :: float
+    %t4170 = call core.add(%t4168, %t3518) :: float
+    %t4172 = call core.add(%t4170, %t3521) :: float
+    %t4165 = call core.div(%t4172, %t3346) :: float
+    %acc4270 = decl_acc :: float
+    loop rates id=L64 in %t3917 as el=%t4274, idx=%t4275
+      %t4302 = load_field t4274["lo"] :: float
+      %t4315 = load_field t4274["hi"] :: float
+      %t4327 = load_field t4274["rate"] :: float
+      %t4285 = call core.sub(%t3942, %t4302) :: float
+      %t4308 = call core.eq(%t4315, %t3325) :: boolean
+      %t4311 = select %t4308, %t3327, %t4315 :: float
+      %t4289 = call core.sub(%t4311, %t4302) :: float
+      %t4290 = call core.clamp(%t4285, %t3306, %t4289) :: float
+      %t4278 = call core.mul(%t4290, %t4327) :: float
+      %acc4270 = acc_add agg.sum(%acc4270, %t4278) :: float
+    end_loop
+    %t4279 = acc_load %acc4270 :: float
+    %t4264 = call core.add(%t4279, %t4110) :: float
+    %t4266 = call core.add(%t4264, %t3518) :: float
+    %t4268 = call core.add(%t4266, %t3521) :: float
+    %t578 = make_object{effective: %t4165, tax: %t4268} :: object
+    %acc4369 = decl_acc :: float
+    loop rates id=L65 in %t3917 as el=%t4373, idx=%t4374
+      %t4401 = load_field t4373["lo"] :: float
+      %t4414 = load_field t4373["hi"] :: float
+      %t4426 = load_field t4373["rate"] :: float
+      %t4384 = call core.sub(%t3942, %t4401) :: float
+      %t4407 = call core.eq(%t4414, %t3325) :: boolean
+      %t4410 = select %t4407, %t3327, %t4414 :: float
+      %t4388 = call core.sub(%t4410, %t4401) :: float
+      %t4389 = call core.clamp(%t4384, %t3306, %t4388) :: float
+      %t4377 = call core.mul(%t4389, %t4426) :: float
+      %acc4369 = acc_add agg.sum(%acc4369, %t4377) :: float
+    end_loop
+    %t4378 = acc_load %acc4369 :: float
+    %t4363 = call core.add(%t4378, %t4110) :: float
+    %t4365 = call core.add(%t4363, %t3518) :: float
+    %t4367 = call core.add(%t4365, %t3521) :: float
+    %t4360 = call core.sub(%t3301, %t4367) :: float
+    %acc4471 = decl_acc :: float
+    loop rates id=L66 in %t3917 as el=%t4475, idx=%t4476
+      %t4503 = load_field t4475["lo"] :: float
+      %t4516 = load_field t4475["hi"] :: float
+      %t4528 = load_field t4475["rate"] :: float
+      %t4486 = call core.sub(%t3942, %t4503) :: float
+      %t4509 = call core.eq(%t4516, %t3325) :: boolean
+      %t4512 = select %t4509, %t3327, %t4516 :: float
+      %t4490 = call core.sub(%t4512, %t4503) :: float
+      %t4491 = call core.clamp(%t4486, %t3306, %t4490) :: float
+      %t4479 = call core.mul(%t4491, %t4528) :: float
+      %acc4471 = acc_add agg.sum(%acc4471, %t4479) :: float
+    end_loop
+    %t4480 = acc_load %acc4471 :: float
+    %t4465 = call core.add(%t4480, %t4110) :: float
+    %t4467 = call core.add(%t4465, %t3518) :: float
+    %t4469 = call core.add(%t4467, %t3521) :: float
+    %t4462 = call core.sub(%t3301, %t4469) :: float
+    %t4459 = call core.sub(%t4462, %t558) :: float
+    %t582 = make_object{federal: %t564, fica: %t567, state: %t549, local: %t553, total: %t578, after_tax: %t4360, retirement_contrib: %t558, take_home: %t4459} :: object
+    %acc4560 = decl_acc :: float
+    %t4562 = load_field t3281["married_separate"] :: any
+    %t4563 = load_field t4562["rates"] :: any
+    %acc4629 = decl_acc :: float
+    %t4583 = load_field t3302["married_separate"] :: any
+    %t4584 = load_field t4583["std"] :: float
+    %t4585 = call core.sub(%t3301, %t4584) :: float
+    %t4587 = make_tuple(%t4585, %t3306) :: tuple<float, integer>
+    %t4588 = fold %t4587 fn="agg.max" :: float
+    loop rates id=L67 in %t4563 as el=%t4564, idx=%t4565
+      %t4600 = load_field t4564["lo"] :: float
+      %t4613 = load_field t4564["hi"] :: float
+      %t4621 = load_field t4564["rate"] :: float
+      %t4606 = call core.eq(%t4613, %t3325) :: boolean
+      %t4609 = select %t4606, %t3327, %t4613 :: float
+      %t4577 = call core.gte(%t4588, %t4600) :: boolean
+      %t4579 = call core.lt(%t4588, %t4609) :: boolean
+      %t4580 = call core.and(%t4577, %t4579) :: boolean
+      %t4569 = select %t4580, %t4621, %t3306 :: float
+      %acc4560 = acc_add agg.sum(%acc4560, %t4569) :: float
+      %t4644 = call core.sub(%t4588, %t4600) :: float
+      %t4648 = call core.sub(%t4609, %t4600) :: float
+      %t4649 = call core.clamp(%t4644, %t3306, %t4648) :: float
+      %t4637 = call core.mul(%t4649, %t4621) :: float
+      %acc4629 = acc_add agg.sum(%acc4629, %t4637) :: float
+    end_loop
+    %t4570 = acc_load %acc4560 :: float
+    %t4638 = acc_load %acc4629 :: float
+    %t4627 = call core.div(%t4638, %t3346) :: float
+    %acc4688 = decl_acc :: float
+    loop rates id=L69 in %t4563 as el=%t4692, idx=%t4693
+      %t4720 = load_field t4692["lo"] :: float
+      %t4733 = load_field t4692["hi"] :: float
+      %t4745 = load_field t4692["rate"] :: float
+      %t4703 = call core.sub(%t4588, %t4720) :: float
+      %t4726 = call core.eq(%t4733, %t3325) :: boolean
+      %t4729 = select %t4726, %t3327, %t4733 :: float
+      %t4707 = call core.sub(%t4729, %t4720) :: float
+      %t4708 = call core.clamp(%t4703, %t3306, %t4707) :: float
+      %t4696 = call core.mul(%t4708, %t4745) :: float
+      %acc4688 = acc_add agg.sum(%acc4688, %t4696) :: float
+    end_loop
+    %t4697 = acc_load %acc4688 :: float
+    %t586 = make_object{marginal: %t4570, effective: %t4627, tax: %t4697} :: object
+    %t4769 = const 125000.0 :: float
+    %t4770 = call core.sub(%t3301, %t4769) :: float
+    %t4772 = make_tuple(%t4770, %t3306) :: tuple<float, integer>
+    %t4773 = fold %t4772 fn="agg.max" :: float
+    %t4775 = call core.mul(%t4773, %t3492) :: float
+    %t4756 = call core.add(%t3474, %t4775) :: float
+    %t4751 = call core.div(%t4756, %t3346) :: float
+    %t589 = make_object{effective: %t4751, tax: %t4756} :: object
+    %acc4820 = decl_acc :: float
+    loop rates id=L70 in %t4563 as el=%t4824, idx=%t4825
+      %t4852 = load_field t4824["lo"] :: float
+      %t4865 = load_field t4824["hi"] :: float
+      %t4877 = load_field t4824["rate"] :: float
+      %t4835 = call core.sub(%t4588, %t4852) :: float
+      %t4858 = call core.eq(%t4865, %t3325) :: boolean
+      %t4861 = select %t4858, %t3327, %t4865 :: float
+      %t4839 = call core.sub(%t4861, %t4852) :: float
+      %t4840 = call core.clamp(%t4835, %t3306, %t4839) :: float
+      %t4828 = call core.mul(%t4840, %t4877) :: float
+      %acc4820 = acc_add agg.sum(%acc4820, %t4828) :: float
+    end_loop
+    %t4829 = acc_load %acc4820 :: float
+    %t4814 = call core.add(%t4829, %t4756) :: float
+    %t4816 = call core.add(%t4814, %t3518) :: float
+    %t4818 = call core.add(%t4816, %t3521) :: float
+    %t4811 = call core.div(%t4818, %t3346) :: float
+    %acc4916 = decl_acc :: float
+    loop rates id=L71 in %t4563 as el=%t4920, idx=%t4921
+      %t4948 = load_field t4920["lo"] :: float
+      %t4961 = load_field t4920["hi"] :: float
+      %t4973 = load_field t4920["rate"] :: float
+      %t4931 = call core.sub(%t4588, %t4948) :: float
+      %t4954 = call core.eq(%t4961, %t3325) :: boolean
+      %t4957 = select %t4954, %t3327, %t4961 :: float
+      %t4935 = call core.sub(%t4957, %t4948) :: float
+      %t4936 = call core.clamp(%t4931, %t3306, %t4935) :: float
+      %t4924 = call core.mul(%t4936, %t4973) :: float
+      %acc4916 = acc_add agg.sum(%acc4916, %t4924) :: float
+    end_loop
+    %t4925 = acc_load %acc4916 :: float
+    %t4910 = call core.add(%t4925, %t4756) :: float
+    %t4912 = call core.add(%t4910, %t3518) :: float
+    %t4914 = call core.add(%t4912, %t3521) :: float
+    %t600 = make_object{effective: %t4811, tax: %t4914} :: object
+    %acc5015 = decl_acc :: float
+    loop rates id=L72 in %t4563 as el=%t5019, idx=%t5020
+      %t5047 = load_field t5019["lo"] :: float
+      %t5060 = load_field t5019["hi"] :: float
+      %t5072 = load_field t5019["rate"] :: float
+      %t5030 = call core.sub(%t4588, %t5047) :: float
+      %t5053 = call core.eq(%t5060, %t3325) :: boolean
+      %t5056 = select %t5053, %t3327, %t5060 :: float
+      %t5034 = call core.sub(%t5056, %t5047) :: float
+      %t5035 = call core.clamp(%t5030, %t3306, %t5034) :: float
+      %t5023 = call core.mul(%t5035, %t5072) :: float
+      %acc5015 = acc_add agg.sum(%acc5015, %t5023) :: float
+    end_loop
+    %t5024 = acc_load %acc5015 :: float
+    %t5009 = call core.add(%t5024, %t4756) :: float
+    %t5011 = call core.add(%t5009, %t3518) :: float
+    %t5013 = call core.add(%t5011, %t3521) :: float
+    %t5006 = call core.sub(%t3301, %t5013) :: float
+    %acc5117 = decl_acc :: float
+    loop rates id=L73 in %t4563 as el=%t5121, idx=%t5122
+      %t5149 = load_field t5121["lo"] :: float
+      %t5162 = load_field t5121["hi"] :: float
+      %t5174 = load_field t5121["rate"] :: float
+      %t5132 = call core.sub(%t4588, %t5149) :: float
+      %t5155 = call core.eq(%t5162, %t3325) :: boolean
+      %t5158 = select %t5155, %t3327, %t5162 :: float
+      %t5136 = call core.sub(%t5158, %t5149) :: float
+      %t5137 = call core.clamp(%t5132, %t3306, %t5136) :: float
+      %t5125 = call core.mul(%t5137, %t5174) :: float
+      %acc5117 = acc_add agg.sum(%acc5117, %t5125) :: float
+    end_loop
+    %t5126 = acc_load %acc5117 :: float
+    %t5111 = call core.add(%t5126, %t4756) :: float
+    %t5113 = call core.add(%t5111, %t3518) :: float
+    %t5115 = call core.add(%t5113, %t3521) :: float
+    %t5108 = call core.sub(%t3301, %t5115) :: float
+    %t5105 = call core.sub(%t5108, %t558) :: float
+    %t604 = make_object{federal: %t586, fica: %t589, state: %t549, local: %t553, total: %t600, after_tax: %t5006, retirement_contrib: %t558, take_home: %t5105} :: object
+    %acc5206 = decl_acc :: float
+    %t5208 = load_field t3281["head_of_household"] :: any
+    %t5209 = load_field t5208["rates"] :: any
+    %acc5275 = decl_acc :: float
+    %t5229 = load_field t3302["head_of_household"] :: any
+    %t5230 = load_field t5229["std"] :: float
+    %t5231 = call core.sub(%t3301, %t5230) :: float
+    %t5233 = make_tuple(%t5231, %t3306) :: tuple<float, integer>
+    %t5234 = fold %t5233 fn="agg.max" :: float
+    loop rates id=L74 in %t5209 as el=%t5210, idx=%t5211
+      %t5246 = load_field t5210["lo"] :: float
+      %t5259 = load_field t5210["hi"] :: float
+      %t5267 = load_field t5210["rate"] :: float
+      %t5252 = call core.eq(%t5259, %t3325) :: boolean
+      %t5255 = select %t5252, %t3327, %t5259 :: float
+      %t5223 = call core.gte(%t5234, %t5246) :: boolean
+      %t5225 = call core.lt(%t5234, %t5255) :: boolean
+      %t5226 = call core.and(%t5223, %t5225) :: boolean
+      %t5215 = select %t5226, %t5267, %t3306 :: float
+      %acc5206 = acc_add agg.sum(%acc5206, %t5215) :: float
+      %t5290 = call core.sub(%t5234, %t5246) :: float
+      %t5294 = call core.sub(%t5255, %t5246) :: float
+      %t5295 = call core.clamp(%t5290, %t3306, %t5294) :: float
+      %t5283 = call core.mul(%t5295, %t5267) :: float
+      %acc5275 = acc_add agg.sum(%acc5275, %t5283) :: float
+    end_loop
+    %t5216 = acc_load %acc5206 :: float
+    %t5284 = acc_load %acc5275 :: float
+    %t5273 = call core.div(%t5284, %t3346) :: float
+    %acc5334 = decl_acc :: float
+    loop rates id=L76 in %t5209 as el=%t5338, idx=%t5339
+      %t5366 = load_field t5338["lo"] :: float
+      %t5379 = load_field t5338["hi"] :: float
+      %t5391 = load_field t5338["rate"] :: float
+      %t5349 = call core.sub(%t5234, %t5366) :: float
+      %t5372 = call core.eq(%t5379, %t3325) :: boolean
+      %t5375 = select %t5372, %t3327, %t5379 :: float
+      %t5353 = call core.sub(%t5375, %t5366) :: float
+      %t5354 = call core.clamp(%t5349, %t3306, %t5353) :: float
+      %t5342 = call core.mul(%t5354, %t5391) :: float
+      %acc5334 = acc_add agg.sum(%acc5334, %t5342) :: float
+    end_loop
+    %t5343 = acc_load %acc5334 :: float
+    %t608 = make_object{marginal: %t5216, effective: %t5273, tax: %t5343} :: object
+    %acc5466 = decl_acc :: float
+    loop rates id=L77 in %t5209 as el=%t5470, idx=%t5471
+      %t5498 = load_field t5470["lo"] :: float
+      %t5511 = load_field t5470["hi"] :: float
+      %t5523 = load_field t5470["rate"] :: float
+      %t5481 = call core.sub(%t5234, %t5498) :: float
+      %t5504 = call core.eq(%t5511, %t3325) :: boolean
+      %t5507 = select %t5504, %t3327, %t5511 :: float
+      %t5485 = call core.sub(%t5507, %t5498) :: float
+      %t5486 = call core.clamp(%t5481, %t3306, %t5485) :: float
+      %t5474 = call core.mul(%t5486, %t5523) :: float
+      %acc5466 = acc_add agg.sum(%acc5466, %t5474) :: float
+    end_loop
+    %t5475 = acc_load %acc5466 :: float
+    %t5460 = call core.add(%t5475, %t3476) :: float
+    %t5462 = call core.add(%t5460, %t3518) :: float
+    %t5464 = call core.add(%t5462, %t3521) :: float
+    %t5457 = call core.div(%t5464, %t3346) :: float
+    %acc5562 = decl_acc :: float
+    loop rates id=L78 in %t5209 as el=%t5566, idx=%t5567
+      %t5594 = load_field t5566["lo"] :: float
+      %t5607 = load_field t5566["hi"] :: float
+      %t5619 = load_field t5566["rate"] :: float
+      %t5577 = call core.sub(%t5234, %t5594) :: float
+      %t5600 = call core.eq(%t5607, %t3325) :: boolean
+      %t5603 = select %t5600, %t3327, %t5607 :: float
+      %t5581 = call core.sub(%t5603, %t5594) :: float
+      %t5582 = call core.clamp(%t5577, %t3306, %t5581) :: float
+      %t5570 = call core.mul(%t5582, %t5619) :: float
+      %acc5562 = acc_add agg.sum(%acc5562, %t5570) :: float
+    end_loop
+    %t5571 = acc_load %acc5562 :: float
+    %t5556 = call core.add(%t5571, %t3476) :: float
+    %t5558 = call core.add(%t5556, %t3518) :: float
+    %t5560 = call core.add(%t5558, %t3521) :: float
+    %t622 = make_object{effective: %t5457, tax: %t5560} :: object
+    %acc5661 = decl_acc :: float
+    loop rates id=L79 in %t5209 as el=%t5665, idx=%t5666
+      %t5693 = load_field t5665["lo"] :: float
+      %t5706 = load_field t5665["hi"] :: float
+      %t5718 = load_field t5665["rate"] :: float
+      %t5676 = call core.sub(%t5234, %t5693) :: float
+      %t5699 = call core.eq(%t5706, %t3325) :: boolean
+      %t5702 = select %t5699, %t3327, %t5706 :: float
+      %t5680 = call core.sub(%t5702, %t5693) :: float
+      %t5681 = call core.clamp(%t5676, %t3306, %t5680) :: float
+      %t5669 = call core.mul(%t5681, %t5718) :: float
+      %acc5661 = acc_add agg.sum(%acc5661, %t5669) :: float
+    end_loop
+    %t5670 = acc_load %acc5661 :: float
+    %t5655 = call core.add(%t5670, %t3476) :: float
+    %t5657 = call core.add(%t5655, %t3518) :: float
+    %t5659 = call core.add(%t5657, %t3521) :: float
+    %t5652 = call core.sub(%t3301, %t5659) :: float
+    %acc5763 = decl_acc :: float
+    loop rates id=L80 in %t5209 as el=%t5767, idx=%t5768
+      %t5795 = load_field t5767["lo"] :: float
+      %t5808 = load_field t5767["hi"] :: float
+      %t5820 = load_field t5767["rate"] :: float
+      %t5778 = call core.sub(%t5234, %t5795) :: float
+      %t5801 = call core.eq(%t5808, %t3325) :: boolean
+      %t5804 = select %t5801, %t3327, %t5808 :: float
+      %t5782 = call core.sub(%t5804, %t5795) :: float
+      %t5783 = call core.clamp(%t5778, %t3306, %t5782) :: float
+      %t5771 = call core.mul(%t5783, %t5820) :: float
+      %acc5763 = acc_add agg.sum(%acc5763, %t5771) :: float
+    end_loop
+    %t5772 = acc_load %acc5763 :: float
+    %t5757 = call core.add(%t5772, %t3476) :: float
+    %t5759 = call core.add(%t5757, %t3518) :: float
+    %t5761 = call core.add(%t5759, %t3521) :: float
+    %t5754 = call core.sub(%t3301, %t5761) :: float
+    %t5751 = call core.sub(%t5754, %t558) :: float
+    %t626 = make_object{federal: %t608, fica: %t545, state: %t549, local: %t553, total: %t622, after_tax: %t5652, retirement_contrib: %t558, take_home: %t5751} :: object
+    %t627 = make_object{single: %t560, married_joint: %t582, married_separate: %t604, head_of_household: %t626} :: object
+    yield %t627
+  )
+)