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>*100);
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(<ore:nuggetGold>*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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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§M模式 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 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(<extratrees:food:35>*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 mythenrich1 = RecipeBuilder.newBuilder("mythenrich1","mythic_processor_infuser",2);
mythenrich1.addEnergyPerTickInput(1000000);
mythenrich1.addItemInput(<nuclearcraft:compound:1>*10);
mythenrich1.addFluidInput(<fluid:wet_steam>*100);
mythenrich1.addFluidOutput(<fluid:high_particulate_steam>*150);
mythenrich1.build();

val mythenrich2 = RecipeBuilder.newBuilder("mythenrich2","mythic_processor_infuser",2);
mythenrich2.addEnergyPerTickInput(1000000);
mythenrich2.addItemInput(<nuclearcraft:gem_dust:5>*10);
mythenrich2.addFluidInput(<fluid:water>*10000);
mythenrich2.addFluidOutput(<fluid:fluorite_water>*6660);
mythenrich2.build();

val mythenrich3 = RecipeBuilder.newBuilder("mythenrich3","mythic_processor_infuser",2);
mythenrich3.addEnergyPerTickInput(1000000);
mythenrich3.addItemInput(<bewitchment:salt>*10);
mythenrich3.addFluidInput(<fluid:water>*1000);
mythenrich3.addFluidOutput(<fluid:salt_water>*1000);
mythenrich3.build();

val mythenrich4 = RecipeBuilder.newBuilder("mythenrich4","mythic_processor_infuser",2);
mythenrich4.addEnergyPerTickInput(1000000);
mythenrich4.addItemInput(<ore:dustRhenium>*10);
mythenrich4.addFluidInput(<fluid:unbalanced_negative_matter>*500);
mythenrich4.addFluidOutput(<fluid:bohrium>*400);
mythenrich4.build();

val mythenrich5 = RecipeBuilder.newBuilder("mythenrich5","mythic_processor_infuser",2);
mythenrich5.addEnergyPerTickInput(1000000);
mythenrich5.addItemInput(<contenttweaker:lanthanum_salt>*10);
mythenrich5.addFluidInput(<fluid:fierymetal>*1440);
mythenrich5.addFluidOutput(<fluid:lanthanum>*400);
mythenrich5.build();

val mythenrich6 = RecipeBuilder.newBuilder("mythenrich6","mythic_processor_infuser",2);
mythenrich6.addEnergyPerTickInput(1000000);
mythenrich6.addItemInput(<contenttweaker:hempcrete_dust>*10);
mythenrich6.addFluidInput(<fluid:hydrochloric_acid>*50);
mythenrich6.addFluidOutput(<fluid:inorganic_remains>*200);
mythenrich6.build();

val mythenrich7 = RecipeBuilder.newBuilder("mythenrich7","mythic_processor_infuser",2);
mythenrich7.addEnergyPerTickInput(1000000);
mythenrich7.addItemInput(<contenttweaker:imperfect_neutronium_nugget>*10);
mythenrich7.addFluidInput(<fluid:fluix_plasma>*10000);
mythenrich7.addFluidOutput(<fluid:fluix_plasma>*11000);
mythenrich7.build();

val mythenrich8 = RecipeBuilder.newBuilder("mythenrich8","mythic_processor_infuser",2);
mythenrich8.addEnergyPerTickInput(1000000);
mythenrich8.addItemInput(<contenttweaker:actualizing_stone>*10);
mythenrich8.addFluidInput(<fluid:hyperdense_plasma>*1000);
mythenrich8.addFluidOutput(<fluid:high_entropy_hyperdense_plasma>*40000);
mythenrich8.build();

val mythenrich9 = RecipeBuilder.newBuilder("mythenrich9","mythic_processor_infuser",2);
mythenrich9.addEnergyPerTickInput(1000000);
mythenrich9.addItemInput(<extratrees:misc:0>*40);
mythenrich9.addFluidInput(<fluid:jeweled_blend>*1500);
mythenrich9.addFluidOutput(<fluid:innerved_jeweled_blend>*1500);
mythenrich9.build();

val mythenrich10 = RecipeBuilder.newBuilder("mythenrich10","mythic_processor_infuser",2);
mythenrich10.addEnergyPerTickInput(1000000);
mythenrich10.addItemInput(<appliedenergistics2:material:45>*120);
mythenrich10.addFluidInput(<fluid:innerved_jeweled_blend>*1500);
mythenrich10.addFluidOutput(<fluid:ouranic_jeweled_blend>*1500);
mythenrich10.build();

val mythenrich11 = RecipeBuilder.newBuilder("mythenrich11","mythic_processor_infuser",2);
mythenrich11.addEnergyPerTickInput(1000000);
mythenrich11.addItemInput(<minecraft:gunpowder>*640);
mythenrich11.addFluidInput(<fluid:ouranic_jeweled_blend>*1500);
mythenrich11.addFluidOutput(<fluid:eikaic_jeweled_blend>*1500);
mythenrich11.build();

val mythenrich12 = RecipeBuilder.newBuilder("mythenrich12","mythic_processor_infuser",2);
mythenrich12.addEnergyPerTickInput(1000000);
mythenrich12.addItemInput(<contenttweaker:dust_of_infinite_wishes>*10);
mythenrich12.addFluidInput(<fluid:hint_of_divinity>*40000);
mythenrich12.addFluidOutput(<fluid:infinite_divine_wish>*80000);
mythenrich12.build();

val mythenrich13 = RecipeBuilder.newBuilder("mythenrich13","mythic_processor_infuser",2);
mythenrich13.addEnergyPerTickInput(1000000);
mythenrich13.addItemInput(<contenttweaker:dust_of_infinite_wishes>*10);
mythenrich13.addFluidInput(<fluid:hint_of_insanity>*40000);
mythenrich13.addFluidOutput(<fluid:infinite_insane_wish>*80000);
mythenrich13.build();

val mythenrich14 = RecipeBuilder.newBuilder("mythenrich14","mythic_processor_infuser",2);
mythenrich14.addEnergyPerTickInput(1000000);
mythenrich14.addItemInput(<contenttweaker:infused_dread_shard>*10);
mythenrich14.addFluidInput(<fluid:essence_of_betrayal>*500);
mythenrich14.addFluidOutput(<fluid:essence_of_betrayal>*1000);
mythenrich14.build();

val mythenrich15 = RecipeBuilder.newBuilder("mythenrich15","mythic_processor_infuser",2);
mythenrich15.addEnergyPerTickInput(1000000);
mythenrich15.addItemInput(<contenttweaker:stone_of_constraint>*10);
mythenrich15.addFluidInput(<fluid:essence_of_ilarity>*100);
mythenrich15.addFluidOutput(<fluid:matter_of_restraining>*40000);
mythenrich15.build();

val mythenrich16 = RecipeBuilder.newBuilder("mythenrich16","mythic_processor_infuser",2);
mythenrich16.addEnergyPerTickInput(1000000);
mythenrich16.addItemInput(<contenttweaker:vial_of_ilarity>*10);
mythenrich16.addFluidInput(<fluid:essence_of_ilarity>*100);
mythenrich16.addFluidOutput(<fluid:essence_of_ilarity>*40000);
mythenrich16.build();

val mythenrich17 = RecipeBuilder.newBuilder("mythenrich17","mythic_processor_infuser",2);
mythenrich17.addEnergyPerTickInput(1000000);
mythenrich17.addItemInput(<contenttweaker:divine_resonance_fabrial>*10);
mythenrich17.addFluidInput(<fluid:hint_of_divinity>*80000);
mythenrich17.addFluidOutput(<fluid:divine_resonant_hint>*80000);
mythenrich17.build();

val mythenrich18 = RecipeBuilder.newBuilder("mythenrich18","mythic_processor_infuser",2);
mythenrich18.addEnergyPerTickInput(1000000);
mythenrich18.addItemInput(<avaritia:resource:5>*10);
mythenrich18.addFluidInput(<fluid:divine_resonant_hint>*80000);
mythenrich18.addFluidOutput(<fluid:divine_resonance>*80000);
mythenrich18.build();

val mythenrich19 = RecipeBuilder.newBuilder("mythenrich19","mythic_processor_infuser",2);
mythenrich19.addEnergyPerTickInput(1000000);
mythenrich19.addItemInput(<contenttweaker:bismuth_cluster>*10);
mythenrich19.addFluidInput(<fluid:hydrochloric_acid>*100);
mythenrich19.addFluidOutput(<fluid:bismuth>*1440);
mythenrich19.build();

val mythenrich20 = RecipeBuilder.newBuilder("mythenrich20","mythic_processor_infuser",2);
mythenrich20.addEnergyPerTickInput(1000000);
mythenrich20.addItemInput(<contenttweaker:dream_projector_gem>*1);
mythenrich20.addFluidInput(<fluid:marginal_pearlized_essence>*2000);
mythenrich20.addFluidOutput(<fluid:marginal_pearlized_catalyst>*2000);
mythenrich20.build();

val mythenrich21 = RecipeBuilder.newBuilder("mythenrich21","mythic_processor_infuser",2);
mythenrich21.addEnergyPerTickInput(1000000);
mythenrich21.addItemInput(<contenttweaker:cursed_dragon_egg>*1);
mythenrich21.addFluidInput(<fluid:weak_pearlized_essence>*2000);
mythenrich21.addFluidOutput(<fluid:weak_pearlized_catalyst>*2000);
mythenrich21.build();

val mythenrich22 = RecipeBuilder.newBuilder("mythenrich22","mythic_processor_infuser",2);
mythenrich22.addEnergyPerTickInput(1000000);
mythenrich22.addItemInput(<contenttweaker:strange_stone_essence>*1);
mythenrich22.addFluidInput(<fluid:moderate_pearlized_essence>*2000);
mythenrich22.addFluidOutput(<fluid:moderate_pearlized_catalyst>*2000);
mythenrich22.build();

val mythenrich23 = RecipeBuilder.newBuilder("mythenrich23","mythic_processor_infuser",2);
mythenrich23.addEnergyPerTickInput(1000000);
mythenrich23.addItemInput(<avaritia:resource:5>*1);
mythenrich23.addFluidInput(<fluid:strong_pearlized_essence>*2000);
mythenrich23.addFluidOutput(<fluid:strong_pearlized_catalyst>*2000);
mythenrich23.build();

val mythenrich24 = RecipeBuilder.newBuilder("mythenrich24","mythic_processor_infuser",2);
mythenrich24.addEnergyPerTickInput(1000000);
mythenrich24.addItemInput(<twilightforest:cinder_log>*64);
mythenrich24.addFluidInput(<fluid:hot_spring_water>*64000);
mythenrich24.addFluidOutput(<fluid:sacred_spring_fire>*64000);
mythenrich24.build();

val mythenrich25 = RecipeBuilder.newBuilder("mythenrich25","mythic_processor_infuser",2);
mythenrich25.addEnergyPerTickInput(1000000);
mythenrich25.addItemInput(<contenttweaker:neutronium_pearl>*1);
mythenrich25.addFluidInput(<fluid:molten_hassium_alloy>*100000);
mythenrich25.addFluidOutput(<fluid:neutrhassium_alloy>*100000);
mythenrich25.build();

val mythenrich26 = RecipeBuilder.newBuilder("mythenrich26","mythic_processor_infuser",2);
mythenrich26.addEnergyPerTickInput(1000000);
mythenrich26.addItemInput(<contenttweaker:dna_primer>*100);
mythenrich26.addFluidInput(<fluid:bio.ethanol>*1000);
mythenrich26.addFluidOutput(<fluid:binnie.dna.raw>*1000);
mythenrich26.build();

val mythenrich27 = RecipeBuilder.newBuilder("mythenrich27","mythic_processor_infuser",2);
mythenrich27.addEnergyPerTickInput(1000000);
mythenrich27.addItemInput(<minecraft:wheat>*10);
mythenrich27.addFluidInput(<fluid:binnie.growth.medium>*250);
mythenrich27.addFluidOutput(<fluid:binnie.bacteria>*50);
mythenrich27.build();

val mythenrich28 = RecipeBuilder.newBuilder("mythenrich28","mythic_processor_infuser",2);
mythenrich28.addEnergyPerTickInput(1000000);
mythenrich28.addItemInput(<genetics:misc:4>*10);
mythenrich28.addFluidInput(<fluid:water>*250);
mythenrich28.addFluidOutput(<fluid:binnie.growth.medium>*250);
mythenrich28.build();

val mythenrich29 = RecipeBuilder.newBuilder("mythenrich29","mythic_processor_infuser",2);
mythenrich29.addEnergyPerTickInput(1000000);
mythenrich29.addItemInput(<contenttweaker:quasar_charged_gem>);
mythenrich29.addFluidInput(<fluid:pure_recursion>*200);
mythenrich29.addFluidOutput(<fluid:doped_recursion>*200);
mythenrich29.build();

val mythenrich30 = RecipeBuilder.newBuilder("mythenrich30","mythic_processor_infuser",2);
mythenrich30.addEnergyPerTickInput(1000000);
mythenrich30.addItemInput(<minecraft:coal>);
mythenrich30.addFluidInput(<fluid:glowstone>*100);
mythenrich30.addFluidOutput(<fluid:combustible_glowstone>*100);
mythenrich30.build();

val mythenrich31 = RecipeBuilder.newBuilder("mythenrich31","mythic_processor_infuser",2);
mythenrich31.addEnergyPerTickInput(1000000);
mythenrich31.addItemInput(<minecraft:blaze_powder>);
mythenrich31.addFluidInput(<fluid:refined_fuel>*100);
mythenrich31.addFluidOutput(<fluid:blazing_refined_fuel>*100);
mythenrich31.build();


val mythenrich32 = RecipeBuilder.newBuilder("mythenrich32","mythic_processor_infuser",2);
mythenrich32.addEnergyPerTickInput(1000000);
mythenrich32.addItemInput(<actuallyadditions:item_misc:23>);
mythenrich32.addFluidInput(<fluid:refinedcanolaoil>*1000);
mythenrich32.addFluidOutput(<fluid:crystaloil>*1000);
mythenrich32.build();

val mythenrich33 = RecipeBuilder.newBuilder("mythenrich33","mythic_processor_infuser",2);
mythenrich33.addEnergyPerTickInput(1000000);
mythenrich33.addItemInput(<actuallyadditions:item_misc:24>);
mythenrich33.addFluidInput(<fluid:crystaloil>*1000);
mythenrich33.addFluidOutput(<fluid:empoweredoil>*1000);
mythenrich33.build();

val mythenrich34 = RecipeBuilder.newBuilder("mythenrich34","mythic_processor_infuser",2);
mythenrich34.addEnergyPerTickInput(1000000);
mythenrich34.addItemInput(<contenttweaker:enriched_canola_seed>);
mythenrich34.addFluidInput(<fluid:empoweredoil>*1000);
mythenrich34.addFluidOutput(<fluid:enriched_canola_oil>*1000);
mythenrich34.build();

val mythenrich35 = RecipeBuilder.newBuilder("mythenrich35","mythic_processor_infuser",2);
mythenrich35.addEnergyPerTickInput(1000000);
mythenrich35.addItemInput(<extratrees:misc:4>);
mythenrich35.addFluidInput(<fluid:binnie.juice.apricot>*1000);
mythenrich35.addFluidOutput(<fluid:binnie.wine.apricot>*1000);
mythenrich35.build();

val mythenrich36 = RecipeBuilder.newBuilder("mythenrich36","mythic_processor_infuser",2);
mythenrich36.addEnergyPerTickInput(1000000);
mythenrich36.addItemInput(<extratrees:misc:4>);
mythenrich36.addFluidInput(<fluid:binnie.juice.banana>*1000);
mythenrich36.addFluidOutput(<fluid:binnie.wine.banana>*1000);
mythenrich36.build();

val mythenrich37 = RecipeBuilder.newBuilder("mythenrich37","mythic_processor_infuser",2);
mythenrich37.addEnergyPerTickInput(1000000);
mythenrich37.addItemInput(<extratrees:misc:4>);
mythenrich37.addFluidInput(<fluid:binnie.juice.cherry>*1000);
mythenrich37.addFluidOutput(<fluid:binnie.wine.cherry>*1000);
mythenrich37.build();

val mythenrich38 = RecipeBuilder.newBuilder("mythenrich38","mythic_processor_infuser",2);
mythenrich38.addEnergyPerTickInput(1000000);
mythenrich38.addItemInput(<extratrees:misc:4>);
mythenrich38.addFluidInput(<fluid:binnie.juice.apple>*1000);
mythenrich38.addFluidOutput(<fluid:binnie.cider.apple>*1000);
mythenrich38.build();

val mythenrich39 = RecipeBuilder.newBuilder("mythenrich39","mythic_processor_infuser",2);
mythenrich39.addEnergyPerTickInput(1000000);
mythenrich39.addItemInput(<extratrees:misc:4>);
mythenrich39.addFluidInput(<fluid:binnie.juice.peach>*1000);
mythenrich39.addFluidOutput(<fluid:binnie.cider.peach>*1000);
mythenrich39.build();

val mythenrich40 = RecipeBuilder.newBuilder("mythenrich40","mythic_processor_infuser",2);
mythenrich40.addEnergyPerTickInput(1000000);
mythenrich40.addItemInput(<extratrees:misc:4>);
mythenrich40.addFluidInput(<fluid:binnie.juice.pear>*1000);
mythenrich40.addFluidOutput(<fluid:binnie.ciderpear>*1000);
mythenrich40.build();

val mythenrich41 = RecipeBuilder.newBuilder("mythenrich41","mythic_processor_infuser",2);
mythenrich41.addEnergyPerTickInput(1000000);
mythenrich41.addItemInput(<extratrees:misc:4>);
mythenrich41.addFluidInput(<fluid:binnie.juice.elderberry>*1000);
mythenrich41.addFluidOutput(<fluid:binnie.wine.elderberry>*1000);
mythenrich41.build();

val mythenrich42 = RecipeBuilder.newBuilder("mythenrich42","mythic_processor_infuser",2);
mythenrich42.addEnergyPerTickInput(1000000);
mythenrich42.addItemInput(<extratrees:misc:4>);
mythenrich42.addFluidInput(<fluid:binnie.juice.plum>*1000);
mythenrich42.addFluidOutput(<fluid:binnie.wine.plum>*1000);
mythenrich42.build();

val mythenrich43 = RecipeBuilder.newBuilder("mythenrich43","mythic_processor_infuser",2);
mythenrich43.addEnergyPerTickInput(1000000);
mythenrich43.addItemInput(<extratrees:misc:4>);
mythenrich43.addFluidInput(<fluid:binnie.juice.carrot>*1000);
mythenrich43.addFluidOutput(<fluid:binnie.wine.carrot>*1000);
mythenrich43.build();

val mythenrich44 = RecipeBuilder.newBuilder("mythenrich44","mythic_processor_infuser",2);
mythenrich44.addEnergyPerTickInput(1000000);
mythenrich44.addItemInput(<extratrees:misc:4>);
mythenrich44.addFluidInput(<fluid:binnie.juice.white.grape>*1000);
mythenrich44.addFluidOutput(<fluid:binnie.wine.white>*1000);
mythenrich44.build();

val mythenrich45 = RecipeBuilder.newBuilder("mythenrich45","mythic_processor_infuser",2);
mythenrich45.addEnergyPerTickInput(1000000);
mythenrich45.addItemInput(<extratrees:misc:4>);
mythenrich45.addFluidInput(<fluid:binnie.juice.red.grape>*1000);
mythenrich45.addFluidOutput(<fluid:binnie.wine.red>*1000);
mythenrich45.build();

val mythenrich46 = RecipeBuilder.newBuilder("mythenrich46","mythic_processor_infuser",2);
mythenrich46.addEnergyPerTickInput(1000000);
mythenrich46.addItemInput(<extratrees:misc:4>);
mythenrich46.addFluidInput(<fluid:binnie.juice.lime>*1000);
mythenrich46.addFluidOutput(<fluid:binnie.wine.citrus>*1000);
mythenrich46.build();

val mythenrich47 = RecipeBuilder.newBuilder("mythenrich47","mythic_processor_infuser",2);
mythenrich47.addEnergyPerTickInput(1000000);
mythenrich47.addItemInput(<extratrees:misc:4>);
mythenrich47.addFluidInput(<fluid:binnie.juice.grapefruit>*1000);
mythenrich47.addFluidOutput(<fluid:binnie.wine.citrus>*1000);
mythenrich47.build();

val mythenrich48 = RecipeBuilder.newBuilder("mythenrich48","mythic_processor_infuser",2);
mythenrich48.addEnergyPerTickInput(1000000);
mythenrich48.addItemInput(<extratrees:misc:4>);
mythenrich48.addFluidInput(<fluid:binnie.juice.lemon>*1000);
mythenrich48.addFluidOutput(<fluid:binnie.wine.citrus>*1000);
mythenrich48.build();

val mythenrich49 = RecipeBuilder.newBuilder("mythenrich49","mythic_processor_infuser",2);
mythenrich49.addEnergyPerTickInput(1000000);
mythenrich49.addItemInput(<extratrees:misc:4>);
mythenrich49.addFluidInput(<fluid:binnie.juice.orange>*1000);
mythenrich49.addFluidOutput(<fluid:binnie.wine.citrus>*1000);
mythenrich49.build();

val mythenrich50 = RecipeBuilder.newBuilder("mythenrich50","mythic_processor_infuser",2);
mythenrich50.addEnergyPerTickInput(1000000);
mythenrich50.addItemInput(<extratrees:misc:4>);
mythenrich50.addFluidInput(<fluid:binnie.juice.cranberry>*1000);
mythenrich50.addFluidOutput(<fluid:binnie.wine.cranberry>*1000);
mythenrich50.build();

val mythenrich51 = RecipeBuilder.newBuilder("mythenrich51","mythic_processor_infuser",2);
mythenrich51.addEnergyPerTickInput(1000000);
mythenrich51.addItemInput(<extratrees:misc:4>);
mythenrich51.addFluidInput(<fluid:binnie.juice.pineapple>*1000);
mythenrich51.addFluidOutput(<fluid:binnie.wine.pineapple>*1000);
mythenrich51.build();

val mythenrich52 = RecipeBuilder.newBuilder("mythenrich52","mythic_processor_infuser",2);
mythenrich52.addEnergyPerTickInput(1000000);
mythenrich52.addItemInput(<extratrees:misc:4>);
mythenrich52.addFluidInput(<fluid:binnie.juice.tomato>*1000);
mythenrich52.addFluidOutput(<fluid:binnie.wine.tomato>*1000);
mythenrich52.build();