import mods.modularmachinery.RecipeBuilder;

val mythinfus1 = RecipeBuilder.newBuilder("mythinfus1","mythic_processor_infuser",2);
mythinfus1.addEnergyPerTickInput(1000000);
mythinfus1.addFluidInput(<fluid:neutron>*5);
mythinfus1.addItemInput(<ore:ingotOgerite>);
mythinfus1.addItemOutput(<extendedcrafting:material:33>*3);
mythinfus1.build();

val mythinfus2 = RecipeBuilder.newBuilder("mythinfus2","mythic_processor_infuser",2);
mythinfus2.addEnergyPerTickInput(1000000);
mythinfus2.addFluidInput(<fluid:neutron>*5);
mythinfus2.addItemInput(<ore:ingotDraconiumAwakened>);
mythinfus2.addItemOutput(<extendedcrafting:material:33>);
mythinfus2.build();

val mythinfus3 = RecipeBuilder.newBuilder("mythinfus3","mythic_processor_infuser",2);
mythinfus3.addEnergyPerTickInput(1000000);
mythinfus3.addFluidInput(<fluid:lava>*10000);
mythinfus3.addItemInput(<contenttweaker:heated_organic_mythic_board>);
mythinfus3.addItemOutput(<contenttweaker:warm_organic_mythic_board>);
mythinfus3.build();

val mythinfus4 = RecipeBuilder.newBuilder("mythinfus4","mythic_processor_infuser",2);
mythinfus4.addEnergyPerTickInput(1000000);
mythinfus4.addFluidInput(<fluid:darkstarlight>*1000);
mythinfus4.addItemInput(<contenttweaker:stormlight_infused_crystal>*64);
mythinfus4.addItemOutput(<contenttweaker:darkstar_infused_crystal>*64);
mythinfus4.build();

val mythinfus5 = RecipeBuilder.newBuilder("mythinfus5","mythic_processor_infuser",2);
mythinfus5.addEnergyPerTickInput(1000000);
mythinfus5.addFluidInput(<fluid:stormlight>*2000);
mythinfus5.addItemInput(<aoa3:crystallite_block>*64);
mythinfus5.addItemOutput(<contenttweaker:stormlight_infused_crystal>*64);
mythinfus5.build();

val mythinfus6 = RecipeBuilder.newBuilder("mythinfus6","mythic_processor_infuser",2);
mythinfus6.addEnergyPerTickInput(1000000);
mythinfus6.addFluidInput(<fluid:pulsating_starlight>*100);
mythinfus6.addItemInput(<contenttweaker:reactive_fluix>*10);
mythinfus6.addItemOutput(<contenttweaker:pulsating_fluix>*10);
mythinfus6.build();

val mythinfus7 = RecipeBuilder.newBuilder("mythinfus7","mythic_processor_infuser",2);
mythinfus7.addEnergyPerTickInput(1000000);
mythinfus7.addFluidInput(<fluid:fluix_plasma>*1000);
mythinfus7.addItemInput(<contenttweaker:unidentified_gem>*10);
mythinfus7.addItemOutput(<contenttweaker:reactive_fluix>*10);
mythinfus7.build();

val mythinfus8 = RecipeBuilder.newBuilder("mythinfus8","mythic_processor_infuser",2);
mythinfus8.addEnergyPerTickInput(1000000);
mythinfus8.addFluidInput(<fluid:lifeessence>*200);
mythinfus8.addItemInput(<bhc:red_heart>*10);
mythinfus8.addItemOutput(<bewitchment:heart>*10);
mythinfus8.build();

val mythinfus9 = RecipeBuilder.newBuilder("mythinfus9","mythic_processor_infuser",2);
mythinfus9.addEnergyPerTickInput(1000000);
mythinfus9.addFluidInput(<fluid:neutron>*10000);
mythinfus9.addItemInput(<avaritia:resource:5>*10);
mythinfus9.addItemOutput(<contenttweaker:infinity_core>*10);
mythinfus9.build();

val mythinfus10 = RecipeBuilder.newBuilder("mythinfus10","mythic_processor_infuser",2);
mythinfus10.addEnergyPerTickInput(1000000);
mythinfus10.addFluidInput(<fluid:cryotheum>*50);
mythinfus10.addItemInput(<contenttweaker:searing_organic_mythic_board>);
mythinfus10.addItemOutput(<contenttweaker:quenched_organic_mythic_board>);
mythinfus10.build();

val mythinfus11 = RecipeBuilder.newBuilder("mythinfus11","mythic_processor_infuser",2);
mythinfus11.addEnergyPerTickInput(1000000);
mythinfus11.addFluidInput(<fluid:halite_fluid>*1000);
mythinfus11.addItemInput(<extendedcrafting:singularity_ultimate>*4);
mythinfus11.addItemOutput(<contenttweaker:heart_of_the_halite_warrior>*4);
mythinfus11.build();

val mythinfus12 = RecipeBuilder.newBuilder("mythinfus12","mythic_processor_infuser",2);
mythinfus12.addEnergyPerTickInput(1000000);
mythinfus12.addFluidInput(<fluid:lava>*10000);
mythinfus12.addItemInput(<contenttweaker:warm_organic_mythic_board>);
mythinfus12.addItemOutput(<contenttweaker:hot_organic_mythic_board>);
mythinfus12.build();

val mythinfus13 = RecipeBuilder.newBuilder("mythinfus13","mythic_processor_infuser",2);
mythinfus13.addEnergyPerTickInput(1000000);
mythinfus13.addFluidInput(<fluid:xpjuice>*3200);
mythinfus13.addItemInput(<minecraft:fermented_spider_eye>*64);
mythinfus13.addItemOutput(<contenttweaker:experienced_spider_eye>*64);
mythinfus13.build();

val mythinfus14 = RecipeBuilder.newBuilder("mythinfus14","mythic_processor_infuser",2);
mythinfus14.addEnergyPerTickInput(1000000);
mythinfus14.addFluidInput(<fluid:experience>*3200);
mythinfus14.addItemInput(<minecraft:fermented_spider_eye>*64);
mythinfus14.addItemOutput(<contenttweaker:experienced_spider_eye>*64);
mythinfus14.build();

val mythinfus15 = RecipeBuilder.newBuilder("mythinfus15","mythic_processor_infuser",2);
mythinfus15.addEnergyPerTickInput(1000000);
mythinfus15.addFluidInput(<fluid:essence>*3200);
mythinfus15.addItemInput(<minecraft:fermented_spider_eye>*64);
mythinfus15.addItemOutput(<contenttweaker:experienced_spider_eye>*64);
mythinfus15.build();

val mythinfus16 = RecipeBuilder.newBuilder("mythinfus16","mythic_processor_infuser",2);
mythinfus16.addEnergyPerTickInput(1000000);
mythinfus16.addFluidInput(<fluid:lava>*10000);
mythinfus16.addItemInput(<contenttweaker:hot_organic_mythic_board>);
mythinfus16.addItemOutput(<contenttweaker:searing_organic_mythic_board>);
mythinfus16.build();

val mythinfus17 = RecipeBuilder.newBuilder("mythinfus17","mythic_processor_infuser",2);
mythinfus17.addEnergyPerTickInput(1000000);
mythinfus17.addFluidInput(<fluid:cryotheum>*10000);
mythinfus17.addItemInput(<contenttweaker:quenched_organic_mythic_board>);
mythinfus17.addItemOutput(<contenttweaker:cured_organic_mythic_board>);
mythinfus17.build();

val mythinfus18 = RecipeBuilder.newBuilder("mythinfus18","mythic_processor_infuser",2);
mythinfus18.addEnergyPerTickInput(1000000);
mythinfus18.addFluidInput(<fluid:fuel_mixed_heavy_heat_2>*2);
mythinfus18.addItemInput(<contenttweaker:hydrocarbon_coated_organic_mythic_board>);
mythinfus18.addItemOutput(<contenttweaker:heated_organic_mythic_board>);
mythinfus18.build();

val mythinfus19 = RecipeBuilder.newBuilder("mythinfus19","mythic_processor_infuser",2);
mythinfus19.addEnergyPerTickInput(1000000);
mythinfus19.addFluidInput(<fluid:eptane>*100);
mythinfus19.addItemInput(<contenttweaker:fixed_organic_mythic_board>);
mythinfus19.addItemOutput(<contenttweaker:hydrocarbon_coated_organic_mythic_board>);
mythinfus19.build();

val mythinfus20 = RecipeBuilder.newBuilder("mythinfus20","mythic_processor_infuser",2);
mythinfus20.addEnergyPerTickInput(1000000);
mythinfus20.addFluidInput(<fluid:lumiotheum>*100);
mythinfus20.addItemInput(<contenttweaker:twice_coated_organic_mythic_board>);
mythinfus20.addItemOutput(<contenttweaker:thrice_coated_organic_mythic_board>);
mythinfus20.build();

val mythinfus21 = RecipeBuilder.newBuilder("mythinfus21","mythic_processor_infuser",2);
mythinfus21.addEnergyPerTickInput(1000000);
mythinfus21.addFluidInput(<fluid:empoweredoil>*100);
mythinfus21.addItemInput(<contenttweaker:once_coated_organic_mythic_board>);
mythinfus21.addItemOutput(<contenttweaker:twice_coated_organic_mythic_board>);
mythinfus21.build();

val mythinfus22 = RecipeBuilder.newBuilder("mythinfus22","mythic_processor_infuser",2);
mythinfus22.addEnergyPerTickInput(1000000);
mythinfus22.addFluidInput(<fluid:refined_fuel>*100);
mythinfus22.addItemInput(<contenttweaker:uncured_organic_mythic_board>);
mythinfus22.addItemOutput(<contenttweaker:once_coated_organic_mythic_board>);
mythinfus22.build();

val mythinfus23 = RecipeBuilder.newBuilder("mythinfus23","mythic_processor_infuser",2);
mythinfus23.addEnergyPerTickInput(1000000);
mythinfus23.addFluidInput(<fluid:neutron>*100);
mythinfus23.addItemInput(<ore:nuggetUltimate>*10);
mythinfus23.addItemOutput(<contenttweaker:imperfect_neutronium_nugget>*10);
mythinfus23.build();

val mythinfus24 = RecipeBuilder.newBuilder("mythinfus24","mythic_processor_infuser",2);
mythinfus24.addEnergyPerTickInput(1000000);
mythinfus24.addFluidInput(<fluid:pre_baryonic_plasma>*100);
mythinfus24.addItemInput(<contenttweaker:strings_crystal>*12);
mythinfus24.addItemOutput(<contenttweaker:big_bang_matter>);
mythinfus24.build();

val mythinfus25 = RecipeBuilder.newBuilder("mythinfus25","mythic_processor_infuser",2);
mythinfus25.addEnergyPerTickInput(1000000);
mythinfus25.addFluidInput(<fluid:whisper_of_starvald_demelain>*1);
mythinfus25.addItemInput(<contenttweaker:gem_of_dimensional_ascension>);
mythinfus25.addItemOutput(<contenttweaker:gem_of_dimensional_ascension>*32);
mythinfus25.build();

val mythinfus26 = RecipeBuilder.newBuilder("mythinfus26","mythic_processor_infuser",2);
mythinfus26.addEnergyPerTickInput(1000000);
mythinfus26.addFluidInput(<fluid:crystallized_obsidian>*10000);
mythinfus26.addItemInput(<ore:nuggetIron>*10);
mythinfus26.addItemOutput(<cyclicmagic:crystallized_obsidian>*10);
mythinfus26.build();

val mythinfus27 = RecipeBuilder.newBuilder("mythinfus27","mythic_processor_infuser",2);
mythinfus27.addEnergyPerTickInput(1000000);
mythinfus27.addFluidInput(<fluid:crystal>*10000);
mythinfus27.addItemInput(<ore:nuggetIron>*10);
mythinfus27.addItemOutput(<cyclicmagic:crystallized_obsidian>*10);
mythinfus27.build();

val mythinfus28 = RecipeBuilder.newBuilder("mythinfus28","mythic_processor_infuser",2);
mythinfus28.addEnergyPerTickInput(1000000);
mythinfus28.addFluidInput(<fluid:amber>*10000);
mythinfus28.addItemInput(<ore:nuggetGold>*10);
mythinfus28.addItemOutput(<cyclicmagic:crystallized_amber>*10);
mythinfus28.build();

val mythinfus29 = RecipeBuilder.newBuilder("mythinfus29","mythic_processor_infuser",2);
mythinfus29.addEnergyPerTickInput(1000000);
mythinfus29.addFluidInput(<fluid:molten_blood_infused_iron>*1440);
mythinfus29.addItemInput(<bloodmagic:demon_crystal:4>*10);
mythinfus29.addItemOutput(<contenttweaker:samarium_dust>*10);
mythinfus29.build();

val mythinfus30 = RecipeBuilder.newBuilder("mythinfus30","mythic_processor_infuser",2);
mythinfus30.addEnergyPerTickInput(1000000);
mythinfus30.addFluidInput(<fluid:messy_rainbow_fluid>*1000);
mythinfus30.addItemInput(<ore:oreAstralStarmetal>*10);
mythinfus30.addItemOutput(<contenttweaker:tantalum_chunk>*30);
mythinfus30.build();

val mythinfus31 = RecipeBuilder.newBuilder("mythinfus31","mythic_processor_infuser",2);
mythinfus31.addEnergyPerTickInput(1000000);
mythinfus31.addFluidInput(<fluid:messy_rainbow_fluid>*1000);
mythinfus31.addItemInput(<ore:oreMithril>*10);
mythinfus31.addItemOutput(<contenttweaker:hafnium_chunk>*30);
mythinfus31.build();

val mythinfus32 = RecipeBuilder.newBuilder("mythinfus32","mythic_processor_infuser",2);
mythinfus32.addEnergyPerTickInput(1000000);
mythinfus32.addFluidInput(<fluid:boric_acid>*2000);
mythinfus32.addItemInput(<ore:ingotPlatinum>*120);
mythinfus32.addItemOutput(<contenttweaker:indium_dust>*10);
mythinfus32.build();

val mythinfus33 = RecipeBuilder.newBuilder("mythinfus33","mythic_processor_infuser",2);
mythinfus33.addEnergyPerTickInput(1000000);
mythinfus33.addFluidInput(<fluid:krypton_xenon_mix>*100);
mythinfus33.addItemInput(<contenttweaker:silica_gelatin>*10);
mythinfus33.addItemOutput(<contenttweaker:krypton_xenon_capture>*10);
mythinfus33.build();

val mythinfus34 = RecipeBuilder.newBuilder("mythinfus34","mythic_processor_infuser",2);
mythinfus34.addEnergyPerTickInput(1000000);
mythinfus34.addFluidInput(<fluid:hydrated_gelatin>*720);
mythinfus34.addItemInput(<contenttweaker:silica_dust>*10);
mythinfus34.addItemOutput(<contenttweaker:silica_gelatin>*40);
mythinfus34.build();

val mythinfus35 = RecipeBuilder.newBuilder("mythinfus35","mythic_processor_infuser",2);
mythinfus35.addEnergyPerTickInput(1000000);
mythinfus35.addFluidInput(<fluid:niobium>*100);
mythinfus35.addItemInput(<ore:dustMyrmitite>*10);
mythinfus35.addItemOutput(<contenttweaker:myrminiobite_ingot>*10);
mythinfus35.build();

val mythinfus36 = RecipeBuilder.newBuilder("mythinfus36","mythic_processor_infuser",2);
mythinfus36.addEnergyPerTickInput(1000000);
mythinfus36.addFluidInput(<fluid:plasma>*100);
mythinfus36.addItemInput(<contenttweaker:abyssite_crystal>*10);
mythinfus36.addItemOutput(<materialpart:abyssite:ingot>*10);
mythinfus36.build();

val mythinfus37 = RecipeBuilder.newBuilder("mythinfus37","mythic_processor_infuser",2);
mythinfus37.addEnergyPerTickInput(1000000);
mythinfus37.addFluidInput(<fluid:lymph_of_pixonia>*720);
mythinfus37.addItemInput(<ore:ingotVibranium>*10);
mythinfus37.addItemOutput(<contenttweaker:ethereal_infusion_stone>*10);
mythinfus37.build();

val mythinfus38 = RecipeBuilder.newBuilder("mythinfus38","mythic_processor_infuser",2);
mythinfus38.addEnergyPerTickInput(1000000);
mythinfus38.addFluidInput(<fluid:cursed_myrmitite>*2500);
mythinfus38.addItemInput(<techreborn:part:9>*10);
mythinfus38.addItemOutput(<contenttweaker:myrmex_coolant_cell>*10);
mythinfus38.build();

val mythinfus39 = RecipeBuilder.newBuilder("mythinfus39","mythic_processor_infuser",2);
mythinfus39.addEnergyPerTickInput(1000000);
mythinfus39.addFluidInput(<fluid:dimensional_essence>*1000);
mythinfus39.addItemInput(<ore:ingotLunastone>*10);
mythinfus39.addItemOutput(<contenttweaker:nethersky_steel_ingot>*40);
mythinfus39.build();

val mythinfus40 = RecipeBuilder.newBuilder("mythinfus40","mythic_processor_infuser",2);
mythinfus40.addEnergyPerTickInput(1000000);
mythinfus40.addFluidInput(<fluid:dimensional_essence>*1000);
mythinfus40.addItemInput(<ore:ingotVityte>*10);
mythinfus40.addItemOutput(<contenttweaker:nethersky_steel_ingot>*30);
mythinfus40.build();

val mythinfus41 = RecipeBuilder.newBuilder("mythinfus41","mythic_processor_infuser",2);
mythinfus41.addEnergyPerTickInput(1000000);
mythinfus41.addFluidInput(<fluid:dimensional_essence>*1000);
mythinfus41.addItemInput(<ore:ingotFluctuatite>*10);
mythinfus41.addItemOutput(<contenttweaker:nethersky_steel_ingot>*20);
mythinfus41.build();

val mythinfus42 = RecipeBuilder.newBuilder("mythinfus42","mythic_processor_infuser",2);
mythinfus42.addEnergyPerTickInput(1000000);
mythinfus42.addFluidInput(<fluid:dimensional_essence>*1000);
mythinfus42.addItemInput(<ore:ingotColdIron>*10);
mythinfus42.addItemOutput(<contenttweaker:nethersky_steel_ingot>*10);
mythinfus42.build();

val mythinfus43 = RecipeBuilder.newBuilder("mythinfus43","mythic_processor_infuser",2);
mythinfus43.addEnergyPerTickInput(1000000);
mythinfus43.addFluidInput(<fluid:recursive_computing_matter>*4000);
mythinfus43.addItemInput(<forestry:propolis:3>*64);
mythinfus43.addItemOutput(<contenttweaker:inquiring_propolis>*64);
mythinfus43.build();



val mythinfus44 = RecipeBuilder.newBuilder("mythinfus44","mythic_processor_infuser",2);
mythinfus44.addEnergyPerTickInput(1000000);
mythinfus44.addFluidInput(<fluid:muons>*1000);
mythinfus44.addItemInput(<contenttweaker:inert_crystal>*10);
mythinfus44.addItemOutput(<contenttweaker:muon_crystal>*10);
mythinfus44.build();

val mythinfus45 = RecipeBuilder.newBuilder("mythinfus45","mythic_processor_infuser",2);
mythinfus45.addEnergyPerTickInput(1000000);
mythinfus45.addFluidInput(<fluid:electrons>*6000);
mythinfus45.addItemInput(<ore:ingotMithril>*10);
mythinfus45.addItemOutput(<contenttweaker:negatively_charged_mithril>*10);
mythinfus45.build();

val mythinfus46 = RecipeBuilder.newBuilder("mythinfus46","mythic_processor_infuser",2);
mythinfus46.addEnergyPerTickInput(1000000);
mythinfus46.addFluidInput(<fluid:atomic_nuclei>*6000);
mythinfus46.addItemInput(<ore:ingotMithril>*10);
mythinfus46.addItemOutput(<contenttweaker:positively_charged_mithril>*10);
mythinfus46.build();

val mythinfus47 = RecipeBuilder.newBuilder("mythinfus47","mythic_processor_infuser",2);
mythinfus47.addEnergyPerTickInput(1000000);
mythinfus47.addFluidInput(<fluid:fractallite_halite>*120);
mythinfus47.addItemInput(<avaritia:resource:5>*10);
mythinfus47.addItemOutput(<avaritiaitem:fractallite_halite_catalyst>*10);
mythinfus47.build();



val mythinfus48 = RecipeBuilder.newBuilder("mythinfus48","mythic_processor_infuser",2);
mythinfus48.addEnergyPerTickInput(1000000);
mythinfus48.addFluidInput(<fluid:recursive_computing_matter>*1000);
mythinfus48.addItemInput(<contenttweaker:seeker_stone>);
mythinfus48.addItemOutput(<contenttweaker:reality_pebble>*4);
mythinfus48.build();

val mythinfus49 = RecipeBuilder.newBuilder("mythinfus49","mythic_processor_infuser",2);
mythinfus49.addEnergyPerTickInput(1000000);
mythinfus49.addFluidInput(<fluid:recursive_computing_matter>*1000);
mythinfus49.addItemInput(<contenttweaker:stone_of_universal_balance>);
mythinfus49.addItemOutput(<contenttweaker:seeker_stone>*4);
mythinfus49.build();

val mythinfus50 = RecipeBuilder.newBuilder("mythinfus50","mythic_processor_infuser",2);
mythinfus50.addEnergyPerTickInput(1000000);
mythinfus50.addFluidInput(<fluid:arbiterium>*10);
mythinfus50.addItemInput(<contenttweaker:unidentified_egg>*10);
mythinfus50.addItemOutput(<contenttweaker:unidentifying_egg>*10);
mythinfus50.build();

val mythinfus51 = RecipeBuilder.newBuilder("mythinfus51","mythic_processor_infuser",2);
mythinfus51.addEnergyPerTickInput(1000000);
mythinfus51.addFluidInput(<fluid:lifeessence>*16000);
mythinfus51.addItemInput(<openblocks:tank>);
mythinfus51.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "lifeessence", Amount: 16000}}));
mythinfus51.build();

val mythinfus52 = RecipeBuilder.newBuilder("mythinfus52","mythic_processor_infuser",2);
mythinfus52.addEnergyPerTickInput(1000000);
mythinfus52.addFluidInput(<fluid:sideral_life_essence>*1024000);
mythinfus52.addItemInput(<bloodmagic:blood_tank:6>);
mythinfus52.addItemOutput(<bloodmagic:blood_tank:6>.withTag({Fluid: {FluidName: "sideral_life_essence", Amount: 1024000}}));
mythinfus52.build();

val mythinfus53 = RecipeBuilder.newBuilder("mythinfus53","mythic_processor_infuser",2);
mythinfus53.addEnergyPerTickInput(1000000);
mythinfus53.addFluidInput(<fluid:borax_solution>*16000);
mythinfus53.addItemInput(<openblocks:tank>);
mythinfus53.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "borax_solution", Amount: 16000}}));
mythinfus53.build();


val mythinfus54 = RecipeBuilder.newBuilder("mythinfus54","mythic_processor_infuser",2);
mythinfus54.addEnergyPerTickInput(1000000);
mythinfus54.addFluidInput(<fluid:mana>*16000);
mythinfus54.addItemInput(<openblocks:tank>);
mythinfus54.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "mana", Amount: 16000}}));
mythinfus54.build();

val mythinfus55 = RecipeBuilder.newBuilder("mythinfus55","mythic_processor_infuser",2);
mythinfus55.addEnergyPerTickInput(1000000);
mythinfus55.addFluidInput(<fluid:fluctuatite>*16000);
mythinfus55.addItemInput(<openblocks:tank>);
mythinfus55.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "fluctuatite", Amount: 16000}}));
mythinfus55.build();


val mythinfus56 = RecipeBuilder.newBuilder("mythinfus56","mythic_processor_infuser",2);
mythinfus56.addEnergyPerTickInput(1000000);
mythinfus56.addFluidInput(<fluid:strings>*1000);
mythinfus56.addItemInput(<contenttweaker:inert_crystal>*10);
mythinfus56.addItemOutput(<contenttweaker:strings_crystal>*10);
mythinfus56.build();

val mythinfus57 = RecipeBuilder.newBuilder("mythinfus57","mythic_processor_infuser",2);
mythinfus57.addEnergyPerTickInput(1000000);
mythinfus57.addFluidInput(<fluid:evanescent_bifrost>*500);
mythinfus57.addItemInput(<ore:dustSednanite>*10);
mythinfus57.addItemOutput(<contenttweaker:evanescent_sednanite_dust>*10);
mythinfus57.build();

val mythinfus58 = RecipeBuilder.newBuilder("mythinfus58","mythic_processor_infuser",2);
mythinfus58.addEnergyPerTickInput(1000000);
mythinfus58.addFluidInput(<fluid:binnie.juice.olive>*10000);
mythinfus58.addItemInput(<binniecore:glass:0>*10);
mythinfus58.addItemOutput(<binniecore:glass:1>.withTag({Fluid: {FluidName: "binnie.juice.olive", Amount: 1000}})*10);
mythinfus58.build();

val mythinfus59 = RecipeBuilder.newBuilder("mythinfus59","mythic_processor_infuser",2);
mythinfus59.addEnergyPerTickInput(1000000);
mythinfus59.addFluidInput(<fluid:oxygen>*10000);
mythinfus59.addItemInput(<ore:ingotUranium>*10);
mythinfus59.addItemOutput(<nuclearcraft:ingot_oxide:1>*10);
mythinfus59.build();

val mythinfus60 = RecipeBuilder.newBuilder("mythinfus60","mythic_processor_infuser",2);
mythinfus60.addEnergyPerTickInput(1000000);
mythinfus60.addFluidInput(<fluid:if.pink_slime>*100000);
mythinfus60.addItemInput(<ore:ingotIron>*50);
mythinfus60.addItemOutput(<industrialforegoing:pink_slime_ingot>*50);
mythinfus60.build();

val mythinfus61 = RecipeBuilder.newBuilder("mythinfus61","mythic_processor_infuser",2);
mythinfus61.addEnergyPerTickInput(1000000);
mythinfus61.addFluidInput(<fluid:liquid_life>*200);
mythinfus61.addItemInput(<minecraft:rotten_flesh>*640);
mythinfus61.addItemOutput(<contenttweaker:living_flesh>*10);
mythinfus61.build();








val mythinfus62 = RecipeBuilder.newBuilder("mythinfus62","mythic_processor_infuser",2);
mythinfus62.addEnergyPerTickInput(1000000);
mythinfus62.addFluidInput(<fluid:spatial_matter>*10000);
mythinfus62.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 1§r"]}}));
mythinfus62.setChance(0.0);
mythinfus62.addItemInput(<contenttweaker:fractal_stone>*10);
mythinfus62.addItemOutput(<contenttweaker:fractal_stone>*20);
mythinfus62.build();

val mythinfus62a = RecipeBuilder.newBuilder("mythinfus62a","mythic_processor_infuser",2);
mythinfus62a.addEnergyPerTickInput(1000000);
mythinfus62a.addFluidInput(<fluid:spatial_matter>*50000);
mythinfus62a.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 2§r"]}}));
mythinfus62a.setChance(0.0);
mythinfus62a.addItemInput(<contenttweaker:fractal_stone>*100);
mythinfus62a.addItemOutput(<contenttweaker:fractal_stone>*200);
mythinfus62a.build();

val mythinfus62b = RecipeBuilder.newBuilder("mythinfus62b","mythic_processor_infuser",2);
mythinfus62b.addEnergyPerTickInput(1000000);
mythinfus62b.addFluidInput(<fluid:spatial_matter>*100000);
mythinfus62b.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 3§r"]}}));
mythinfus62b.setChance(0.0);
mythinfus62b.addItemInput(<contenttweaker:fractal_stone>*1000);
mythinfus62b.addItemOutput(<contenttweaker:fractal_stone>*2000);
mythinfus62b.build();

val mythinfus63 = RecipeBuilder.newBuilder("mythinfus63","mythic_processor_infuser",2);
mythinfus63.addEnergyPerTickInput(1000000);
mythinfus63.addFluidInput(<fluid:cosmic_matter>*10000);
mythinfus63.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 1§r"]}}));
mythinfus63.setChance(0.0);
mythinfus63.addItemInput(<contenttweaker:fractal_stone>*10);
mythinfus63.addItemOutput(<contenttweaker:fractal_stone>*30);
mythinfus63.build();

val mythinfus63a = RecipeBuilder.newBuilder("mythinfus63a","mythic_processor_infuser",2);
mythinfus63a.addEnergyPerTickInput(1000000);
mythinfus63a.addFluidInput(<fluid:cosmic_matter>*50000);
mythinfus63a.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 2§r"]}}));
mythinfus63a.setChance(0.0);
mythinfus63a.addItemInput(<contenttweaker:fractal_stone>*100);
mythinfus63a.addItemOutput(<contenttweaker:fractal_stone>*300);
mythinfus63a.build();

val mythinfus63b = RecipeBuilder.newBuilder("mythinfus63b","mythic_processor_infuser",2);
mythinfus63b.addEnergyPerTickInput(1000000);
mythinfus63b.addFluidInput(<fluid:cosmic_matter>*100000);
mythinfus63b.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 3§r"]}}));
mythinfus63b.setChance(0.0);
mythinfus63b.addItemInput(<contenttweaker:fractal_stone>*1000);
mythinfus63b.addItemOutput(<contenttweaker:fractal_stone>*3000);
mythinfus63b.build();

val mythinfus64 = RecipeBuilder.newBuilder("mythinfus64","mythic_processor_infuser",2);
mythinfus64.addEnergyPerTickInput(1000000);
mythinfus64.addFluidInput(<fluid:galactic_matter>*10000);
mythinfus64.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 1§r"]}}));
mythinfus64.setChance(0.0);
mythinfus64.addItemInput(<contenttweaker:fractal_stone>*10);
mythinfus64.addItemOutput(<contenttweaker:fractal_stone>*40);
mythinfus64.build();

val mythinfus64a = RecipeBuilder.newBuilder("mythinfus64a","mythic_processor_infuser",2);
mythinfus64a.addEnergyPerTickInput(1000000);
mythinfus64a.addFluidInput(<fluid:galactic_matter>*50000);
mythinfus64a.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 2§r"]}}));
mythinfus64a.setChance(0.0);
mythinfus64a.addItemInput(<contenttweaker:fractal_stone>*100);
mythinfus64a.addItemOutput(<contenttweaker:fractal_stone>*400);
mythinfus64a.build();

val mythinfus64b = RecipeBuilder.newBuilder("mythinfus64b","mythic_processor_infuser",2);
mythinfus64b.addEnergyPerTickInput(1000000);
mythinfus64b.addFluidInput(<fluid:galactic_matter>*100000);
mythinfus64b.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 3§r"]}}));
mythinfus64b.setChance(0.0);
mythinfus64b.addItemInput(<contenttweaker:fractal_stone>*1000);
mythinfus64b.addItemOutput(<contenttweaker:fractal_stone>*4000);
mythinfus64b.build();

val mythinfus65 = RecipeBuilder.newBuilder("mythinfus65","mythic_processor_infuser",2);
mythinfus65.addEnergyPerTickInput(1000000);
mythinfus65.addFluidInput(<fluid:chaotic_matter>*10000);
mythinfus65.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 1§r"]}}));
mythinfus65.setChance(0.0);
mythinfus65.addItemInput(<contenttweaker:fractal_stone>*10);
mythinfus65.addItemOutput(<contenttweaker:fractal_stone>*50);
mythinfus65.build();

val mythinfus65a = RecipeBuilder.newBuilder("mythinfus65a","mythic_processor_infuser",2);
mythinfus65a.addEnergyPerTickInput(1000000);
mythinfus65a.addFluidInput(<fluid:chaotic_matter>*50000);
mythinfus65a.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 2§r"]}}));
mythinfus65a.setChance(0.0);
mythinfus65a.addItemInput(<contenttweaker:fractal_stone>*100);
mythinfus65a.addItemOutput(<contenttweaker:fractal_stone>*500);
mythinfus65a.build();

val mythinfus65b = RecipeBuilder.newBuilder("mythinfus65b","mythic_processor_infuser",2);
mythinfus65b.addEnergyPerTickInput(1000000);
mythinfus65b.addFluidInput(<fluid:chaotic_matter>*100000);
mythinfus65b.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 3§r"]}}));
mythinfus65b.setChance(0.0);
mythinfus65b.addItemInput(<contenttweaker:fractal_stone>*1000);
mythinfus65b.addItemOutput(<contenttweaker:fractal_stone>*5000);
mythinfus65b.build();

val mythinfus66 = RecipeBuilder.newBuilder("mythinfus66","mythic_processor_infuser",2);
mythinfus66.addEnergyPerTickInput(1000000);
mythinfus66.addFluidInput(<fluid:nightmarish_matter>*10000);
mythinfus66.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 1§r"]}}));
mythinfus66.setChance(0.0);
mythinfus66.addItemInput(<contenttweaker:fractal_stone>*10);
mythinfus66.addItemOutput(<contenttweaker:fractal_stone>*60);
mythinfus66.build();

val mythinfus66a = RecipeBuilder.newBuilder("mythinfus66a","mythic_processor_infuser",2);
mythinfus66a.addEnergyPerTickInput(1000000);
mythinfus66a.addFluidInput(<fluid:nightmarish_matter>*50000);
mythinfus66a.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 2§r"]}}));
mythinfus66a.setChance(0.0);
mythinfus66a.addItemInput(<contenttweaker:fractal_stone>*100);
mythinfus66a.addItemOutput(<contenttweaker:fractal_stone>*600);
mythinfus66a.build();

val mythinfus66b = RecipeBuilder.newBuilder("mythinfus66b","mythic_processor_infuser",2);
mythinfus66b.addEnergyPerTickInput(1000000);
mythinfus66b.addFluidInput(<fluid:nightmarish_matter>*100000);
mythinfus66b.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 3§r"]}}));
mythinfus66b.setChance(0.0);
mythinfus66b.addItemInput(<contenttweaker:fractal_stone>*1000);
mythinfus66b.addItemOutput(<contenttweaker:fractal_stone>*6000);
mythinfus66b.build();

val mythinfus67 = RecipeBuilder.newBuilder("mythinfus67","mythic_processor_infuser",2);
mythinfus67.addEnergyPerTickInput(1000000);
mythinfus67.addFluidInput(<fluid:universal_matter>*10000);
mythinfus67.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 1§r"]}}));
mythinfus67.setChance(0.0);
mythinfus67.addItemInput(<contenttweaker:fractal_stone>*10);
mythinfus67.addItemOutput(<contenttweaker:fractal_stone>*70);
mythinfus67.build();

val mythinfus67a = RecipeBuilder.newBuilder("mythinfus67a","mythic_processor_infuser",2);
mythinfus67a.addEnergyPerTickInput(1000000);
mythinfus67a.addFluidInput(<fluid:universal_matter>*50000);
mythinfus67a.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 2§r"]}}));
mythinfus67a.setChance(0.0);
mythinfus67a.addItemInput(<contenttweaker:fractal_stone>*100);
mythinfus67a.addItemOutput(<contenttweaker:fractal_stone>*700);
mythinfus67a.build();

val mythinfus67b = RecipeBuilder.newBuilder("mythinfus67b","mythic_processor_infuser",2);
mythinfus67b.addEnergyPerTickInput(1000000);
mythinfus67b.addFluidInput(<fluid:universal_matter>*100000);
mythinfus67b.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 3§r"]}}));
mythinfus67b.setChance(0.0);
mythinfus67b.addItemInput(<contenttweaker:fractal_stone>*1000);
mythinfus67b.addItemOutput(<contenttweaker:fractal_stone>*7000);
mythinfus67b.build();

val mythinfus68 = RecipeBuilder.newBuilder("mythinfus68","mythic_processor_infuser",2);
mythinfus68.addEnergyPerTickInput(1000000);
mythinfus68.addFluidInput(<fluid:ultimate_fractallite_essence>*10000);
mythinfus68.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 1§r"]}}));
mythinfus68.setChance(0.0);
mythinfus68.addItemInput(<contenttweaker:fractal_stone>*10);
mythinfus68.addItemOutput(<contenttweaker:fractal_stone>*80);
mythinfus68.build();

val mythinfus68a = RecipeBuilder.newBuilder("mythinfus68a","mythic_processor_infuser",2);
mythinfus68a.addEnergyPerTickInput(1000000);
mythinfus68a.addFluidInput(<fluid:ultimate_fractallite_essence>*50000);
mythinfus68a.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 2§r"]}}));
mythinfus68a.setChance(0.0);
mythinfus68a.addItemInput(<contenttweaker:fractal_stone>*100);
mythinfus68a.addItemOutput(<contenttweaker:fractal_stone>*800);
mythinfus68a.build();

val mythinfus68b = RecipeBuilder.newBuilder("mythinfus68b","mythic_processor_infuser",2);
mythinfus68b.addEnergyPerTickInput(1000000);
mythinfus68b.addFluidInput(<fluid:ultimate_fractallite_essence>*100000);
mythinfus68b.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 3§r"]}}));
mythinfus68b.setChance(0.0);
mythinfus68b.addItemInput(<contenttweaker:fractal_stone>*1000);
mythinfus68b.addItemOutput(<contenttweaker:fractal_stone>*8000);
mythinfus68b.build();

val mythinfus68c = RecipeBuilder.newBuilder("mythinfus68c","mythic_processor_infuser",2);
mythinfus68c.addEnergyPerTickInput(1000000);
mythinfus68c.addFluidInput(<fluid:ultimate_fractallite_essence>*200000);
mythinfus68c.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 4§r"]}}));
mythinfus68c.setChance(0.0);
mythinfus68c.addItemInput(<contenttweaker:fractal_stone>*10000);
mythinfus68c.addItemOutput(<contenttweaker:fractal_stone>*80000);
mythinfus68c.build();

val mythinfus68d = RecipeBuilder.newBuilder("mythinfus68d","mythic_processor_infuser",2);
mythinfus68d.addEnergyPerTickInput(1000000);
mythinfus68d.addFluidInput(<fluid:ultimate_fractallite_essence>*400000);
mythinfus68d.addItemInput(<contenttweaker:warren_configurator>.withTag({display: {Lore: ["§d§MMode 5§r"]}}));
mythinfus68d.setChance(0.0);
mythinfus68d.addItemInput(<contenttweaker:fractal_stone>*100000);
mythinfus68d.addItemOutput(<contenttweaker:fractal_stone>*800000);
mythinfus68d.build();

val mythinfus69 = RecipeBuilder.newBuilder("mythinfus69","mythic_processor_infuser",2);
mythinfus69.addEnergyPerTickInput(1000000);
mythinfus69.addFluidInput(<fluid:eleint_dragonfire>*1000);
mythinfus69.addItemInput(<minecraft:bucket>*1);
mythinfus69.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "eleint_dragonfire", Amount: 1000}));
mythinfus69.build();

val mythinfus70 = RecipeBuilder.newBuilder("mythinfus70","mythic_processor_infuser",2);
mythinfus70.addEnergyPerTickInput(1000000);
mythinfus70.addFluidInput(<fluid:nidhogg_dragonfire>*1000);
mythinfus70.addItemInput(<minecraft:bucket>*1);
mythinfus70.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "nidhogg_dragonfire", Amount: 1000}));
mythinfus70.build();

val mythinfus71 = RecipeBuilder.newBuilder("mythinfus71","mythic_processor_infuser",2);
mythinfus71.addEnergyPerTickInput(1000000);
mythinfus71.addFluidInput(<fluid:cryotheum>*4000);
mythinfus71.addItemInput(<materialpart:hot_vibranium_alloy:ingot>*32);
mythinfus71.addItemOutput(<materialpart:vibranium_alloy:ingot>*32);
mythinfus71.build();

val mythinfus72 = RecipeBuilder.newBuilder("mythinfus72","mythic_processor_infuser",2);
mythinfus72.addEnergyPerTickInput(1000000);
mythinfus72.addFluidInput(<fluid:protodermis>*2500);
mythinfus72.addItemInput(<divinerpg:mortum_soul>*10);
mythinfus72.addItemOutput(<contenttweaker:living_construct_soul>*10);
mythinfus72.build();

val mythinfus73 = RecipeBuilder.newBuilder("mythinfus73","mythic_processor_infuser",2);
mythinfus73.addEnergyPerTickInput(1000000);
mythinfus73.addFluidInput(<fluid:sideral_life_essence>*200);
mythinfus73.addItemInput(<materialpart:hot_vibranium_alloy:ingot>*128);
mythinfus73.addItemOutput(<materialpart:vibranium_alloy:ingot>*128);
mythinfus73.build();

val mythinfus74 = RecipeBuilder.newBuilder("mythinfus74","mythic_processor_infuser",2);
mythinfus74.addEnergyPerTickInput(1000000);
mythinfus74.addFluidInput(<fluid:liquidcoralium>*2000);
mythinfus74.addItemInput(<abyssalcraft:stone:6>*100);
mythinfus74.addItemOutput(<abyssalcraft:stone:5>*100);
mythinfus74.build();

val mythinfus75 = RecipeBuilder.newBuilder("mythinfus75","mythic_processor_infuser",2);
mythinfus75.addEnergyPerTickInput(1000000);
mythinfus75.addFluidInput(<fluid:eternal_dragon_fire>*1000);
mythinfus75.addItemInput(<minecraft:bucket>);
mythinfus75.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "eternal_dragon_fire", Amount: 1000}));
mythinfus75.build();

val mythinfus76 = RecipeBuilder.newBuilder("mythinfus76","mythic_processor_infuser",2);
mythinfus76.addEnergyPerTickInput(1000000);
mythinfus76.addFluidInput(<fluid:actualizing_fluid>*10);
mythinfus76.addItemInput(<contenttweaker:warren_chunk>*32);
mythinfus76.addItemOutput(<contenttweaker:actualized_chunk>*32);
mythinfus76.build();

val mythinfus77 = RecipeBuilder.newBuilder("mythinfus77","mythic_processor_infuser",2);
mythinfus77.addEnergyPerTickInput(1000000);
mythinfus77.addFluidInput(<fluid:binnie.bacteria>*20);
mythinfus77.addItemInput(<minecraft:sugar>*10);
mythinfus77.addItemOutput(<genetics:misc:3>*10);
mythinfus77.build();

val mythinfus78 = RecipeBuilder.newBuilder("mythinfus78","mythic_processor_infuser",2);
mythinfus78.addEnergyPerTickInput(1000000);
mythinfus78.addFluidInput(<fluid:enderium>*131072000);
mythinfus78.addItemInput(<bloodmagic:blood_tank:13>);
mythinfus78.addItemOutput(<bloodmagic:blood_tank:13>.withTag({Fluid: {FluidName: "enderium", Amount: 131072000}}));
mythinfus78.build();

val mythinfus79 = RecipeBuilder.newBuilder("mythinfus79","mythic_processor_infuser",2);
mythinfus79.addEnergyPerTickInput(1000000);
mythinfus79.addFluidInput(<fluid:lumium>*131072000);
mythinfus79.addItemInput(<bloodmagic:blood_tank:13>);
mythinfus79.addItemOutput(<bloodmagic:blood_tank:13>.withTag({Fluid: {FluidName: "lumium", Amount: 131072000}}));
mythinfus79.build();

val mythinfus80 = RecipeBuilder.newBuilder("mythinfus80","mythic_processor_infuser",2);
mythinfus80.addEnergyPerTickInput(1000000);
mythinfus80.addFluidInput(<fluid:recursive_computing_matter>*16000);
mythinfus80.addItemInput(<openblocks:tank>);
mythinfus80.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "recursive_computing_matter", Amount: 16000}}));
mythinfus80.build();

val mythinfus81 = RecipeBuilder.newBuilder("mythinfus81","mythic_processor_infuser",2);
mythinfus81.addEnergyPerTickInput(1000000);
mythinfus81.addFluidInput(<fluid:inquiring_protodermis>*16000);
mythinfus81.addItemInput(<openblocks:tank>);
mythinfus81.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "inquiring_protodermis", Amount: 16000}}));
mythinfus81.build();

val mythinfus82 = RecipeBuilder.newBuilder("mythinfus82","mythic_processor_infuser",2);
mythinfus82.addEnergyPerTickInput(1000000);
mythinfus82.addFluidInput(<fluid:otherworldly_tears>*100);
mythinfus82.addItemInput(<contenttweaker:crying_obsidian_powder>*10);
mythinfus82.addItemOutput(<contenttweaker:crying_obsidian_powder>*40);
mythinfus82.build();

val mythinfus83 = RecipeBuilder.newBuilder("mythinfus83","mythic_processor_infuser",2);
mythinfus83.addEnergyPerTickInput(1000000);
mythinfus83.addFluidInput(<fluid:hyperdense_plasma>*10);
mythinfus83.addItemInput(<contenttweaker:diamond_matrix>*1);
mythinfus83.addItemOutput(<avaritia:resource:0>*36);
mythinfus83.build();

val mythinfus84 = RecipeBuilder.newBuilder("mythinfus84","mythic_processor_infuser",2);
mythinfus84.addEnergyPerTickInput(1000000);
mythinfus84.addFluidInput(<fluid:lymph_of_pixonia>*1000);
mythinfus84.addItemInput(<minecraft:bucket>*1);
mythinfus84.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "lymph_of_pixonia", Amount: 1000}));
mythinfus84.build();

val mythinfus85 = RecipeBuilder.newBuilder("mythinfus85","mythic_processor_infuser",2);
mythinfus85.addEnergyPerTickInput(1000000);
mythinfus85.addFluidInput(<fluid:twilight_fire>*1000);
mythinfus85.addItemInput(<minecraft:bucket>*1);
mythinfus85.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "twilight_fire", Amount: 1000}));
mythinfus85.build();

val mythinfus86 = RecipeBuilder.newBuilder("mythinfus86","mythic_processor_infuser",2);
mythinfus86.addEnergyPerTickInput(1000000);
mythinfus86.addFluidInput(<fluid:recursive_computing_matter>*1000);
mythinfus86.addItemInput(<minecraft:bucket>*1);
mythinfus86.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "recursive_computing_matter", Amount: 1000}));
mythinfus86.build();

val mythinfus87 = RecipeBuilder.newBuilder("mythinfus87","mythic_processor_infuser",2);
mythinfus87.addEnergyPerTickInput(1000000);
mythinfus87.addFluidInput(<fluid:redstone>*18000);
mythinfus87.addItemInput(<ore:blockElectrum>*10);
mythinfus87.addItemOutput(<redstonearsenal:storage:0>*10);
mythinfus87.build();

val mythinfus88 = RecipeBuilder.newBuilder("mythinfus88","mythic_processor_infuser",2);
mythinfus88.addEnergyPerTickInput(1000000);
mythinfus88.addFluidInput(<fluid:redstone>*2000);
mythinfus88.addItemInput(<ore:ingotElectrum>*10);
mythinfus88.addItemOutput(<redstonearsenal:material:32>*10);
mythinfus88.build();

val mythinfus89 = RecipeBuilder.newBuilder("mythinfus89","mythic_processor_infuser",2);
mythinfus89.addEnergyPerTickInput(1000000);
mythinfus89.addFluidInput(<fluid:pyrotheum>*1000);
mythinfus89.addItemInput(<minecraft:glass_bottle>);
mythinfus89.addItemOutput(<contenttweaker:bottle_of_pyrotheum>);
mythinfus89.build();

val mythinfus90 = RecipeBuilder.newBuilder("mythinfus90","mythic_processor_infuser",2);
mythinfus90.addEnergyPerTickInput(1000000);
mythinfus90.addFluidInput(<fluid:petrotheum>*1000);
mythinfus90.addItemInput(<minecraft:glass_bottle>);
mythinfus90.addItemOutput(<contenttweaker:bottle_of_petrotheum>);
mythinfus90.build();

val mythinfus91 = RecipeBuilder.newBuilder("mythinfus91","mythic_processor_infuser",2);
mythinfus91.addEnergyPerTickInput(1000000);
mythinfus91.addFluidInput(<fluid:magnesium>*12);
mythinfus91.addItemInput(<contenttweaker:uranium_honey_cluster>);
mythinfus91.addItemOutput(<contenttweaker:infused_uranium>*4);
mythinfus91.build();

val mythinfus92 = RecipeBuilder.newBuilder("mythinfus92","mythic_processor_infuser",2);
mythinfus92.addEnergyPerTickInput(1000000);
mythinfus92.addFluidInput(<fluid:magnesium>*12);
mythinfus92.addItemInput(<contenttweaker:thorium_honey_cluster>);
mythinfus92.addItemOutput(<contenttweaker:infused_thorium>*4);
mythinfus92.build();

val mythinfus93 = RecipeBuilder.newBuilder("mythinfus93","mythic_processor_infuser",2);
mythinfus93.addEnergyPerTickInput(1000000);
mythinfus93.addFluidInput(<fluid:seared_grave_stone>*1000);
mythinfus93.addItemInput(<contenttweaker:uranium_honey_cluster>*4);
mythinfus93.addItemOutput(<nuclearcraft:ore:4>*4);
mythinfus93.build();

val mythinfus94 = RecipeBuilder.newBuilder("mythinfus94","mythic_processor_infuser",2);
mythinfus94.addEnergyPerTickInput(1000000);
mythinfus94.addFluidInput(<fluid:seared_grave_stone>*1000);
mythinfus94.addItemInput(<contenttweaker:thorium_honey_cluster>*4);
mythinfus94.addItemOutput(<nuclearcraft:ore:3>*4);
mythinfus94.build();

val mythinfus95 = RecipeBuilder.newBuilder("mythinfus95","mythic_processor_infuser",2);
mythinfus95.addEnergyPerTickInput(1000000);
mythinfus95.addFluidInput(<fluid:titanium>*16384000);
mythinfus95.addItemInput(<bloodmagic:blood_tank:10>);
mythinfus95.addItemOutput(<bloodmagic:blood_tank:10>.withTag({Fluid: {FluidName: "titanium", Amount: 16384000}}));
mythinfus95.build();

val mythinfus96 = RecipeBuilder.newBuilder("mythinfus96","mythic_processor_infuser",2);
mythinfus96.addEnergyPerTickInput(1000000);
mythinfus96.addFluidInput(<fluid:platinum>*16384000);
mythinfus96.addItemInput(<bloodmagic:blood_tank:10>);
mythinfus96.addItemOutput(<bloodmagic:blood_tank:10>.withTag({Fluid: {FluidName: "platinum", Amount: 16384000}}));
mythinfus96.build();

val mythinfus97 = RecipeBuilder.newBuilder("mythinfus97","mythic_processor_infuser",2);
mythinfus97.addEnergyPerTickInput(1000000);
mythinfus97.addFluidInput(<fluid:tungsten>*16384000);
mythinfus97.addItemInput(<bloodmagic:blood_tank:10>);
mythinfus97.addItemOutput(<bloodmagic:blood_tank:10>.withTag({Fluid: {FluidName: "tungsten", Amount: 16384000}}));
mythinfus97.build();

val mythinfus98 = RecipeBuilder.newBuilder("mythinfus98","mythic_processor_infuser",2);
mythinfus98.addEnergyPerTickInput(1000000);
mythinfus98.addFluidInput(<fluid:iridium>*16384000);
mythinfus98.addItemInput(<bloodmagic:blood_tank:10>);
mythinfus98.addItemOutput(<bloodmagic:blood_tank:10>.withTag({Fluid: {FluidName: "iridium", Amount: 16384000}}));
mythinfus98.build();

val mythinfus99 = RecipeBuilder.newBuilder("mythinfus99","mythic_processor_infuser",2);
mythinfus99.addEnergyPerTickInput(1000000);
mythinfus99.addFluidInput(<fluid:uranium>*16384000);
mythinfus99.addItemInput(<bloodmagic:blood_tank:10>);
mythinfus99.addItemOutput(<bloodmagic:blood_tank:10>.withTag({Fluid: {FluidName: "uranium", Amount: 16384000}}));
mythinfus99.build();

val mythinfus100 = RecipeBuilder.newBuilder("mythinfus100","mythic_processor_infuser",2);
mythinfus100.addEnergyPerTickInput(1000000);
mythinfus100.addFluidInput(<fluid:thorium>*16384000);
mythinfus100.addItemInput(<bloodmagic:blood_tank:10>);
mythinfus100.addItemOutput(<bloodmagic:blood_tank:10>.withTag({Fluid: {FluidName: "thorium", Amount: 16384000}}));
mythinfus100.build();

val mythinfus101 = RecipeBuilder.newBuilder("mythinfus101","mythic_processor_infuser",2);
mythinfus101.addEnergyPerTickInput(1000000);
mythinfus101.addFluidInput(<fluid:inquiring_protodermis>*1000);
mythinfus101.addItemInput(<minecraft:bucket>);
mythinfus101.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "inquiring_protodermis", Amount: 1000}));
mythinfus101.build();

val mythinfus102 = RecipeBuilder.newBuilder("mythinfus102","mythic_processor_infuser",2);
mythinfus102.addEnergyPerTickInput(1000000);
mythinfus102.addFluidInput(<fluid:actualization_hope>*1000);
mythinfus102.addItemInput(<minecraft:bucket>);
mythinfus102.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "actualization_hope", Amount: 1000}));
mythinfus102.build();

val mythinfus103 = RecipeBuilder.newBuilder("mythinfus103","mythic_processor_infuser",2);
mythinfus103.addEnergyPerTickInput(1000000);
mythinfus103.addFluidInput(<fluid:thaumium>*65336000);
mythinfus103.addItemInput(<bloodmagic:blood_tank:12>);
mythinfus103.addItemOutput(<bloodmagic:blood_tank:12>.withTag({Fluid: {FluidName: "thaumium", Amount: 65336000}}));
mythinfus103.build();

val mythinfus104 = RecipeBuilder.newBuilder("mythinfus104","mythic_processor_infuser",2);
mythinfus104.addEnergyPerTickInput(1000000);
mythinfus104.addFluidInput(<fluid:void_given_focus>*1000);
mythinfus104.addItemInput(<minecraft:bucket>);
mythinfus104.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "void_given_focus", Amount: 1000}));
mythinfus104.build();

val mythinfus105 = RecipeBuilder.newBuilder("mythinfus105","mythic_processor_infuser",2);
mythinfus105.addEnergyPerTickInput(1000000);
mythinfus105.addFluidInput(<fluid:vital_lymph>*1000);
mythinfus105.addItemInput(<minecraft:bucket>);
mythinfus105.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "vital_lymph", Amount: 1000}));
mythinfus105.build();

val mythinfus106 = RecipeBuilder.newBuilder("mythinfus106","mythic_processor_infuser",2);
mythinfus106.addEnergyPerTickInput(1000000);
mythinfus106.addFluidInput(<fluid:low_grade_space_time_fuel>*50);
mythinfus106.addItemInput(<contenttweaker:quasar_charged_dust>*160);
mythinfus106.addItemOutput(<contenttweaker:solid_low_grade_space_time_fuel>*10);
mythinfus106.build();

val mythinfus107 = RecipeBuilder.newBuilder("mythinfus107","mythic_processor_infuser",2);
mythinfus107.addEnergyPerTickInput(1000000);
mythinfus107.addFluidInput(<fluid:medium_grade_space_time_fuel>*50);
mythinfus107.addItemInput(<contenttweaker:quasar_charged_dust>*320);
mythinfus107.addItemOutput(<contenttweaker:solid_medium_grade_space_time_fuel>*10);
mythinfus107.build();

val mythinfus108 = RecipeBuilder.newBuilder("mythinfus108","mythic_processor_infuser",2);
mythinfus108.addEnergyPerTickInput(1000000);
mythinfus108.addFluidInput(<fluid:high_grade_space_time_fuel>*50);
mythinfus108.addItemInput(<contenttweaker:quasar_charged_dust>*640);
mythinfus108.addItemOutput(<contenttweaker:solid_high_grade_space_time_fuel>*10);
mythinfus108.build();

val mythinfus109 = RecipeBuilder.newBuilder("mythinfus109","mythic_processor_infuser",2);
mythinfus109.addEnergyPerTickInput(1000000);
mythinfus109.addFluidInput(<fluid:fluidglyceryl>*1000);
mythinfus109.addItemInput(<techreborn:dynamiccell>*1);
mythinfus109.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "fluidglyceryl", Amount: 1000}}));
mythinfus109.build();

val mythinfus110 = RecipeBuilder.newBuilder("mythinfus110","mythic_processor_infuser",2);
mythinfus110.addEnergyPerTickInput(1000000);
mythinfus110.addFluidInput(<fluid:whispering_starlight>*10000);
mythinfus110.addItemInput(<contenttweaker:possessed_sky_stone>*10);
mythinfus110.addItemOutput(<contenttweaker:possessed_sky_stone>*40);
mythinfus110.build();


val mythinfus111 = RecipeBuilder.newBuilder("mythinfus111","mythic_processor_infuser",2);
mythinfus111.addEnergyPerTickInput(1000000);
mythinfus111.addFluidInput(<fluid:beryllium>*1000);
mythinfus111.addItemInput(<techreborn:dynamiccell>*1);
mythinfus111.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "beryllium", Amount: 1000}}));
mythinfus111.build();

val mythinfus112 = RecipeBuilder.newBuilder("mythinfus112","mythic_processor_infuser",2);
mythinfus112.addEnergyPerTickInput(1000000);
mythinfus112.addFluidInput(<fluid:boron>*1000);
mythinfus112.addItemInput(<techreborn:dynamiccell>*1);
mythinfus112.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "boron", Amount: 1000}}));
mythinfus112.build();

val mythinfus113 = RecipeBuilder.newBuilder("mythinfus113","mythic_processor_infuser",2);
mythinfus113.addEnergyPerTickInput(1000000);
mythinfus113.addFluidInput(<fluid:lithium>*1000);
mythinfus113.addItemInput(<techreborn:dynamiccell>*1);
mythinfus113.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "lithium", Amount: 1000}}));
mythinfus113.build();

val mythinfus114 = RecipeBuilder.newBuilder("mythinfus114","mythic_processor_infuser",2);
mythinfus114.addEnergyPerTickInput(1000000);
mythinfus114.addFluidInput(<fluid:sednanite>*1000);
mythinfus114.addItemInput(<techreborn:dynamiccell>*1);
mythinfus114.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "sednanite", Amount: 1000}}));
mythinfus114.build();

val mythinfus115 = RecipeBuilder.newBuilder("mythinfus115","mythic_processor_infuser",2);
mythinfus115.addEnergyPerTickInput(1000000);
mythinfus115.addFluidInput(<fluid:mildly_recursive_goo>*1000);
mythinfus115.addItemInput(<techreborn:dynamiccell>*1);
mythinfus115.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "mildly_recursive_goo", Amount: 1000}}));
mythinfus115.build();

val mythinfus116 = RecipeBuilder.newBuilder("mythinfus116","mythic_processor_infuser",2);
mythinfus116.addEnergyPerTickInput(1000000);
mythinfus116.addFluidInput(<fluid:supercooled_noble_gas_mix>*1000);
mythinfus116.addItemInput(<techreborn:dynamiccell>*1);
mythinfus116.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "supercooled_noble_gas_mix", Amount: 1000}}));
mythinfus116.build();

val mythinfus117 = RecipeBuilder.newBuilder("mythinfus117","mythic_processor_infuser",2);
mythinfus117.addEnergyPerTickInput(1000000);
mythinfus117.addFluidInput(<fluid:einstenium>*1000);
mythinfus117.addItemInput(<techreborn:dynamiccell>*1);
mythinfus117.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "einstenium", Amount: 1000}}));
mythinfus117.build();

val mythinfus118 = RecipeBuilder.newBuilder("mythinfus118","mythic_processor_infuser",2);
mythinfus118.addEnergyPerTickInput(1000000);
mythinfus118.addFluidInput(<fluid:primal_ogerite>*1000);
mythinfus118.addItemInput(<techreborn:dynamiccell>*1);
mythinfus118.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "primal_ogerite", Amount: 1000}}));
mythinfus118.build();


val mythinfus119 = RecipeBuilder.newBuilder("mythinfus119","mythic_processor_infuser",2);
mythinfus119.addEnergyPerTickInput(1000000);
mythinfus119.addFluidInput(<fluid:hellfire>*1000);
mythinfus119.addItemInput(<minecraft:glass_bottle>*1);
mythinfus119.addItemOutput(<bewitchment:bottled_hellfire>);
mythinfus119.build();

val mythinfus120 = RecipeBuilder.newBuilder("mythinfus120","mythic_processor_infuser",2);
mythinfus120.addEnergyPerTickInput(1000000);
mythinfus120.addFluidInput(<fluid:spruce_heart>*1000);
mythinfus120.addItemInput(<bewitchment:empty_jar>*1);
mythinfus120.addItemOutput(<bewitchment:spruce_heart>);
mythinfus120.build();

val mythinfus121 = RecipeBuilder.newBuilder("mythinfus121","mythic_processor_infuser",2);
mythinfus121.addEnergyPerTickInput(1000000);
mythinfus121.addFluidInput(<fluid:cloudy_oil>*1000);
mythinfus121.addItemInput(<bewitchment:empty_jar>*1);
mythinfus121.addItemOutput(<bewitchment:cloudy_oil>);
mythinfus121.build();

val mythinfus122 = RecipeBuilder.newBuilder("mythinfus122","mythic_processor_infuser",2);
mythinfus122.addEnergyPerTickInput(1000000);
mythinfus122.addFluidInput(<fluid:acacia_resin>*1000);
mythinfus122.addItemInput(<bewitchment:empty_jar>*1);
mythinfus122.addItemOutput(<bewitchment:acacia_resin>);
mythinfus122.build();

val mythinfus123 = RecipeBuilder.newBuilder("mythinfus123","mythic_processor_infuser",2);
mythinfus123.addEnergyPerTickInput(1000000);
mythinfus123.addFluidInput(<fluid:ebb_of_death>*1000);
mythinfus123.addItemInput(<bewitchment:empty_jar>*1);
mythinfus123.addItemOutput(<bewitchment:ebb_of_death>);
mythinfus123.build();

val mythinfus124 = RecipeBuilder.newBuilder("mythinfus124","mythic_processor_infuser",2);
mythinfus124.addEnergyPerTickInput(1000000);
mythinfus124.addFluidInput(<fluid:droplet_of_wisdom>*1000);
mythinfus124.addItemInput(<bewitchment:empty_jar>*1);
mythinfus124.addItemOutput(<bewitchment:droplet_of_wisdom>);
mythinfus124.build();

val mythinfus125 = RecipeBuilder.newBuilder("mythinfus125","mythic_processor_infuser",2);
mythinfus125.addEnergyPerTickInput(1000000);
mythinfus125.addFluidInput(<fluid:liquid_witchcraft>*1000);
mythinfus125.addItemInput(<bewitchment:empty_jar>*1);
mythinfus125.addItemOutput(<bewitchment:liquid_witchcraft>);
mythinfus125.build();

val mythinfus126 = RecipeBuilder.newBuilder("mythinfus126","mythic_processor_infuser",2);
mythinfus126.addEnergyPerTickInput(1000000);
mythinfus126.addFluidInput(<fluid:essence_of_vitality>*1000);
mythinfus126.addItemInput(<bewitchment:empty_jar>*1);
mythinfus126.addItemOutput(<bewitchment:essence_of_vitality>);
mythinfus126.build();

val mythinfus127 = RecipeBuilder.newBuilder("mythinfus127","mythic_processor_infuser",2);
mythinfus127.addEnergyPerTickInput(1000000);
mythinfus127.addFluidInput(<fluid:cleansing_balm>*1000);
mythinfus127.addItemInput(<bewitchment:empty_jar>*1);
mythinfus127.addItemOutput(<bewitchment:cleansing_balm>);
mythinfus127.build();

val mythinfus128 = RecipeBuilder.newBuilder("mythinfus128","mythic_processor_infuser",2);
mythinfus128.addEnergyPerTickInput(1000000);
mythinfus128.addFluidInput(<fluid:demonic_elixir>*1000);
mythinfus128.addItemInput(<bewitchment:empty_jar>*1);
mythinfus128.addItemOutput(<bewitchment:demonic_elixir>);
mythinfus128.build();

val mythinfus129 = RecipeBuilder.newBuilder("mythinfus129","mythic_processor_infuser",2);
mythinfus129.addEnergyPerTickInput(1000000);
mythinfus129.addFluidInput(<fluid:fiery_unguent>*1000);
mythinfus129.addItemInput(<bewitchment:empty_jar>*1);
mythinfus129.addItemOutput(<bewitchment:fiery_unguent>);
mythinfus129.build();

val mythinfus130 = RecipeBuilder.newBuilder("mythinfus130","mythic_processor_infuser",2);
mythinfus130.addEnergyPerTickInput(1000000);
mythinfus130.addFluidInput(<fluid:swirl_of_depths>*1000);
mythinfus130.addItemInput(<bewitchment:empty_jar>*1);
mythinfus130.addItemOutput(<bewitchment:swirl_of_depths>);
mythinfus130.build();

val mythinfus131 = RecipeBuilder.newBuilder("mythinfus131","mythic_processor_infuser",2);
mythinfus131.addEnergyPerTickInput(1000000);
mythinfus131.addFluidInput(<fluid:oil_of_vitriol>*1000);
mythinfus131.addItemInput(<bewitchment:empty_jar>*1);
mythinfus131.addItemOutput(<bewitchment:oil_of_vitriol>);
mythinfus131.build();

val mythinfus132 = RecipeBuilder.newBuilder("mythinfus132","mythic_processor_infuser",2);
mythinfus132.addEnergyPerTickInput(1000000);
mythinfus132.addFluidInput(<fluid:otherworldly_tears>*1000);
mythinfus132.addItemInput(<bewitchment:empty_jar>*1);
mythinfus132.addItemOutput(<bewitchment:otherworldly_tears>);
mythinfus132.build();

val mythinfus133 = RecipeBuilder.newBuilder("mythinfus133","mythic_processor_infuser",2);
mythinfus133.addEnergyPerTickInput(1000000);
mythinfus133.addFluidInput(<fluid:heaven_extract>*1000);
mythinfus133.addItemInput(<bewitchment:empty_jar>*1);
mythinfus133.addItemOutput(<bewitchment:heaven_extract>);
mythinfus133.build();

val mythinfus134 = RecipeBuilder.newBuilder("mythinfus134","mythic_processor_infuser",2);
mythinfus134.addEnergyPerTickInput(1000000);
mythinfus134.addFluidInput(<fluid:stone_ichor>*1000);
mythinfus134.addItemInput(<bewitchment:empty_jar>*1);
mythinfus134.addItemOutput(<bewitchment:stone_ichor>);
mythinfus134.build();

val mythinfus135 = RecipeBuilder.newBuilder("mythinfus135","mythic_processor_infuser",2);
mythinfus135.addEnergyPerTickInput(1000000);
mythinfus135.addFluidInput(<fluid:birch_soul>*1000);
mythinfus135.addItemInput(<bewitchment:empty_jar>*1);
mythinfus135.addItemOutput(<bewitchment:birch_soul>);
mythinfus135.build();


val mythinfus136 = RecipeBuilder.newBuilder("mythinfus136","mythic_processor_infuser",2);
mythinfus136.addEnergyPerTickInput(1000000);
mythinfus136.addFluidInput(<fluid:cloudy_oil>*1000);
mythinfus136.addItemInput(<minecraft:glass_bottle>*1);
mythinfus136.addItemOutput(<contenttweaker:cloudy_oil_bottle>);
mythinfus136.build();

val mythinfus137 = RecipeBuilder.newBuilder("mythinfus137","mythic_processor_infuser",2);
mythinfus137.addEnergyPerTickInput(1000000);
mythinfus137.addFluidInput(<fluid:acacia_resin>*1000);
mythinfus137.addItemInput(<minecraft:glass_bottle>*1);
mythinfus137.addItemOutput(<contenttweaker:acacia_resin_bottle>);
mythinfus137.build();

val mythinfus138 = RecipeBuilder.newBuilder("mythinfus138","mythic_processor_infuser",2);
mythinfus138.addEnergyPerTickInput(1000000);
mythinfus138.addFluidInput(<fluid:liquid_witchcraft>*1000);
mythinfus138.addItemInput(<minecraft:glass_bottle>*1);
mythinfus138.addItemOutput(<contenttweaker:liquid_witchcraft_bottle>);
mythinfus138.build();

val mythinfus139 = RecipeBuilder.newBuilder("mythinfus139","mythic_processor_infuser",2);
mythinfus139.addEnergyPerTickInput(1000000);
mythinfus139.addFluidInput(<fluid:cleansing_balm>*1000);
mythinfus139.addItemInput(<minecraft:glass_bottle>*1);
mythinfus139.addItemOutput(<contenttweaker:cleansing_balm_bottle>);
mythinfus139.build();

val mythinfus140 = RecipeBuilder.newBuilder("mythinfus140","mythic_processor_infuser",2);
mythinfus140.addEnergyPerTickInput(1000000);
mythinfus140.addFluidInput(<fluid:demonic_elixir>*1000);
mythinfus140.addItemInput(<minecraft:glass_bottle>*1);
mythinfus140.addItemOutput(<contenttweaker:demonic_elixir_bottle>);
mythinfus140.build();

val mythinfus141 = RecipeBuilder.newBuilder("mythinfus141","mythic_processor_infuser",2);
mythinfus141.addEnergyPerTickInput(1000000);
mythinfus141.addFluidInput(<fluid:fiery_unguent>*1000);
mythinfus141.addItemInput(<minecraft:glass_bottle>*1);
mythinfus141.addItemOutput(<contenttweaker:fiery_unguent_bottle>);
mythinfus141.build();

val mythinfus142 = RecipeBuilder.newBuilder("mythinfus142","mythic_processor_infuser",2);
mythinfus142.addEnergyPerTickInput(1000000);
mythinfus142.addFluidInput(<fluid:swirl_of_depths>*1000);
mythinfus142.addItemInput(<minecraft:glass_bottle>*1);
mythinfus142.addItemOutput(<contenttweaker:swirl_depths_bottle>);
mythinfus142.build();

val mythinfus143 = RecipeBuilder.newBuilder("mythinfus143","mythic_processor_infuser",2);
mythinfus143.addEnergyPerTickInput(1000000);
mythinfus143.addFluidInput(<fluid:otherworldly_tears>*1000);
mythinfus143.addItemInput(<minecraft:glass_bottle>*1);
mythinfus143.addItemOutput(<contenttweaker:otherwordly_tears_bottle>);
mythinfus143.build();

val mythinfus144 = RecipeBuilder.newBuilder("mythinfus144","mythic_processor_infuser",2);
mythinfus144.addEnergyPerTickInput(1000000);
mythinfus144.addFluidInput(<fluid:heaven_extract>*1000);
mythinfus144.addItemInput(<minecraft:glass_bottle>*1);
mythinfus144.addItemOutput(<contenttweaker:heaven_extract_bottle>);
mythinfus144.build();

val mythinfus145 = RecipeBuilder.newBuilder("mythinfus145","mythic_processor_infuser",2);
mythinfus145.addEnergyPerTickInput(1000000);
mythinfus145.addFluidInput(<fluid:stone_ichor>*1000);
mythinfus145.addItemInput(<minecraft:glass_bottle>*1);
mythinfus145.addItemOutput(<contenttweaker:stone_ichor_bottle>);
mythinfus145.build();

val mythinfus146 = RecipeBuilder.newBuilder("mythinfus146","mythic_processor_infuser",2);
mythinfus146.addEnergyPerTickInput(1000000);
mythinfus146.addFluidInput(<fluid:tear_of_nature>*1000);
mythinfus146.addItemInput(<minecraft:glass_bottle>*1);
mythinfus146.addItemOutput(<contenttweaker:tear_of_nature_bottle>);
mythinfus146.build();

val mythinfus147 = RecipeBuilder.newBuilder("mythinfus147","mythic_processor_infuser",2);
mythinfus147.addEnergyPerTickInput(1000000);
mythinfus147.addFluidInput(<fluid:distillate_of_levity>*16000);
mythinfus147.addItemInput(<openblocks:tank>);
mythinfus147.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "distillate_of_levity", Amount: 16000}}));
mythinfus147.build();

val mythinfus148 = RecipeBuilder.newBuilder("mythinfus148","mythic_processor_infuser",2);
mythinfus148.addEnergyPerTickInput(1000000);
mythinfus148.addFluidInput(<fluid:aerotheum>*1000);
mythinfus148.addItemInput(<techreborn:dynamiccell>*1);
mythinfus148.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "aerotheum", Amount: 1000}}));
mythinfus148.build();

val mythinfus149 = RecipeBuilder.newBuilder("mythinfus149","mythic_processor_infuser",2);
mythinfus149.addEnergyPerTickInput(1000000);
mythinfus149.addFluidInput(<fluid:ebb_of_death>*1000);
mythinfus149.addItemInput(<minecraft:glass_bottle>*1);
mythinfus149.addItemOutput(<contenttweaker:ebb_of_death_bottle>);
mythinfus149.build();

val mythinfus150 = RecipeBuilder.newBuilder("mythinfus150","mythic_processor_infuser",2);
mythinfus150.addEnergyPerTickInput(1000000);
mythinfus150.addFluidInput(<fluid:droplet_of_wisdom>*1000);
mythinfus150.addItemInput(<minecraft:glass_bottle>*1);
mythinfus150.addItemOutput(<contenttweaker:droplet_of_wisdom_bottle>);
mythinfus150.build();

val mythinfus151 = RecipeBuilder.newBuilder("mythinfus151","mythic_processor_infuser",2);
mythinfus151.addEnergyPerTickInput(1000000);
mythinfus151.addFluidInput(<fluid:essence_of_vitality>*1000);
mythinfus151.addItemInput(<minecraft:glass_bottle>*1);
mythinfus151.addItemOutput(<contenttweaker:essence_of_vitality_bottle>);
mythinfus151.build();

val mythinfus152 = RecipeBuilder.newBuilder("mythinfus152","mythic_processor_infuser",2);
mythinfus152.addEnergyPerTickInput(1000000);
mythinfus152.addFluidInput(<fluid:oak_spirit>*1000);
mythinfus152.addItemInput(<minecraft:glass_bottle>*1);
mythinfus152.addItemOutput(<contenttweaker:oak_spirit_bottle>);
mythinfus152.build();

val mythinfus153 = RecipeBuilder.newBuilder("mythinfus153","mythic_processor_infuser",2);
mythinfus153.addEnergyPerTickInput(1000000);
mythinfus153.addFluidInput(<fluid:spruce_heart>*1000);
mythinfus153.addItemInput(<minecraft:glass_bottle>*1);
mythinfus153.addItemOutput(<contenttweaker:spruce_heart_bottle>);
mythinfus153.build();

val mythinfus154 = RecipeBuilder.newBuilder("mythinfus154","mythic_processor_infuser",2);
mythinfus154.addEnergyPerTickInput(1000000);
mythinfus154.addFluidInput(<fluid:oil_of_vitriol>*1000);
mythinfus154.addItemInput(<minecraft:glass_bottle>*1);
mythinfus154.addItemOutput(<contenttweaker:oil_of_vitriol_bottle>);
mythinfus154.build();

val mythinfus155 = RecipeBuilder.newBuilder("mythinfus155","mythic_processor_infuser",2);
mythinfus155.addEnergyPerTickInput(1000000);
mythinfus155.addFluidInput(<fluid:birch_soul>*1000);
mythinfus155.addItemInput(<minecraft:glass_bottle>*1);
mythinfus155.addItemOutput(<contenttweaker:birch_soul_bottle>);
mythinfus155.build();

val mythinfus156 = RecipeBuilder.newBuilder("mythinfus156","mythic_processor_infuser",2);
mythinfus156.addEnergyPerTickInput(1000000);
mythinfus156.addFluidInput(<fluid:dimensional_essence>*1000);
mythinfus156.addItemInput(<aoa3:ghastly_ingot>*10);
mythinfus156.addItemOutput(<contenttweaker:nethersky_steel_ingot>*50);
mythinfus156.build();

val mythinfus157 = RecipeBuilder.newBuilder("mythinfus157","mythic_processor_infuser",2);
mythinfus157.addEnergyPerTickInput(1000000);
mythinfus157.addFluidInput(<fluid:dimensional_essence>*1000);
mythinfus157.addItemInput(<aoa3:ghoulish_ingot>*10);
mythinfus157.addItemOutput(<contenttweaker:nethersky_steel_ingot>*50);
mythinfus157.build();

val mythinfus158 = RecipeBuilder.newBuilder("mythinfus158","mythic_processor_infuser",2);
mythinfus158.addEnergyPerTickInput(1000000);
mythinfus158.addFluidInput(<fluid:dimensional_essence>*1000);
mythinfus158.addItemInput(<aoa3:shyrestone_ingot>*10);
mythinfus158.addItemOutput(<contenttweaker:nethersky_steel_ingot>*60);
mythinfus158.build();

val mythinfus159 = RecipeBuilder.newBuilder("mythinfus159","mythic_processor_infuser",2);
mythinfus159.addEnergyPerTickInput(1000000);
mythinfus159.addFluidInput(<fluid:fluidhelium>*1000);
mythinfus159.addItemInput(<techreborn:dynamiccell>*1);
mythinfus159.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "fluidhelium", Amount: 1000}}));
mythinfus159.build();

val mythinfus160 = RecipeBuilder.newBuilder("mythinfus160","mythic_processor_infuser",2);
mythinfus160.addEnergyPerTickInput(1000000);
mythinfus160.addFluidInput(<fluid:helium>*1000);
mythinfus160.addItemInput(<techreborn:dynamiccell>*1);
mythinfus160.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "helium", Amount: 1000}}));
mythinfus160.build();

val mythinfus161 = RecipeBuilder.newBuilder("mythinfus161","mythic_processor_infuser",2);
mythinfus161.addEnergyPerTickInput(1000000);
mythinfus161.addFluidInput(<fluid:fluidpotassium>*1000);
mythinfus161.addItemInput(<techreborn:dynamiccell>*1);
mythinfus161.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "fluidpotassium", Amount: 1000}}));
mythinfus161.build();

val mythinfus162 = RecipeBuilder.newBuilder("mythinfus162","mythic_processor_infuser",2);
mythinfus162.addEnergyPerTickInput(1000000);
mythinfus162.addFluidInput(<fluid:potassium>*1000);
mythinfus162.addItemInput(<techreborn:dynamiccell>*1);
mythinfus162.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "potassium", Amount: 1000}}));
mythinfus162.build();

val mythinfus163 = RecipeBuilder.newBuilder("mythinfus163","mythic_processor_infuser",2);
mythinfus163.addEnergyPerTickInput(1000000);
mythinfus163.addFluidInput(<fluid:fluidsodium>*1000);
mythinfus163.addItemInput(<techreborn:dynamiccell>*1);
mythinfus163.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "fluidsodium", Amount: 1000}}));
mythinfus163.build();

val mythinfus164 = RecipeBuilder.newBuilder("mythinfus164","mythic_processor_infuser",2);
mythinfus164.addEnergyPerTickInput(1000000);
mythinfus164.addFluidInput(<fluid:sodium>*1000);
mythinfus164.addItemInput(<techreborn:dynamiccell>*1);
mythinfus164.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "sodium", Amount: 1000}}));
mythinfus164.build();

val mythinfus165 = RecipeBuilder.newBuilder("mythinfus165","mythic_processor_infuser",2);
mythinfus165.addEnergyPerTickInput(1000000);
mythinfus165.addFluidInput(<fluid:water>*1000);
mythinfus165.addItemInput(<techreborn:dynamiccell>*1);
mythinfus165.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "water", Amount: 1000}}));
mythinfus165.build();

val mythinfus166 = RecipeBuilder.newBuilder("mythinfus166","mythic_processor_infuser",2);
mythinfus166.addEnergyPerTickInput(1000000);
mythinfus166.addFluidInput(<fluid:cyanite>*10368);
mythinfus166.addItemInput(<techreborn:part:12>*1);
mythinfus166.addItemOutput(<contenttweaker:cyanite_cell>);
mythinfus166.build();

val mythinfus167 = RecipeBuilder.newBuilder("mythinfus167","mythic_processor_infuser",2);
mythinfus167.addEnergyPerTickInput(1000000);
mythinfus167.addFluidInput(<fluid:galactic_plasma>*4000);
mythinfus167.addItemInput(<mysticalagradditions:neutronium_essence>*16);
mythinfus167.addItemOutput(<contenttweaker:dense_neutronium_essence>*16);
mythinfus167.build();


val mythinfus168 = RecipeBuilder.newBuilder("mythinfus168","mythic_processor_infuser",2);
mythinfus168.addEnergyPerTickInput(1000000);
mythinfus168.addFluidInput(<fluid:blood_great_snake>*100);
mythinfus168.addItemInput(<aoa3:bloodstone_block>*4);
mythinfus168.addItemOutput(<contenttweaker:bloodstone_of_the_great_snake>*4);
mythinfus168.build();

val mythinfus169 = RecipeBuilder.newBuilder("mythinfus169","mythic_processor_infuser",2);
mythinfus169.addEnergyPerTickInput(1000000);
mythinfus169.addFluidInput(<fluid:harmonic_fluid_lattice>*1000);
mythinfus169.addItemInput(<techreborn:dynamiccell>*1);
mythinfus169.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "harmonic_fluid_lattice", Amount: 1000}}));
mythinfus169.build();

val mythinfus170 = RecipeBuilder.newBuilder("mythinfus170","mythic_processor_infuser",2);
mythinfus170.addEnergyPerTickInput(1000000);
mythinfus170.addFluidInput(<fluid:koh>*1000);
mythinfus170.addItemInput(<techreborn:dynamiccell>*1);
mythinfus170.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "koh", Amount: 1000}}));
mythinfus170.build();

val mythinfus171 = RecipeBuilder.newBuilder("mythinfus171","mythic_processor_infuser",2);
mythinfus171.addEnergyPerTickInput(1000000);
mythinfus171.addFluidInput(<fluid:essence_of_temporal_synthesis>*5);
mythinfus171.addItemInput(<contenttweaker:actualized_chunk>*128);
mythinfus171.addItemOutput(<contenttweaker:twilight_horde_historical_chunk>*128);
mythinfus171.build();

val mythinfus172 = RecipeBuilder.newBuilder("mythinfus172","mythic_processor_infuser",2);
mythinfus172.addEnergyPerTickInput(1000000);
mythinfus172.addFluidInput(<fluid:sideral_life_essence>*1000);
mythinfus172.addItemInput(<techreborn:dynamiccell>*1);
mythinfus172.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "sideral_life_essence", Amount: 1000}}));
mythinfus172.build();

val mythinfus173 = RecipeBuilder.newBuilder("mythinfus173","mythic_processor_infuser",2);
mythinfus173.addEnergyPerTickInput(1000000);
mythinfus173.addFluidInput(<fluid:fiery_peat>*1000);
mythinfus173.addItemInput(<forestry:bee_combs:15>*1);
mythinfus173.addItemOutput(<forestry:peat>*12);
mythinfus173.build();

val mythinfus174 = RecipeBuilder.newBuilder("mythinfus174","mythic_processor_infuser",2);
mythinfus174.addEnergyPerTickInput(1000000);
mythinfus174.addFluidInput(<fluid:fluidnitrodiesel>*16000);
mythinfus174.addItemInput(<openblocks:tank>);
mythinfus174.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "fluidnitrodiesel", Amount: 16000}}));
mythinfus174.build();

val mythinfus175 = RecipeBuilder.newBuilder("mythinfus175","mythic_processor_infuser",2);
mythinfus175.addEnergyPerTickInput(1000000);
mythinfus175.addFluidInput(<fluid:rutherfordium_chloride>*1000);
mythinfus175.addItemInput(<techreborn:dynamiccell>*1);
mythinfus175.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "rutherfordium_chloride", Amount: 1000}}));
mythinfus175.build();

val mythinfus176 = RecipeBuilder.newBuilder("mythinfus176","mythic_processor_infuser",2);
mythinfus176.addEnergyPerTickInput(1000000);
mythinfus176.addFluidInput(<fluid:depleted_fuel_leu_235>*1000);
mythinfus176.addItemInput(<techreborn:dynamiccell>*1);
mythinfus176.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "depleted_fuel_leu_235", Amount: 1000}}));
mythinfus176.build();

val mythinfus177 = RecipeBuilder.newBuilder("mythinfus177","mythic_processor_infuser",2);
mythinfus177.addEnergyPerTickInput(1000000);
mythinfus177.addFluidInput(<fluid:radioactive_ethereal_goo>*1000);
mythinfus177.addItemInput(<techreborn:dynamiccell>*1);
mythinfus177.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "radioactive_ethereal_goo", Amount: 1000}}));
mythinfus177.build();

val mythinfus178 = RecipeBuilder.newBuilder("mythinfus178","mythic_processor_infuser",2);
mythinfus178.addEnergyPerTickInput(1000000);
mythinfus178.addFluidInput(<fluid:liquidhelium_nak>*1000);
mythinfus178.addItemInput(<minecraft:bucket>);
mythinfus178.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "liquidhelium_nak", Amount: 1000}));
mythinfus178.build();

val mythinfus179 = RecipeBuilder.newBuilder("mythinfus179","mythic_processor_infuser",2);
mythinfus179.addEnergyPerTickInput(1000000);
mythinfus179.addFluidInput(<fluid:harmonic_fluid_lattice>*1000);
mythinfus179.addItemInput(<minecraft:bucket>);
mythinfus179.addItemOutput(<forge:bucketfilled>.withTag({FluidName: "harmonic_fluid_lattice", Amount: 1000}));
mythinfus179.build();

val mythinfus180 = RecipeBuilder.newBuilder("mythinfus180","mythic_processor_infuser",2);
mythinfus180.addEnergyPerTickInput(1000000);
mythinfus180.addFluidInput(<fluid:harmonic_fluid_lattice>*1000);
mythinfus180.addItemInput(<techreborn:dynamiccell>*1);
mythinfus180.addItemOutput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "harmonic_fluid_lattice", Amount: 1000}}));
mythinfus180.build();

val mythinfus181 = RecipeBuilder.newBuilder("mythinfus181","mythic_processor_infuser",2);
mythinfus181.addEnergyPerTickInput(1000000);
mythinfus181.addFluidInput(<fluid:harmonic_fluid_lattice>*16000);
mythinfus181.addItemInput(<openblocks:tank>*1);
mythinfus181.addItemOutput(<openblocks:tank>.withTag({tank: {FluidName: "harmonic_fluid_lattice", Amount: 16000}}));
mythinfus181.build();









val mythextrac1 = RecipeBuilder.newBuilder("mythextrac1","mythic_processor_infuser",2);
mythextrac1.addEnergyPerTickInput(1000000);
mythextrac1.addItemInput(<ore:turfMoon>*10);
mythextrac1.addItemOutput(<minecraft:gravel>*10);
mythextrac1.addFluidOutput(<fluid:helium3>*2500);
mythextrac1.build();

val mythextrac2 = RecipeBuilder.newBuilder("mythextrac2","mythic_processor_infuser",2);
mythextrac2.addEnergyPerTickInput(1000000);
mythextrac2.addItemInput(<contenttweaker:krypton_xenon_capture>*10);
mythextrac2.addItemOutput(<contenttweaker:krypton_capture>*10);
mythextrac2.addFluidOutput(<fluid:xenon>*1000);
mythextrac2.build();

val mythextrac3 = RecipeBuilder.newBuilder("mythextrac3","mythic_processor_infuser",2);
mythextrac3.addEnergyPerTickInput(1000000);
mythextrac3.addItemInput(<contenttweaker:krypton_capture>*10);
mythextrac3.addItemOutput(<abyssalcraft:crystalshard:21>*10);
mythextrac3.addFluidOutput(<fluid:krypton>*1000);
mythextrac3.build();

val mythextrac4 = RecipeBuilder.newBuilder("mythextrac4","mythic_processor_infuser",2);
mythextrac4.addEnergyPerTickInput(1000000);
mythextrac4.addItemInput(<twilightforest:hydra_chop>*10);
mythextrac4.addItemOutput(<minecraft:rotten_flesh>*10);
mythextrac4.addFluidOutput(<fluid:hydra_juices>*1000);
mythextrac4.build();

val mythextrac5 = RecipeBuilder.newBuilder("mythextrac5","mythic_processor_infuser",2);
mythextrac5.addEnergyPerTickInput(1000000);
mythextrac5.addItemInput(<forestry:honey_drop:*>*10);
mythextrac5.addItemOutput(<forestry:propolis>*10);
mythextrac5.addFluidOutput(<fluid:for.honey>*2000);
mythextrac5.build();

val mythextrac6 = RecipeBuilder.newBuilder("mythextrac6","mythic_processor_infuser",2);
mythextrac6.addEnergyPerTickInput(1000000);
mythextrac6.addItemInput(<ore:fruitForestry>*10);
mythextrac6.addItemOutput(<forestry:mulch>*10);
mythextrac6.addFluidOutput(<fluid:juice>*4000);
mythextrac6.build();

val mythextrac7 = RecipeBuilder.newBuilder("mythextrac7","mythic_processor_infuser",2);
mythextrac7.addEnergyPerTickInput(1000000);
mythextrac7.addItemInput(<minecraft:carrot>*10);
mythextrac7.addItemOutput(<forestry:mulch>*10);
mythextrac7.addFluidOutput(<fluid:juice>*2000);
mythextrac7.build();



val mythextrac8 = RecipeBuilder.newBuilder("mythextrac8","mythic_processor_infuser",2);
mythextrac8.addEnergyPerTickInput(1000000);
mythextrac8.addItemInput(<ore:cropCoffee>*10);
mythextrac8.addItemOutput(<forestry:mulch>*10);
mythextrac8.addFluidOutput(<fluid:seed.oil>*200);
mythextrac8.build();

val mythextrac9 = RecipeBuilder.newBuilder("mythextrac9","mythic_processor_infuser",2);
mythextrac9.addEnergyPerTickInput(1000000);
mythextrac9.addItemInput(<ore:cropAlmond>*10);
mythextrac9.addItemOutput(<forestry:mulch>*10);
mythextrac9.addFluidOutput(<fluid:seed.oil>*800);
mythextrac9.build();

val mythextrac10 = RecipeBuilder.newBuilder("mythextrac10","mythic_processor_infuser",2);
mythextrac10.addEnergyPerTickInput(1000000);
mythextrac10.addItemInput(<ore:cropCherry>*10);
mythextrac10.addItemOutput(<forestry:mulch>*10);
mythextrac10.addFluidOutput(<fluid:seed.oil>*500);
mythextrac10.build();

val mythextrac11 = RecipeBuilder.newBuilder("mythextrac11","mythic_processor_infuser",2);
mythextrac11.addEnergyPerTickInput(1000000);
mythextrac11.addItemInput(<ore:cropChestnut>*10);
mythextrac11.addItemOutput(<forestry:mulch>*10);
mythextrac11.addFluidOutput(<fluid:seed.oil>*2200);
mythextrac11.build();

val mythextrac12 = RecipeBuilder.newBuilder("mythextrac12","mythic_processor_infuser",2);
mythextrac12.addEnergyPerTickInput(1000000);
mythextrac12.addItemInput(<ore:cropWalnut>*10);
mythextrac12.addItemOutput(<forestry:mulch>*10);
mythextrac12.addFluidOutput(<fluid:seed.oil>*1800);
mythextrac12.build();


val mythextrac13 = RecipeBuilder.newBuilder("mythextrac13","mythic_processor_infuser",2);
mythextrac13.addEnergyPerTickInput(1000000);
mythextrac13.addItemInput(<ore:cropOlive>*10);
mythextrac13.addItemOutput(<forestry:mulch>*10);
mythextrac13.addFluidOutput(<fluid:binnie.juice.olive>*500);
mythextrac13.build();

val mythextrac14 = RecipeBuilder.newBuilder("mythextrac14","mythic_processor_infuser",2);
mythextrac14.addEnergyPerTickInput(1000000);
mythextrac14.addItemInput(<aoa3:shyre_weed>*10);
mythextrac14.addItemOutput(<forestry:mulch>*10);
mythextrac14.addFluidOutput(<fluid:shyre_weed_oil>*250);
mythextrac14.build();

val mythextrac15 = RecipeBuilder.newBuilder("mythextrac15","mythic_processor_infuser",2);
mythextrac15.addEnergyPerTickInput(1000000);
mythextrac15.addItemInput(<forge:bucketfilled>.withTag({FluidName: "liquid_death", Amount: 1000}));
mythextrac15.addItemOutput(<minecraft:bucket>*1);
mythextrac15.addFluidOutput(<fluid:liquid_death>*1000);
mythextrac15.build();

val mythextrac16 = RecipeBuilder.newBuilder("mythextrac16","mythic_processor_infuser",2);
mythextrac16.addEnergyPerTickInput(1000000);
mythextrac16.addItemInput(<forge:bucketfilled>.withTag({FluidName: "eleint_dragonfire", Amount: 1000}));
mythextrac16.addItemOutput(<minecraft:bucket>*1);
mythextrac16.addFluidOutput(<fluid:eleint_dragonfire>*1000);
mythextrac16.build();

val mythextrac17 = RecipeBuilder.newBuilder("mythextrac17","mythic_processor_infuser",2);
mythextrac17.addEnergyPerTickInput(1000000);
mythextrac17.addItemInput(<forge:bucketfilled>.withTag({FluidName: "nidhogg_dragonfire", Amount: 1000}));
mythextrac17.addItemOutput(<minecraft:bucket>*1);
mythextrac17.addFluidOutput(<fluid:nidhogg_dragonfire>*1000);
mythextrac17.build();

val mythextrac18 = RecipeBuilder.newBuilder("mythextrac18","mythic_processor_infuser",2);
mythextrac18.addEnergyPerTickInput(1000000);
mythextrac18.addItemInput(<forge:bucketfilled>.withTag({FluidName: "gluttonous_lymph", Amount: 1000}));
mythextrac18.addItemOutput(<minecraft:bucket>*1);
mythextrac18.addFluidOutput(<fluid:gluttonous_lymph>*1000);
mythextrac18.build();

val mythextrac19 = RecipeBuilder.newBuilder("mythextrac19","mythic_processor_infuser",2);
mythextrac19.addEnergyPerTickInput(1000000);
mythextrac19.addItemInput(<forge:bucketfilled>.withTag({FluidName: "liquidantimatter", Amount: 1000}));
mythextrac19.addItemOutput(<minecraft:bucket>*1);
mythextrac19.addFluidOutput(<fluid:liquidantimatter>*1000);
mythextrac19.build();

val mythextrac20 = RecipeBuilder.newBuilder("mythextrac20","mythic_processor_infuser",2);
mythextrac20.addEnergyPerTickInput(1000000);
mythextrac20.addItemInput(<forge:bucketfilled>.withTag({FluidName: "essence_of_sane_thoughts", Amount: 1000}));
mythextrac20.addItemOutput(<minecraft:bucket>*1);
mythextrac20.addFluidOutput(<fluid:essence_of_sane_thoughts>*1000);
mythextrac20.build();

val mythextrac21 = RecipeBuilder.newBuilder("mythextrac21","mythic_processor_infuser",2);
mythextrac21.addEnergyPerTickInput(1000000);
mythextrac21.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "boron10", Amount: 1000}}));
mythextrac21.addItemOutput(<techreborn:dynamiccell>);
mythextrac21.addFluidOutput(<fluid:boron10>*1000);
mythextrac21.build();

val mythextrac22 = RecipeBuilder.newBuilder("mythextrac22","mythic_processor_infuser",2);
mythextrac22.addEnergyPerTickInput(1000000);
mythextrac22.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "boron11", Amount: 1000}}));
mythextrac22.addItemOutput(<techreborn:dynamiccell>);
mythextrac22.addFluidOutput(<fluid:boron11>*1000);
mythextrac22.build();

val mythextrac23 = RecipeBuilder.newBuilder("mythextrac23","mythic_processor_infuser",2);
mythextrac23.addEnergyPerTickInput(1000000);
mythextrac23.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "lithium7", Amount: 1000}}));
mythextrac23.addItemOutput(<techreborn:dynamiccell>);
mythextrac23.addFluidOutput(<fluid:lithium7>*1000);
mythextrac23.build();

val mythextrac24 = RecipeBuilder.newBuilder("mythextrac24","mythic_processor_infuser",2);
mythextrac24.addEnergyPerTickInput(1000000);
mythextrac24.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "lithium6", Amount: 1000}}));
mythextrac24.addItemOutput(<techreborn:dynamiccell>);
mythextrac24.addFluidOutput(<fluid:lithium6>*1000);
mythextrac24.build();

val mythextrac25 = RecipeBuilder.newBuilder("mythextrac25","mythic_processor_infuser",2);
mythextrac25.addEnergyPerTickInput(1000000);
mythextrac25.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "dimensional_essence", Amount: 1000}}));
mythextrac25.addItemOutput(<techreborn:dynamiccell>);
mythextrac25.addFluidOutput(<fluid:dimensional_essence>*1000);
mythextrac25.build();

val mythextrac26 = RecipeBuilder.newBuilder("mythextrac26","mythic_processor_infuser",2);
mythextrac26.addEnergyPerTickInput(1000000);
mythextrac26.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "nethengeic_fluid", Amount: 1000}}));
mythextrac26.addItemOutput(<techreborn:dynamiccell>);
mythextrac26.addFluidOutput(<fluid:nethengeic_fluid>*1000);
mythextrac26.build();

val mythextrac27 = RecipeBuilder.newBuilder("mythextrac27","mythic_processor_infuser",2);
mythextrac27.addEnergyPerTickInput(1000000);
mythextrac27.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "liquid_void", Amount: 1000}}));
mythextrac27.addItemOutput(<techreborn:dynamiccell>);
mythextrac27.addFluidOutput(<fluid:liquid_void>*1000);
mythextrac27.build();

val mythextrac28 = RecipeBuilder.newBuilder("mythextrac28","mythic_processor_infuser",2);
mythextrac28.addEnergyPerTickInput(1000000);
mythextrac28.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "overworldian_fluid", Amount: 1000}}));
mythextrac28.addItemOutput(<techreborn:dynamiccell>);
mythextrac28.addFluidOutput(<fluid:overworldian_fluid>*1000);
mythextrac28.build();

val mythextrac29 = RecipeBuilder.newBuilder("mythextrac29","mythic_processor_infuser",2);
mythextrac29.addEnergyPerTickInput(1000000);
mythextrac29.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "krypton_xenon_mix", Amount: 1000}}));
mythextrac29.addItemOutput(<techreborn:dynamiccell>);
mythextrac29.addFluidOutput(<fluid:krypton_xenon_mix>*1000);
mythextrac29.build();

val mythextrac30 = RecipeBuilder.newBuilder("mythextrac30","mythic_processor_infuser",2);
mythextrac30.addEnergyPerTickInput(1000000);
mythextrac30.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "neon", Amount: 1000}}));
mythextrac30.addItemOutput(<techreborn:dynamiccell>);
mythextrac30.addFluidOutput(<fluid:neon>*1000);
mythextrac30.build();

val mythextrac31 = RecipeBuilder.newBuilder("mythextrac31","mythic_processor_infuser",2);
mythextrac31.addEnergyPerTickInput(1000000);
mythextrac31.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "einstenium_253", Amount: 1000}}));
mythextrac31.addItemOutput(<techreborn:dynamiccell>);
mythextrac31.addFluidOutput(<fluid:einstenium_253>*1000);
mythextrac31.build();

val mythextrac32 = RecipeBuilder.newBuilder("mythextrac32","mythic_processor_infuser",2);
mythextrac32.addEnergyPerTickInput(1000000);
mythextrac32.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "einstenium_254", Amount: 1000}}));
mythextrac32.addItemOutput(<techreborn:dynamiccell>);
mythextrac32.addFluidOutput(<fluid:einstenium_254>*1000);
mythextrac32.build();

val mythextrac33 = RecipeBuilder.newBuilder("mythextrac33","mythic_processor_infuser",2);
mythextrac33.addEnergyPerTickInput(1000000);
mythextrac33.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "decay_inducing_matter", Amount: 1000}}));
mythextrac33.addItemOutput(<techreborn:dynamiccell>);
mythextrac33.addFluidOutput(<fluid:decay_inducing_matter>*1000);
mythextrac33.build();

val mythextrac34 = RecipeBuilder.newBuilder("mythextrac34","mythic_processor_infuser",2);
mythextrac34.addEnergyPerTickInput(1000000);
mythextrac34.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "energetic_ogerite", Amount: 1000}}));
mythextrac34.addItemOutput(<techreborn:dynamiccell>);
mythextrac34.addFluidOutput(<fluid:energetic_ogerite>*1000);
mythextrac34.build();


val mythextrac35 = RecipeBuilder.newBuilder("mythextrac35","mythic_processor_infuser",2);
mythextrac35.addEnergyPerTickInput(1000000);
mythextrac35.addItemInput(<bewitchment:oak_spirit>);
mythextrac35.addItemOutput(<bewitchment:empty_jar>);
mythextrac35.addFluidOutput(<fluid:oak_spirit>*1000);
mythextrac35.build();

val mythextrac36 = RecipeBuilder.newBuilder("mythextrac36","mythic_processor_infuser",2);
mythextrac36.addEnergyPerTickInput(1000000);
mythextrac36.addItemInput(<bewitchment:spruce_heart>);
mythextrac36.addItemOutput(<bewitchment:empty_jar>);
mythextrac36.addFluidOutput(<fluid:spruce_heart>*1000);
mythextrac36.build();

val mythextrac37 = RecipeBuilder.newBuilder("mythextrac37","mythic_processor_infuser",2);
mythextrac37.addEnergyPerTickInput(1000000);
mythextrac37.addItemInput(<bewitchment:cloudy_oil>);
mythextrac37.addItemOutput(<bewitchment:empty_jar>);
mythextrac37.addFluidOutput(<fluid:cloudy_oil>*1000);
mythextrac37.build();

val mythextrac38 = RecipeBuilder.newBuilder("mythextrac38","mythic_processor_infuser",2);
mythextrac38.addEnergyPerTickInput(1000000);
mythextrac38.addItemInput(<bewitchment:acacia_resin>);
mythextrac38.addItemOutput(<bewitchment:empty_jar>);
mythextrac38.addFluidOutput(<fluid:acacia_resin>*1000);
mythextrac38.build();

val mythextrac39 = RecipeBuilder.newBuilder("mythextrac39","mythic_processor_infuser",2);
mythextrac39.addEnergyPerTickInput(1000000);
mythextrac39.addItemInput(<bewitchment:liquid_witchcraft>);
mythextrac39.addItemOutput(<bewitchment:empty_jar>);
mythextrac39.addFluidOutput(<fluid:liquid_witchcraft>*1000);
mythextrac39.build();

val mythextrac40 = RecipeBuilder.newBuilder("mythextrac40","mythic_processor_infuser",2);
mythextrac40.addEnergyPerTickInput(1000000);
mythextrac40.addItemInput(<bewitchment:ebb_of_death>);
mythextrac40.addItemOutput(<bewitchment:empty_jar>);
mythextrac40.addFluidOutput(<fluid:ebb_of_death>*1000);
mythextrac40.build();

val mythextrac41 = RecipeBuilder.newBuilder("mythextrac41","mythic_processor_infuser",2);
mythextrac41.addEnergyPerTickInput(1000000);
mythextrac41.addItemInput(<bewitchment:droplet_of_wisdom>);
mythextrac41.addItemOutput(<bewitchment:empty_jar>);
mythextrac41.addFluidOutput(<fluid:droplet_of_wisdom>*1000);
mythextrac41.build();

val mythextrac42 = RecipeBuilder.newBuilder("mythextrac42","mythic_processor_infuser",2);
mythextrac42.addEnergyPerTickInput(1000000);
mythextrac42.addItemInput(<bewitchment:essence_of_vitality>);
mythextrac42.addItemOutput(<bewitchment:empty_jar>);
mythextrac42.addFluidOutput(<fluid:essence_of_vitality>*1000);
mythextrac42.build();

val mythextrac43 = RecipeBuilder.newBuilder("mythextrac43","mythic_processor_infuser",2);
mythextrac43.addEnergyPerTickInput(1000000);
mythextrac43.addItemInput(<bewitchment:cleansing_balm>);
mythextrac43.addItemOutput(<bewitchment:empty_jar>);
mythextrac43.addFluidOutput(<fluid:cleansing_balm>*1000);
mythextrac43.build();

val mythextrac44 = RecipeBuilder.newBuilder("mythextrac44","mythic_processor_infuser",2);
mythextrac44.addEnergyPerTickInput(1000000);
mythextrac44.addItemInput(<bewitchment:demonic_elixir>);
mythextrac44.addItemOutput(<bewitchment:empty_jar>);
mythextrac44.addFluidOutput(<fluid:demonic_elixir>*1000);
mythextrac44.build();

val mythextrac45 = RecipeBuilder.newBuilder("mythextrac45","mythic_processor_infuser",2);
mythextrac45.addEnergyPerTickInput(1000000);
mythextrac45.addItemInput(<bewitchment:fiery_unguent>);
mythextrac45.addItemOutput(<bewitchment:empty_jar>);
mythextrac45.addFluidOutput(<fluid:fiery_unguent>*1000);
mythextrac45.build();

val mythextrac46 = RecipeBuilder.newBuilder("mythextrac46","mythic_processor_infuser",2);
mythextrac46.addEnergyPerTickInput(1000000);
mythextrac46.addItemInput(<bewitchment:swirl_of_depths>);
mythextrac46.addItemOutput(<bewitchment:empty_jar>);
mythextrac46.addFluidOutput(<fluid:swirl_of_depths>*1000);
mythextrac46.build();

val mythextrac47 = RecipeBuilder.newBuilder("mythextrac47","mythic_processor_infuser",2);
mythextrac47.addEnergyPerTickInput(1000000);
mythextrac47.addItemInput(<bewitchment:oil_of_vitriol>);
mythextrac47.addItemOutput(<bewitchment:empty_jar>);
mythextrac47.addFluidOutput(<fluid:oil_of_vitriol>*1000);
mythextrac47.build();

val mythextrac48 = RecipeBuilder.newBuilder("mythextrac48","mythic_processor_infuser",2);
mythextrac48.addEnergyPerTickInput(1000000);
mythextrac48.addItemInput(<bewitchment:otherworldly_tears>);
mythextrac48.addItemOutput(<bewitchment:empty_jar>);
mythextrac48.addFluidOutput(<fluid:otherworldly_tears>*1000);
mythextrac48.build();

val mythextrac49 = RecipeBuilder.newBuilder("mythextrac49","mythic_processor_infuser",2);
mythextrac49.addEnergyPerTickInput(1000000);
mythextrac49.addItemInput(<bewitchment:heaven_extract>);
mythextrac49.addItemOutput(<bewitchment:empty_jar>);
mythextrac49.addFluidOutput(<fluid:heaven_extract>*1000);
mythextrac49.build();

val mythextrac50 = RecipeBuilder.newBuilder("mythextrac50","mythic_processor_infuser",2);
mythextrac50.addEnergyPerTickInput(1000000);
mythextrac50.addItemInput(<bewitchment:stone_ichor>);
mythextrac50.addItemOutput(<bewitchment:empty_jar>);
mythextrac50.addFluidOutput(<fluid:stone_ichor>*1000);
mythextrac50.build();

val mythextrac51 = RecipeBuilder.newBuilder("mythextrac51","mythic_processor_infuser",2);
mythextrac51.addEnergyPerTickInput(1000000);
mythextrac51.addItemInput(<bewitchment:birch_soul>);
mythextrac51.addItemOutput(<bewitchment:empty_jar>);
mythextrac51.addFluidOutput(<fluid:birch_soul>*1000);
mythextrac51.build();

val mythextrac52 = RecipeBuilder.newBuilder("mythextrac52","mythic_processor_infuser",2);
mythextrac52.addEnergyPerTickInput(1000000);
mythextrac52.addItemInput(<bewitchment:bottled_hellfire>);
mythextrac52.addItemOutput(<minecraft:glass_bottle>);
mythextrac52.addFluidOutput(<fluid:hellfire>*1000);
mythextrac52.build();

val mythextrac53 = RecipeBuilder.newBuilder("mythextrac53","mythic_processor_infuser",2);
mythextrac53.addEnergyPerTickInput(1000000);
mythextrac53.addItemInput(<contenttweaker:cloudy_oil_bottle>);
mythextrac53.addItemOutput(<minecraft:glass_bottle>);
mythextrac53.addFluidOutput(<fluid:cloudy_oil>*1000);
mythextrac53.build();

val mythextrac54 = RecipeBuilder.newBuilder("mythextrac54","mythic_processor_infuser",2);
mythextrac54.addEnergyPerTickInput(1000000);
mythextrac54.addItemInput(<contenttweaker:acacia_resin_bottle>);
mythextrac54.addItemOutput(<minecraft:glass_bottle>);
mythextrac54.addFluidOutput(<fluid:acacia_resin>*1000);
mythextrac54.build();

val mythextrac55 = RecipeBuilder.newBuilder("mythextrac55","mythic_processor_infuser",2);
mythextrac55.addEnergyPerTickInput(1000000);
mythextrac55.addItemInput(<contenttweaker:liquid_witchcraft_bottle>);
mythextrac55.addItemOutput(<minecraft:glass_bottle>);
mythextrac55.addFluidOutput(<fluid:liquid_witchcraft>*1000);
mythextrac55.build();

val mythextrac56 = RecipeBuilder.newBuilder("mythextrac56","mythic_processor_infuser",2);
mythextrac56.addEnergyPerTickInput(1000000);
mythextrac56.addItemInput(<contenttweaker:cleansing_balm_bottle>);
mythextrac56.addItemOutput(<minecraft:glass_bottle>);
mythextrac56.addFluidOutput(<fluid:cleansing_balm>*1000);
mythextrac56.build();

val mythextrac57 = RecipeBuilder.newBuilder("mythextrac57","mythic_processor_infuser",2);
mythextrac57.addEnergyPerTickInput(1000000);
mythextrac57.addItemInput(<contenttweaker:demonic_elixir_bottle>);
mythextrac57.addItemOutput(<minecraft:glass_bottle>);
mythextrac57.addFluidOutput(<fluid:demonic_elixir>*1000);
mythextrac57.build();

val mythextrac58 = RecipeBuilder.newBuilder("mythextrac58","mythic_processor_infuser",2);
mythextrac58.addEnergyPerTickInput(1000000);
mythextrac58.addItemInput(<contenttweaker:fiery_unguent_bottle>);
mythextrac58.addItemOutput(<minecraft:glass_bottle>);
mythextrac58.addFluidOutput(<fluid:fiery_unguent>*1000);
mythextrac58.build();

val mythextrac59 = RecipeBuilder.newBuilder("mythextrac59","mythic_processor_infuser",2);
mythextrac59.addEnergyPerTickInput(1000000);
mythextrac59.addItemInput(<contenttweaker:swirl_depths_bottle>);
mythextrac59.addItemOutput(<minecraft:glass_bottle>);
mythextrac59.addFluidOutput(<fluid:swirl_of_depths>*1000);
mythextrac59.build();

val mythextrac60 = RecipeBuilder.newBuilder("mythextrac60","mythic_processor_infuser",2);
mythextrac60.addEnergyPerTickInput(1000000);
mythextrac60.addItemInput(<contenttweaker:otherwordly_tears_bottle>);
mythextrac60.addItemOutput(<minecraft:glass_bottle>);
mythextrac60.addFluidOutput(<fluid:otherworldly_tears>*1000);
mythextrac60.build();

val mythextrac61 = RecipeBuilder.newBuilder("mythextrac61","mythic_processor_infuser",2);
mythextrac61.addEnergyPerTickInput(1000000);
mythextrac61.addItemInput(<contenttweaker:heaven_extract_bottle>);
mythextrac61.addItemOutput(<minecraft:glass_bottle>);
mythextrac61.addFluidOutput(<fluid:heaven_extract>*1000);
mythextrac61.build();

val mythextrac62 = RecipeBuilder.newBuilder("mythextrac62","mythic_processor_infuser",2);
mythextrac62.addEnergyPerTickInput(1000000);
mythextrac62.addItemInput(<contenttweaker:stone_ichor_bottle>);
mythextrac62.addItemOutput(<minecraft:glass_bottle>);
mythextrac62.addFluidOutput(<fluid:stone_ichor>*1000);
mythextrac62.build();

val mythextrac63 = RecipeBuilder.newBuilder("mythextrac63","mythic_processor_infuser",2);
mythextrac63.addEnergyPerTickInput(1000000);
mythextrac63.addItemInput(<contenttweaker:tear_of_nature_bottle>);
mythextrac63.addItemOutput(<minecraft:glass_bottle>);
mythextrac63.addFluidOutput(<fluid:tear_of_nature>*1000);
mythextrac63.build();

val mythextrac64 = RecipeBuilder.newBuilder("mythextrac64","mythic_processor_infuser",2);
mythextrac64.addEnergyPerTickInput(1000000);
mythextrac64.addItemInput(<openblocks:tank>.withTag({tank: {FluidName: "essence_of_sane_thoughts", Amount: 16000}}));
mythextrac64.addItemOutput(<openblocks:tank>);
mythextrac64.addFluidOutput(<fluid:essence_of_sane_thoughts>*16000);
mythextrac64.build();

val mythextrac65 = RecipeBuilder.newBuilder("mythextrac65","mythic_processor_infuser",2);
mythextrac65.addEnergyPerTickInput(1000000);
mythextrac65.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "nitrogen", Amount: 1000}}));
mythextrac65.addItemOutput(<techreborn:dynamiccell>);
mythextrac65.addFluidOutput(<fluid:nitrogen>*1000);
mythextrac65.build();

val mythextrac66 = RecipeBuilder.newBuilder("mythextrac66","mythic_processor_infuser",2);
mythextrac66.addEnergyPerTickInput(1000000);
mythextrac66.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "oxygen", Amount: 1000}}));
mythextrac66.addItemOutput(<techreborn:dynamiccell>);
mythextrac66.addFluidOutput(<fluid:oxygen>*1000);
mythextrac66.build();

val mythextrac67 = RecipeBuilder.newBuilder("mythextrac67","mythic_processor_infuser",2);
mythextrac67.addEnergyPerTickInput(1000000);
mythextrac67.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "noble_gas_mix", Amount: 1000}}));
mythextrac67.addItemOutput(<techreborn:dynamiccell>);
mythextrac67.addFluidOutput(<fluid:noble_gas_mix>*1000);
mythextrac67.build();

val mythextrac68 = RecipeBuilder.newBuilder("mythextrac68","mythic_processor_infuser",2);
mythextrac68.addEnergyPerTickInput(1000000);
mythextrac68.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "argon", Amount: 1000}}));
mythextrac68.addItemOutput(<techreborn:dynamiccell>);
mythextrac68.addFluidOutput(<fluid:argon>*1000);
mythextrac68.build();

val mythextrac69 = RecipeBuilder.newBuilder("mythextrac69","mythic_processor_infuser",2);
mythextrac69.addEnergyPerTickInput(1000000);
mythextrac69.addItemInput(<contenttweaker:ebb_of_death_bottle>);
mythextrac69.addItemOutput(<minecraft:glass_bottle>);
mythextrac69.addFluidOutput(<fluid:ebb_of_death>*1000);
mythextrac69.build();

val mythextrac70 = RecipeBuilder.newBuilder("mythextrac70","mythic_processor_infuser",2);
mythextrac70.addEnergyPerTickInput(1000000);
mythextrac70.addItemInput(<contenttweaker:droplet_of_wisdom_bottle>);
mythextrac70.addItemOutput(<minecraft:glass_bottle>);
mythextrac70.addFluidOutput(<fluid:droplet_of_wisdom>*1000);
mythextrac70.build();

val mythextrac71 = RecipeBuilder.newBuilder("mythextrac71","mythic_processor_infuser",2);
mythextrac71.addEnergyPerTickInput(1000000);
mythextrac71.addItemInput(<contenttweaker:essence_of_vitality_bottle>);
mythextrac71.addItemOutput(<minecraft:glass_bottle>);
mythextrac71.addFluidOutput(<fluid:essence_of_vitality>*1000);
mythextrac71.build();

val mythextrac72 = RecipeBuilder.newBuilder("mythextrac72","mythic_processor_infuser",2);
mythextrac72.addEnergyPerTickInput(1000000);
mythextrac72.addItemInput(<contenttweaker:oak_spirit_bottle>);
mythextrac72.addItemOutput(<minecraft:glass_bottle>);
mythextrac72.addFluidOutput(<fluid:oak_spirit>*1000);
mythextrac72.build();

val mythextrac73 = RecipeBuilder.newBuilder("mythextrac73","mythic_processor_infuser",2);
mythextrac73.addEnergyPerTickInput(1000000);
mythextrac73.addItemInput(<contenttweaker:spruce_heart_bottle>);
mythextrac73.addItemOutput(<minecraft:glass_bottle>);
mythextrac73.addFluidOutput(<fluid:spruce_heart>*1000);
mythextrac73.build();

val mythextrac74 = RecipeBuilder.newBuilder("mythextrac74","mythic_processor_infuser",2);
mythextrac74.addEnergyPerTickInput(1000000);
mythextrac74.addItemInput(<contenttweaker:oil_of_vitriol_bottle>);
mythextrac74.addItemOutput(<minecraft:glass_bottle>);
mythextrac74.addFluidOutput(<fluid:oil_of_vitriol>*1000);
mythextrac74.build();

val mythextrac75 = RecipeBuilder.newBuilder("mythextrac75","mythic_processor_infuser",2);
mythextrac75.addEnergyPerTickInput(1000000);
mythextrac75.addItemInput(<contenttweaker:birch_soul_bottle>);
mythextrac75.addItemOutput(<minecraft:glass_bottle>);
mythextrac75.addFluidOutput(<fluid:birch_soul>*1000);
mythextrac75.build();

val mythextrac76 = RecipeBuilder.newBuilder("mythextrac76","mythic_processor_infuser",2);
mythextrac76.addEnergyPerTickInput(1000000);
mythextrac76.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "fluidpotassium", Amount: 1000}}));
mythextrac76.addItemOutput(<techreborn:dynamiccell>);
mythextrac76.addFluidOutput(<fluid:fluidpotassium>*1000);
mythextrac76.build();

val mythextrac77 = RecipeBuilder.newBuilder("mythextrac77","mythic_processor_infuser",2);
mythextrac77.addEnergyPerTickInput(1000000);
mythextrac77.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "fluidsodium", Amount: 1000}}));
mythextrac77.addItemOutput(<techreborn:dynamiccell>);
mythextrac77.addFluidOutput(<fluid:fluidsodium>*1000);
mythextrac77.build();

val mythextrac78 = RecipeBuilder.newBuilder("mythextrac78","mythic_processor_infuser",2);
mythextrac78.addEnergyPerTickInput(1000000);
mythextrac78.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "potassium", Amount: 1000}}));
mythextrac78.addItemOutput(<techreborn:dynamiccell>);
mythextrac78.addFluidOutput(<fluid:potassium>*1000);
mythextrac78.build();

val mythextrac79 = RecipeBuilder.newBuilder("mythextrac79","mythic_processor_infuser",2);
mythextrac79.addEnergyPerTickInput(1000000);
mythextrac79.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "rutherfordium", Amount: 1000}}));
mythextrac79.addItemOutput(<techreborn:dynamiccell>);
mythextrac79.addFluidOutput(<fluid:rutherfordium>*1000);
mythextrac79.build();

val mythextrac80 = RecipeBuilder.newBuilder("mythextrac80","mythic_processor_infuser",2);
mythextrac80.addEnergyPerTickInput(1000000);
mythextrac80.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "chlorine", Amount: 1000}}));
mythextrac80.addItemOutput(<techreborn:dynamiccell>);
mythextrac80.addFluidOutput(<fluid:chlorine>*1000);
mythextrac80.build();

val mythextrac81 = RecipeBuilder.newBuilder("mythextrac81","mythic_processor_infuser",2);
mythextrac81.addEnergyPerTickInput(1000000);
mythextrac81.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "molten_scandium", Amount: 1000}}));
mythextrac81.addItemOutput(<techreborn:dynamiccell>);
mythextrac81.addFluidOutput(<fluid:molten_scandium>*1000);
mythextrac81.build();

val mythextrac82 = RecipeBuilder.newBuilder("mythextrac82","mythic_processor_infuser",2);
mythextrac82.addEnergyPerTickInput(1000000);
mythextrac82.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "uranium_235", Amount: 1000}}));
mythextrac82.addItemOutput(<techreborn:dynamiccell>);
mythextrac82.addFluidOutput(<fluid:uranium_235>*1000);
mythextrac82.build();

val mythextrac83 = RecipeBuilder.newBuilder("mythextrac83","mythic_processor_infuser",2);
mythextrac83.addEnergyPerTickInput(1000000);
mythextrac83.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "uranium_238", Amount: 1000}}));
mythextrac83.addItemOutput(<techreborn:dynamiccell>);
mythextrac83.addFluidOutput(<fluid:uranium_238>*1000);
mythextrac83.build();

val mythextrac84 = RecipeBuilder.newBuilder("mythextrac84","mythic_processor_infuser",2);
mythextrac84.addEnergyPerTickInput(1000000);
mythextrac84.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "astatine", Amount: 1000}}));
mythextrac84.addItemOutput(<techreborn:dynamiccell>);
mythextrac84.addFluidOutput(<fluid:astatine>*1000);
mythextrac84.build();

val mythextrac85 = RecipeBuilder.newBuilder("mythextrac85","mythic_processor_infuser",2);
mythextrac85.addEnergyPerTickInput(1000000);
mythextrac85.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "neptunium_237", Amount: 1000}}));
mythextrac85.addItemOutput(<techreborn:dynamiccell>);
mythextrac85.addFluidOutput(<fluid:neptunium_237>*1000);
mythextrac85.build();

val mythextrac86 = RecipeBuilder.newBuilder("mythextrac86","mythic_processor_infuser",2);
mythextrac86.addEnergyPerTickInput(1000000);
mythextrac86.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "neptunium_236", Amount: 1000}}));
mythextrac86.addItemOutput(<techreborn:dynamiccell>);
mythextrac86.addFluidOutput(<fluid:neptunium_236>*1000);
mythextrac86.build();

val mythextrac87 = RecipeBuilder.newBuilder("mythextrac87","mythic_processor_infuser",2);
mythextrac87.addEnergyPerTickInput(1000000);
mythextrac87.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "thorium", Amount: 1000}}));
mythextrac87.addItemOutput(<techreborn:dynamiccell>);
mythextrac87.addFluidOutput(<fluid:thorium>*1000);
mythextrac87.build();

val mythextrac88 = RecipeBuilder.newBuilder("mythextrac88","mythic_processor_infuser",2);
mythextrac88.addEnergyPerTickInput(1000000);
mythextrac88.addItemInput(<techreborn:dynamiccell>.withTag({Fluid: {FluidName: "harmonic_fluid_lattice", Amount: 1000}}));
mythextrac88.addItemOutput(<techreborn:dynamiccell>);
mythextrac88.addFluidOutput(<fluid:harmonic_fluid_lattice>*1000);
mythextrac88.build();

val mythextrac89 = RecipeBuilder.newBuilder("mythextrac89","mythic_processor_infuser",2);
mythextrac89.addEnergyPerTickInput(1000000);
mythextrac89.addItemInput(<forge:bucketfilled>.withTag({Fluid: {FluidName: "harmonic_fluid_lattice", Amount: 1000}}));
mythextrac89.addItemOutput(<minecraft:bucket>);
mythextrac89.addFluidOutput(<fluid:harmonic_fluid_lattice>*1000);
mythextrac89.build();

val mythextrac90 = RecipeBuilder.newBuilder("mythextrac90","mythic_processor_infuser",2);
mythextrac90.addEnergyPerTickInput(1000000);
mythextrac90.addItemInput(<openblocks:tank>.withTag({tank: {FluidName: "harmonic_fluid_lattice", Amount: 16000}}));
mythextrac90.addItemOutput(<openblocks:tank>);
mythextrac90.addFluidOutput(<fluid:harmonic_fluid_lattice>*16000);
mythextrac90.build();

val mythextrac91 = RecipeBuilder.newBuilder("mythextrac91","mythic_processor_infuser",2);
mythextrac91.addEnergyPerTickInput(1000000);
mythextrac91.addItemInput(<openblocks:tank>.withTag({tank: {FluidName: "harmonic_temporal_lattice", Amount: 16000}}));
mythextrac91.addItemOutput(<openblocks:tank>);
mythextrac91.addFluidOutput(<fluid:harmonic_temporal_lattice>*16000);
mythextrac91.build();