one phish, two phish, red phish and blue phish

import java.io.*;
import java.time.*;
import java.util.*;
import java.nio.file.*;
import org.apache.poi.xwpf.usermodel.*;
import java.time.format.DateTimeFormatter;

class AutoEngineGen {
    public static int rN (double add, int maxV){
        return (int)(add + (Math.random() * maxV));
    }
    public static void f_calc_o(String engine_Name, String engine_Cycle_Chosen, String oxidizer_Chosen,
                                String fuel_Chosen, String[] tank_Repressurisation,
                                String[] altitude_Of_Operation) throws IOException {
        String tank_Repressurisation_Chosen = rand(tank_Repressurisation);
        String altitude_Of_Operation_Chosen = rand(altitude_Of_Operation);
        String nozzle_Type_Chosen = bussy(altitude_Of_Operation_Chosen);
        String[] cooling_mechanism = {"Ablative Cooling", "Radiative Cooling", "Dump Cooling", "Film Cooling",
                "Regenerative Cooling", "Transpiration Cooling"};
        String cooling_Mechanism_Chosen = rand(cooling_mechanism);
        String f_regen = "Oxidizer ";
        if (cooling_Mechanism_Chosen.equals("Regenerative Cooling")) {
            int choice = (rN(4, 63))/2;
            if (Math.ceil(choice) == Math.floor(choice)) {
                f_regen = "Fuel ";
            }
        }
        String cooling_Mechanism_C = f_regen + cooling_Mechanism_Chosen;
        boolean isHypergolic = isHypergolic(oxidizer_Chosen, fuel_Chosen);
        boolean isCryogenic = isCryogenic(oxidizer_Chosen, fuel_Chosen);
        String injector = Injector(cooling_Mechanism_C);
        String purpose = uses(isHypergolic, isCryogenic, altitude_Of_Operation_Chosen);
        output_def(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen, altitude_Of_Operation_Chosen,
                nozzle_Type_Chosen, tank_Repressurisation_Chosen, cooling_Mechanism_C, isHypergolic,
                isCryogenic, purpose, injector);
    }
    public static String rand(String[] array){
        Collections.shuffle(Arrays.asList(array));
        Random arrayChosen = new Random();
        int arrayChosen_index = arrayChosen.nextInt(array.length);
        return array[arrayChosen_index];
    }
    public static int findex(String[] array, String t){
        ArrayList<String> clist = new ArrayList<>();
        Collections.addAll(clist, array);
        return clist.indexOf(t);
    }
    public static boolean isCryogenic(String oxidizer_chosen, String fuel_chosen) {
        boolean isCryo = false;
        switch (oxidizer_chosen) {
            case "O3 (Ozone)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)", "ClF3 (Chlorine Trifluoride)",
                    "ClF5 (Chlorine Pentafluoride)", "O2 (Oxygen)" -> {
                isCryo = true;
            }
        }
        switch (fuel_chosen) {
            case "CH3OH (Methanol)", "C12H24 (Kerosene)", "H2 (Hydrogen)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                    "B2H6 (Diborane)", "B5H9 (Pentaborane)", "NH3 (Ammonia)", "CH4 (Methane)" -> {
                isCryo = true;
            }
        }
        return isCryo;
    }
    public static String uses(boolean isHypergolic, boolean isCryogenic, String alt) {
        String use = "";
        if ((alt.equals("0-10 km (Sea Level)")) || (alt.equals("20-30 km (Medium Atmosphere)"))) {
            String[] pot_uses = {"Booster Stage", "Orbital Manoeuvering", "Landing"};
            Collections.shuffle(Arrays.asList(pot_uses));
            Random useChosen = new Random();
            int useChosen_index = useChosen.nextInt(pot_uses.length);
            use = pot_uses[useChosen_index];
        } else if ((alt.equals("30-80 km (High Atmosphere)")) || (alt.equals("80 km+ (Vacuum)"))) {
            if (isHypergolic && isCryogenic) {
                String[] pot_uses = {"Upper Stage", "Orbital Manoeuvering", "Course Correction", "Landing"};
                Collections.shuffle(Arrays.asList(pot_uses));
                Random useChosen = new Random();
                int useChosen_index = useChosen.nextInt(pot_uses.length);
                use = pot_uses[useChosen_index];
            } else if (!isHypergolic && isCryogenic) {
                String[] pot_uses = {"Upper Stage", "Landing"};
                Collections.shuffle(Arrays.asList(pot_uses));
                Random useChosen = new Random();
                int useChosen_index = useChosen.nextInt(pot_uses.length);
                use = pot_uses[useChosen_index];
            } else if (isHypergolic && !isCryogenic) {
                String[] pot_uses = {"Upper Stage", "Space tug", "Orbital Manoeuvering", "Course Correction", "Landing"};
                Collections.shuffle(Arrays.asList(pot_uses));
                Random useChosen = new Random();
                int useChosen_index = useChosen.nextInt(pot_uses.length);
                use = pot_uses[useChosen_index];
            }
        } else {
            if (isHypergolic && isCryogenic) {
                String[] pot_uses = {"Booster Stage", "Upper Stage", "Orbital Manoeuvering", "Course Correction", "Landing"};
                Collections.shuffle(Arrays.asList(pot_uses));
                Random useChosen = new Random();
                int useChosen_index = useChosen.nextInt(pot_uses.length);
                use = pot_uses[useChosen_index];
            } else if (!isHypergolic && isCryogenic) {
                String[] pot_uses = {"Booster Stage", "Upper Stage", "Landing"};
                Collections.shuffle(Arrays.asList(pot_uses));
                Random useChosen = new Random();
                int useChosen_index = useChosen.nextInt(pot_uses.length);
                use = pot_uses[useChosen_index];
            } else if (isHypergolic && !isCryogenic) {
                String[] pot_uses = {"Booster Stage", "Upper Stage", "Space tug", "Orbital Manoeuvering", "Course Correction", "Landing"};
                Collections.shuffle(Arrays.asList(pot_uses));
                Random useChosen = new Random();
                int useChosen_index = useChosen.nextInt(pot_uses.length);
                use = pot_uses[useChosen_index];
            }
        }
        return use;
    }
    public static String Injector(String cooling_Mechanism) {
        String fuel_state = "Liquid";
        if (cooling_Mechanism.contains("Regenerative Cooling")) {
            fuel_state = "Gas";
        }
        String[] injector = {"Showerhead Injector", "Self-impinging Injector", "Cross-impinging Injector",
                "Swirl Injector", "Pintle Injector"};
        return fuel_state + " " + rand(injector);
    }
    public static String bussy (String altitude_Of_Operation_Chosen) {
        String nozzle_Type_Chosen = null;
        switch (altitude_Of_Operation_Chosen) {
            case "0-10 km (Sea Level)" -> {
                String[] nozzle_Type_List_SL = {"De Laval Cone (Without Nozzle Extension)",
                        "De Laval Bell (Without Nozzle Extension)"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_SL);
            } case "20-30 km (Medium Atmosphere)" -> {
                String[] nozzle_Type_List_HA = {"De Laval Bell (Without Nozzle Extension)", "De Laval Cone (With Nozzle Extension)",
                        "De Laval Bell (With Nozzle Extension)", "Dual Bell Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_HA);
            } case "30-80 km (High Atmosphere)" -> {
                String[] nozzle_Type_List_HAi = {"De Laval Cone (With Nozzle Extension)", "De Laval Bell (With Nozzle Extension)",
                        "Dual Bell Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_HAi);
            } case "80 km+ (Vacuum)" -> {
                String[] nozzle_Type_List_VA = {"De Laval Cone (With Nozzle Extension)",
                        "De Laval Bell (With Nozzle Extension)", "Expanding Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_VA);
            } case "Any Altitude (0-80 km+)" -> {
                String[] nozzle_Type_List_Aero = {"Linear Aerospike Nozzle", "Toroidal Aerospike Nozzle", "Expansion-Deflection Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_Aero);
            }
        }
        return nozzle_Type_Chosen;
    }
    public static String ass_crack(String[] engine_Name1, String[] firstPart) {
        String engine_Name;
        Collections.shuffle(Arrays.asList(engine_Name1));
        Collections.shuffle(Arrays.asList(firstPart));
        Random engineNameChosen = new Random();
        Random firstPartC = new Random();
        int engineNameChosen_index = engineNameChosen.nextInt(engine_Name1.length);
        int firstPart_index = firstPartC.nextInt(firstPart.length);
        String engNameFinalf = " " + engine_Name1[engineNameChosen_index];
        String firstPart_f = firstPart[firstPart_index] + "-";
        int finalNumber = rN(12, 999);
        if (finalNumber % 8 == 0) {
            engine_Name = firstPart_f + finalNumber + engNameFinalf;
        } else {
            char randomizedCharacter;
            int uio93 = rN(1, 999);
            int uio94 = rN(1, 11);
            Random randomLetter = new Random();
            if (uio93 % uio94 == 0) {
                randomizedCharacter = (char) (randomLetter.nextInt(26) + 'a');
                while (randomizedCharacter != 'l' || randomizedCharacter == 'o' || randomizedCharacter == 'i' || randomizedCharacter == 'q' || randomizedCharacter == 'e' || randomizedCharacter == 'h' || randomizedCharacter == 'g' || randomizedCharacter == 'c' || randomizedCharacter == 'j') {
                    randomizedCharacter = (char) (randomLetter.nextInt(26) + 'a');
                    if (randomizedCharacter != 'l' && randomizedCharacter != 'o' && randomizedCharacter != 'i' && randomizedCharacter != 'q' && randomizedCharacter != 'e' && randomizedCharacter != 'h' && randomizedCharacter != 'g' && randomizedCharacter != 'c' && randomizedCharacter != 'j') {
                        break;
                    }
                }
            } else {
                randomizedCharacter = (char) (randomLetter.nextInt(26) + 'A');
                while (randomizedCharacter == 'O' || randomizedCharacter == 'I' || randomizedCharacter == 'Q') {
                    randomizedCharacter = (char) (randomLetter.nextInt(26) + 'A');
                    if (randomizedCharacter == 'O' || randomizedCharacter == 'I' || randomizedCharacter == 'Q') {
                        break;
                    }
                }
            }
            engine_Name = firstPart_f + finalNumber + randomizedCharacter + engNameFinalf;
        }
        return engine_Name;
    }
    public static void output_monod(String ENN, String ECC, String AOOC, String PLC, String NTLC, String CMC, String CCC, String purpose) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex.docx");
        System.out.println(lbrk + '\n' + "Engine Designation: " + ENN + '\n');
        System.out.println("Fuel Flow Cycle: " + ECC);
        System.out.println("Propellant: " + PLC);
        System.out.println("Altitude Of Operation: " + AOOC);
        System.out.println("Exhaust Nozzle Geometry: " + NTLC);
        System.out.println("Engine Use Case: " + purpose);
        System.out.println("Nozzle Cooling Mechanism: " + CMC);
        System.out.println("Propellant catalyst: " + CCC + '\n');
        XWPFDocument docx = new XWPFDocument();
        if (new File(String.valueOf(pathn1)).exists()) {
            FileInputStream jesus = new FileInputStream(String.valueOf(pathn1));
            docx = new XWPFDocument(jesus);
        }
        XWPFParagraph par = docx.createParagraph();
        XWPFRun run = par.createRun();
        run.setFontSize(12);
        run.setBold(true);
        run.setFontFamily("Arial");
        run.setText("Engine Designation: ");
        run.setTextPosition(15);
        XWPFRun run2 = par.createRun();
        run2.setFontSize(12);
        run2.setBold(true);
        run2.setFontFamily("Arial");
        run2.setText(ENN);
        run2.setTextPosition(15);
        run2.addBreak();
        // -----------------------------------------------------------
        XWPFRun run3 = par.createRun();
        run3.setFontSize(10);
        run3.setBold(true);
        run3.setFontFamily("Arial");
        run3.setText("Fuel Flow Cycle: ");
        XWPFRun run4 = par.createRun();
        run4.setFontSize(10);
        run4.setFontFamily("Arial");
        run4.setText(ECC);
        run4.addBreak();
        // -----------------------------------------------------------
        XWPFRun run5 = par.createRun();
        run5.setFontSize(10);
        run5.setBold(true);
        run5.setFontFamily("Arial");
        run5.setText("Propellant(Remass): ");
        XWPFRun run6 = par.createRun();
        run6.setFontSize(10);
        run6.setFontFamily("Arial");
        run6.setText(PLC);
        run6.addBreak();
        // -----------------------------------------------------------
        XWPFRun run9 = par.createRun();
        run9.setFontSize(10);
        run9.setBold(true);
        run9.setFontFamily("Arial");
        run9.setText("Exhaust Nozzle Geometry: ");
        XWPFRun run0 = par.createRun();
        run0.setFontSize(10);
        run0.setFontFamily("Arial");
        run0.setText(NTLC);
        run0.addBreak();
        // -----------------------------------------------------------
        XWPFRun run104 = par.createRun();
        run104.setFontSize(10);
        run104.setBold(true);
        run104.setFontFamily("Arial");
        run104.setText("Engine Use Case: ");
        XWPFRun run105 = par.createRun();
        run105.setFontSize(10);
        run105.setFontFamily("Arial");
        run105.setText(purpose);
        run105.addBreak();
        // -----------------------------------------------------------
        XWPFRun run10 = par.createRun();
        run10.setFontSize(10);
        run10.setBold(true);
        run10.setFontFamily("Arial");
        run10.setText("Altitude Of Operation: ");
        XWPFRun run23 = par.createRun();
        run23.setFontSize(10);
        run23.setFontFamily("Arial");
        run23.setText(AOOC);
        run23.addBreak();
        // -----------------------------------------------------------
        XWPFRun run13 = par.createRun();
        run13.setFontSize(10);
        run13.setBold(true);
        run13.setFontFamily("Arial");
        run13.setText("Nozzle Cooling Mechanism: ");
        XWPFRun run14 = par.createRun();
        run14.setFontSize(10);
        run14.setFontFamily("Arial");
        run14.setText(CMC);
        run14.addBreak();
        // -----------------------------------------------------------
        XWPFRun run15 = par.createRun();
        run15.setFontSize(10);
        run15.setBold(true);
        run15.setFontFamily("Arial");
        run15.setText("Engine catalyst: ");
        XWPFRun run16 = par.createRun();
        run16.setFontSize(10);
        run16.setFontFamily("Arial");
        run16.setText(CCC);
        run16.addBreak();
        run16.addBreak();
        // -----------------------------------------------------------
        try (FileOutputStream out = new FileOutputStream(String.valueOf(pathn1))) {
            docx.write(out);
        }
    }
    public static void output_mono(String ENN, String ECC, String AOOC, String PLC, String NTLC, String CMC, String purpose) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex.docx");
        System.out.println(lbrk + '\n' + "Engine Designation: " + ENN + '\n');
        System.out.println("Fuel Flow Cycle: " + ECC);
        System.out.println("Propellant: " + PLC);
        System.out.println("Altitude Of Operation: " + AOOC);
        System.out.println("Exhaust Nozzle Geometry: " + NTLC);
        System.out.println("Engine Use Case: " + purpose);
        System.out.println("Nozzle Cooling Mechanism: " + CMC + '\n');
        XWPFDocument docx = new XWPFDocument();
        if (new File(String.valueOf(pathn1)).exists()) {
            FileInputStream jesus = new FileInputStream(String.valueOf(pathn1));
            docx = new XWPFDocument(jesus);
        }
        XWPFParagraph par = docx.createParagraph();
        XWPFRun run = par.createRun();
        run.setFontSize(12);
        run.setBold(true);
        run.setFontFamily("Arial");
        run.setText("Engine Designation: ");
        run.setTextPosition(15);
        XWPFRun run2 = par.createRun();
        run2.setFontSize(12);
        run2.setBold(true);
        run2.setFontFamily("Arial");
        run2.setText(ENN);
        run2.setTextPosition(15);
        run2.addBreak();
        // -----------------------------------------------------------
        XWPFRun run3 = par.createRun();
        run3.setFontSize(10);
        run3.setBold(true);
        run3.setFontFamily("Arial");
        run3.setText("Fuel Flow Cycle: ");
        XWPFRun run4 = par.createRun();
        run4.setFontSize(10);
        run4.setFontFamily("Arial");
        run4.setText(ECC);
        run4.addBreak();
        // -----------------------------------------------------------
        XWPFRun run5 = par.createRun();
        run5.setFontSize(10);
        run5.setBold(true);
        run5.setFontFamily("Arial");
        run5.setText("Propellant(Remass): ");
        XWPFRun run6 = par.createRun();
        run6.setFontSize(10);
        run6.setFontFamily("Arial");
        run6.setText(PLC);
        run6.addBreak();
        // -----------------------------------------------------------
        XWPFRun run9 = par.createRun();
        run9.setFontSize(10);
        run9.setBold(true);
        run9.setFontFamily("Arial");
        run9.setText("Exhaust Nozzle Geometry: ");
        XWPFRun run0 = par.createRun();
        run0.setFontSize(10);
        run0.setFontFamily("Arial");
        run0.setText(NTLC);
        run0.addBreak();
        // -----------------------------------------------------------
        XWPFRun run104 = par.createRun();
        run104.setFontSize(10);
        run104.setBold(true);
        run104.setFontFamily("Arial");
        run104.setText("Engine Use Case: ");
        XWPFRun run105 = par.createRun();
        run105.setFontSize(10);
        run105.setFontFamily("Arial");
        run105.setText(purpose);
        run105.addBreak();
        // -----------------------------------------------------------
        XWPFRun run10 = par.createRun();
        run10.setFontSize(10);
        run10.setBold(true);
        run10.setFontFamily("Arial");
        run10.setText("Altitude Of Operation: ");
        XWPFRun run23 = par.createRun();
        run23.setFontSize(10);
        run23.setFontFamily("Arial");
        run23.setText(AOOC);
        run23.addBreak();
        // -----------------------------------------------------------
        XWPFRun run13 = par.createRun();
        run13.setFontSize(10);
        run13.setBold(true);
        run13.setFontFamily("Arial");
        run13.setText("Nozzle Cooling Mechanism: ");
        XWPFRun run14 = par.createRun();
        run14.setFontSize(10);
        run14.setFontFamily("Arial");
        run14.setText(CMC);
        run14.addBreak();
        run14.addBreak();
        // -----------------------------------------------------------
        try (FileOutputStream out = new FileOutputStream(String.valueOf(pathn1))) {
            docx.write(out);
        }
    }
    public static void output_ex(String ENN, String ECC, String OCC, String FCC, String AOOC, String NTC, String TRR,
                                 String CMC, boolean isHyp, boolean isCryo, String purpose, String injector) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex.docx");
        System.out.println(lbrk + '\n' + "Engine Designation: " + ENN + '\n');
        System.out.println("Fuel Flow Cycle: " + ECC);
        System.out.println("Engine Oxidizer: " + OCC);
        System.out.println("Engine Fuel: " + FCC);
        String message;
        if (isHyp) {
            message = "Propellant properties: Hypergolic";
        } else {
            message = "Propellant properties: Not Hypergolic";
        }

        if ((isCryo) && (isHyp)) {
            message = message + " and cryogenic";
            System.out.println(message);
        } else if ((isCryo) && (!isHyp)) {
            message = message + " but cryogenic";
            System.out.println(message);
        } else if ((!isCryo) && (isHyp)) {
            message = message + " but not cryogenic";
            System.out.println(message);
        } else {
            message = message + " or cryogenic";
            System.out.println(message);
        }

        String ThrottleRange;
        int uio96 = rN(1, 999);
        int uio97 = rN(1, 11);
        if (uio96 % uio97 == 0) {
            int Throttle_MinV = rN(1, 99);
            int Throttle_MaxV = rN(100, 15);
            ThrottleRange = Throttle_MinV + "-" + Throttle_MaxV + "%";
        } else {
            ThrottleRange = "Not Throttleable";
        }
        int gimbalangle = rN(0, 15);
        String piss;
        if ((!(gimbalangle >= 1)) || AOOC.equals("80 km+ (Vacuum)")) {
            piss = "None";
        } else {
            piss = gimbalangle + " degrees";
        }
        System.out.println("Altitude Of Operation: " + AOOC);
        System.out.println("Exhaust Nozzle Geometry: " + NTC);
        System.out.println("Engine Gimbal Range: " + piss);
        System.out.println("Engine Injector Design: " + injector);
        System.out.println("Engine Use Case: " + purpose);
        System.out.println("Tank repressurisation Method: " + TRR);
        System.out.println("Nozzle Cooling Mechanism: " + CMC);
        System.out.println("Engine Throttle Range: " + ThrottleRange + '\n');

        XWPFDocument docx = new XWPFDocument();
        if (new File(String.valueOf(pathn1)).exists()) {
            FileInputStream jesus = new FileInputStream(String.valueOf(pathn1));
            docx = new XWPFDocument(jesus);
        }
        XWPFParagraph par = docx.createParagraph();
        XWPFRun run = par.createRun();
        run.setFontSize(12);
        run.setBold(true);
        run.setFontFamily("Arial");
        run.setText("Engine Designation: ");
        run.setTextPosition(15);
        XWPFRun run2 = par.createRun();
        run2.setFontSize(12);
        run2.setBold(true);
        run2.setFontFamily("Arial");
        run2.setText(ENN);
        run2.setTextPosition(15);
        run2.addBreak();
        // -----------------------------------------------------------
        XWPFRun run3 = par.createRun();
        run3.setFontSize(10);
        run3.setBold(true);
        run3.setFontFamily("Arial");
        run3.setText("Fuel Flow Cycle: ");
        XWPFRun run4 = par.createRun();
        run4.setFontSize(10);
        run4.setFontFamily("Arial");
        run4.setText(ECC);
        run4.addBreak();
        // -----------------------------------------------------------
        XWPFRun run5 = par.createRun();
        run5.setFontSize(10);
        run5.setBold(true);
        run5.setFontFamily("Arial");
        run5.setText("Engine Oxidizer: ");
        XWPFRun run6 = par.createRun();
        run6.setFontSize(10);
        run6.setFontFamily("Arial");
        run6.setText(OCC);
        run6.addBreak();
        // -----------------------------------------------------------
        XWPFRun run8 = par.createRun();
        run8.setFontSize(10);
        run8.setBold(true);
        run8.setFontFamily("Arial");
        run8.setText("Engine Fuel: ");
        XWPFRun run7 = par.createRun();
        run7.setFontSize(10);
        run7.setFontFamily("Arial");
        run7.setText(FCC);
        run7.addBreak();
        // -----------------------------------------------------------
        XWPFRun run100 = par.createRun();
        run100.setFontSize(10);
        run100.setBold(true);
        run100.setFontFamily("Arial");
        run100.setText(message);
        run100.addBreak();
        // -----------------------------------------------------------
        XWPFRun run9 = par.createRun();
        run9.setFontSize(10);
        run9.setBold(true);
        run9.setFontFamily("Arial");
        run9.setText("Exhaust Nozzle Geometry: ");
        XWPFRun run0 = par.createRun();
        run0.setFontSize(10);
        run0.setFontFamily("Arial");
        run0.setText(NTC);
        run0.addBreak();
        // -----------------------------------------------------------
        XWPFRun run102 = par.createRun();
        run102.setFontSize(10);
        run102.setBold(true);
        run102.setFontFamily("Arial");
        run102.setText("Engine Injector Design: ");
        XWPFRun run103 = par.createRun();
        run103.setFontSize(10);
        run103.setFontFamily("Arial");
        run103.setText(injector);
        run103.addBreak();
        // -----------------------------------------------------------
        XWPFRun run104 = par.createRun();
        run104.setFontSize(10);
        run104.setBold(true);
        run104.setFontFamily("Arial");
        run104.setText("Engine Use Case: ");
        XWPFRun run105 = par.createRun();
        run105.setFontSize(10);
        run105.setFontFamily("Arial");
        run105.setText(purpose);
        run105.addBreak();
        // -----------------------------------------------------------
        XWPFRun run101 = par.createRun();
        run101.setFontSize(10);
        run101.setBold(true);
        run101.setFontFamily("Arial");
        run101.setText("Engine Gimbal Range: ");
        XWPFRun run27 = par.createRun();
        run27.setFontSize(10);
        run27.setFontFamily("Arial");
        run27.setText(gimbalangle + " degrees");
        run27.addBreak();
        // -----------------------------------------------------------
        XWPFRun run10 = par.createRun();
        run10.setFontSize(10);
        run10.setBold(true);
        run10.setFontFamily("Arial");
        run10.setText("Altitude Of Operation: ");
        XWPFRun run23 = par.createRun();
        run23.setFontSize(10);
        run23.setFontFamily("Arial");
        run23.setText(AOOC);
        run23.addBreak();
        // -----------------------------------------------------------
        XWPFRun run11 = par.createRun();
        run11.setFontSize(10);
        run11.setBold(true);
        run11.setFontFamily("Arial");
        run11.setText("Tank repressurisation Method: ");
        XWPFRun run12 = par.createRun();
        run12.setFontSize(10);
        run12.setFontFamily("Arial");
        run12.setText(TRR);
        run12.addBreak();
        // -----------------------------------------------------------
        XWPFRun run13 = par.createRun();
        run13.setFontSize(10);
        run13.setBold(true);
        run13.setFontFamily("Arial");
        run13.setText("Nozzle Cooling Mechanism: ");
        XWPFRun run14 = par.createRun();
        run14.setFontSize(10);
        run14.setFontFamily("Arial");
        run14.setText(CMC);
        run14.addBreak();
        // -----------------------------------------------------------
        XWPFRun run15 = par.createRun();
        run15.setFontSize(10);
        run15.setBold(true);
        run15.setFontFamily("Arial");
        run15.setText("Engine Throttle Range: ");
        XWPFRun run16 = par.createRun();
        run16.setFontSize(10);
        run16.setFontFamily("Arial");
        run16.setText(ThrottleRange);
        run16.addBreak();
        run16.addBreak();
        // -----------------------------------------------------------
        try (FileOutputStream out = new FileOutputStream(String.valueOf(pathn1))) {
            docx.write(out);
        }
    }
    public static void output_nt(String ENN, String ECC, String AOOC, String NCC, String PLC, String RFC, String NTLC,
                                 String TRC, String CMC, String purpose, String react_gen, boolean bimodal, String ERC) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex.docx");
        System.out.println(lbrk + '\n' + "Engine Designation: " + ENN + '\n');
        System.out.println("Fuel Flow Cycle: " + NCC + " " + ECC);
        System.out.println("Propellant (Remass): " + PLC);
        System.out.println("Reactor Fuel: " + RFC);
        System.out.println("Reactor Generation: " + react_gen);
        System.out.println("Reactor Coolant: " + ERC + " - Xe (Xenon)");
        String bimm1, bimm2, oo1, oo2;
        if (!bimodal) {
            bimm1 = "Engine Bimodality: ";
            oo1 = "Engine isn't bimodal";
            bimm2 = "Engine Electrical Output: ";
            oo2 = "NaN";
        } else {
            bimm1 = "Engine Bimodality: ";
            oo1 = "Engine is bimodal";
            bimm2 = "Engine Electrical Output: ";
            double ops = rN(1.5, 100);
            oo2 = String.format("%.1f", ops);
            oo2 = oo2  + " MW";
        }
        System.out.println(bimm1 + oo1);
        System.out.println(bimm2 + oo2);
        System.out.println("Altitude Of Operation: " + AOOC);
        System.out.println("Exhaust Nozzle Geometry: " + NTLC);
        System.out.println("Engine Use Case: " + purpose);
        System.out.println("Tank repressurisation Method: " + TRC);
        System.out.println("Nozzle Cooling Mechanism: " + CMC + '\n');

        XWPFDocument docx = new XWPFDocument();
        if (new File(String.valueOf(pathn1)).exists()) {
            FileInputStream jesus = new FileInputStream(String.valueOf(pathn1));
            docx = new XWPFDocument(jesus);
        }
        XWPFParagraph par = docx.createParagraph();
        XWPFRun run = par.createRun();
        run.setFontSize(12);
        run.setBold(true);
        run.setFontFamily("Arial");
        run.setText("Engine Designation: ");
        run.setTextPosition(15);
        XWPFRun run2 = par.createRun();
        run2.setFontSize(12);
        run2.setBold(true);
        run2.setFontFamily("Arial");
        run2.setText(ENN);
        run2.setTextPosition(15);
        run2.addBreak();
        // -----------------------------------------------------------
        XWPFRun run3 = par.createRun();
        run3.setFontSize(10);
        run3.setBold(true);
        run3.setFontFamily("Arial");
        run3.setText("Fuel Flow Cycle: ");
        XWPFRun run4 = par.createRun();
        run4.setFontSize(10);
        run4.setFontFamily("Arial");
        run4.setText(NCC + " " + ECC);
        run4.addBreak();
        // -----------------------------------------------------------
        XWPFRun run5 = par.createRun();
        run5.setFontSize(10);
        run5.setBold(true);
        run5.setFontFamily("Arial");
        run5.setText("Propellant(Remass): ");
        XWPFRun run6 = par.createRun();
        run6.setFontSize(10);
        run6.setFontFamily("Arial");
        run6.setText(PLC);
        run6.addBreak();
        // -----------------------------------------------------------
        XWPFRun run7 = par.createRun();
        run7.setFontSize(10);
        run7.setBold(true);
        run7.setFontFamily("Arial");
        run7.setText("Reactor Fuel: ");
        XWPFRun run8 = par.createRun();
        run8.setFontSize(10);
        run8.setFontFamily("Arial");
        run8.setText(RFC);
        run8.addBreak();
        // -----------------------------------------------------------
        XWPFRun run767 = par.createRun();
        run767.setFontSize(10);
        run767.setBold(true);
        run767.setFontFamily("Arial");
        run767.setText("Reactor Generation: ");
        XWPFRun run768 = par.createRun();
        run768.setFontSize(10);
        run768.setFontFamily("Arial");
        run768.setText(react_gen);
        run768.addBreak();
        // -----------------------------------------------------------
        XWPFRun run566 = par.createRun();
        run566.setFontSize(10);
        run566.setBold(true);
        run566.setFontFamily("Arial");
        run566.setText("Engine Coolant: ");
        XWPFRun run567 = par.createRun();
        run567.setFontSize(10);
        run567.setFontFamily("Arial");
        run567.setText(ERC + " - Xe (Xenon)");
        run567.addBreak();
        // -----------------------------------------------------------
        XWPFRun run769 = par.createRun();
        run769.setFontSize(10);
        run769.setBold(true);
        run769.setFontFamily("Arial");
        run769.setText(bimm1);
        XWPFRun run770 = par.createRun();
        run770.setFontSize(10);
        run770.setFontFamily("Arial");
        run770.setText(oo1);
        run770.addBreak();
        // -----------------------------------------------------------
        XWPFRun run771 = par.createRun();
        run771.setFontSize(10);
        run771.setBold(true);
        run771.setFontFamily("Arial");
        run771.setText(bimm2);
        XWPFRun run772 = par.createRun();
        run772.setFontSize(10);
        run772.setFontFamily("Arial");
        run772.setText(oo2);
        run772.addBreak();
        // -----------------------------------------------------------
        XWPFRun run9 = par.createRun();
        run9.setFontSize(10);
        run9.setBold(true);
        run9.setFontFamily("Arial");
        run9.setText("Exhaust Nozzle Geometry: ");
        XWPFRun run0 = par.createRun();
        run0.setFontSize(10);
        run0.setFontFamily("Arial");
        run0.setText(NTLC);
        run0.addBreak();
        // -----------------------------------------------------------
        XWPFRun run104 = par.createRun();
        run104.setFontSize(10);
        run104.setBold(true);
        run104.setFontFamily("Arial");
        run104.setText("Engine Use Case: ");
        XWPFRun run105 = par.createRun();
        run105.setFontSize(10);
        run105.setFontFamily("Arial");
        run105.setText(purpose);
        run105.addBreak();
        // -----------------------------------------------------------
        XWPFRun run10 = par.createRun();
        run10.setFontSize(10);
        run10.setBold(true);
        run10.setFontFamily("Arial");
        run10.setText("Altitude Of Operation: ");
        XWPFRun run23 = par.createRun();
        run23.setFontSize(10);
        run23.setFontFamily("Arial");
        run23.setText(AOOC);
        run23.addBreak();
        // ------------------------------------------------------------
        XWPFRun run11 = par.createRun();
        run11.setFontSize(10);
        run11.setBold(true);
        run11.setFontFamily("Arial");
        run11.setText("Tank repressurisation Method: ");
        XWPFRun run12 = par.createRun();
        run12.setFontSize(10);
        run12.setFontFamily("Arial");
        run12.setText(TRC);
        run12.addBreak();
        // -----------------------------------------------------------
        XWPFRun run13 = par.createRun();
        run13.setFontSize(10);
        run13.setBold(true);
        run13.setFontFamily("Arial");
        run13.setText("Nozzle Cooling Mechanism: ");
        XWPFRun run14 = par.createRun();
        run14.setFontSize(10);
        run14.setFontFamily("Arial");
        run14.setText(CMC);
        run14.addBreak();
        run14.addBreak();
        // -----------------------------------------------------------
        try (FileOutputStream out = new FileOutputStream(String.valueOf(pathn1))) {
            docx.write(out);
        }
    }
    public static void output_et(String ENN, String ECC, String AOOC, String PLC, String NTLC, String PGLC, String purpose) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex.docx");
        System.out.println(lbrk + '\n' + "Engine Designation: " + ENN + '\n');
        System.out.println("Fuel Flow Cycle: " + ECC);
        System.out.println("Propellant(Remass): " + PLC);
        System.out.println("Altitude Of Operation: " + AOOC);
        System.out.println("Exhaust Nozzle Geometry: " + NTLC);
        System.out.println("Engine Use Case: " + purpose);
        System.out.println("Engine Power Source: " + PGLC);
        String pwr = (Math.round((float)rN(20, 980)/10))*10 + " kW" + '\n';
        System.out.println("Rated Power Level: " + pwr);

        XWPFDocument docx = new XWPFDocument();
        if (new File(String.valueOf(pathn1)).exists()) {
            FileInputStream jesus = new FileInputStream(String.valueOf(pathn1));
            docx = new XWPFDocument(jesus);
        }
        XWPFParagraph par = docx.createParagraph();
        XWPFRun run = par.createRun();
        run.setFontSize(12);
        run.setBold(true);
        run.setFontFamily("Arial");
        run.setText("Engine Designation: ");
        run.setTextPosition(15);
        XWPFRun run2 = par.createRun();
        run2.setFontSize(12);
        run2.setBold(true);
        run2.setFontFamily("Arial");
        run2.setText(ENN);
        run2.setTextPosition(15);
        run2.addBreak();
        // -----------------------------------------------------------
        XWPFRun run3 = par.createRun();
        run3.setFontSize(10);
        run3.setBold(true);
        run3.setFontFamily("Arial");
        run3.setText("Fuel Flow Cycle: ");
        XWPFRun run4 = par.createRun();
        run4.setFontSize(10);
        run4.setFontFamily("Arial");
        run4.setText(ECC);
        run4.addBreak();
        // -----------------------------------------------------------
        XWPFRun run5 = par.createRun();
        run5.setFontSize(10);
        run5.setBold(true);
        run5.setFontFamily("Arial");
        run5.setText("Propellant(Remass): ");
        XWPFRun run6 = par.createRun();
        run6.setFontSize(10);
        run6.setFontFamily("Arial");
        run6.setText(PLC);
        run6.addBreak();
        // -----------------------------------------------------------
        XWPFRun run9 = par.createRun();
        run9.setFontSize(10);
        run9.setBold(true);
        run9.setFontFamily("Arial");
        run9.setText("Exhaust Nozzle Geometry: ");
        XWPFRun run0 = par.createRun();
        run0.setFontSize(10);
        run0.setFontFamily("Arial");
        run0.setText(NTLC);
        run0.addBreak();
        // -----------------------------------------------------------
        XWPFRun run104 = par.createRun();
        run104.setFontSize(10);
        run104.setBold(true);
        run104.setFontFamily("Arial");
        run104.setText("Engine Use Case: ");
        XWPFRun run105 = par.createRun();
        run105.setFontSize(10);
        run105.setFontFamily("Arial");
        run105.setText(purpose);
        run105.addBreak();
        // -----------------------------------------------------------
        XWPFRun run10 = par.createRun();
        run10.setFontSize(10);
        run10.setBold(true);
        run10.setFontFamily("Arial");
        run10.setText("Altitude Of Operation: ");
        XWPFRun run23 = par.createRun();
        run23.setFontSize(10);
        run23.setFontFamily("Arial");
        run23.setText(AOOC);
        run23.addBreak();
        // -----------------------------------------------------------
        XWPFRun run11 = par.createRun();
        run11.setFontSize(10);
        run11.setBold(true);
        run11.setFontFamily("Arial");
        run11.setText("Engine Power Source: ");
        XWPFRun run12 = par.createRun();
        run12.setFontSize(10);
        run12.setFontFamily("Arial");
        run12.setText(PGLC);
        run12.addBreak();
        // -----------------------------------------------------------
        XWPFRun run13 = par.createRun();
        run13.setFontSize(10);
        run13.setBold(true);
        run13.setFontFamily("Arial");
        run13.setText("Rated Power Level: ");
        XWPFRun run14 = par.createRun();
        run14.setFontSize(10);
        run14.setFontFamily("Arial");
        run14.setText(pwr);
        run14.addBreak();
        run14.addBreak();
        // -----------------------------------------------------------
        try (FileOutputStream out = new FileOutputStream(String.valueOf(pathn1))) {
            docx.write(out);
        }
    }
    public static void output_def(String ENN, String ECC, String OCC, String FCC, String AOOC, String NTC, String TRC, String CMC,
                                  boolean isHyp, boolean isCryo, String purpose, String injector) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex.docx");
        System.out.println(lbrk + '\n' + "Engine Designation: " + ENN + '\n');
        System.out.println("Fuel Flow Cycle: " + ECC);
        System.out.println("Engine Oxidizer: " + OCC);
        System.out.println("Engine Fuel: " + FCC);
        String message;
        if (isHyp) {
            message = "Propellant properties: Hypergolic";
        } else {
            message = "Propellant properties: Not Hypergolic";
        }

        if ((isCryo) && (isHyp)) {
            message = message + " and cryogenic";
            System.out.println(message);
        } else if ((isCryo) && (!isHyp)) {
            message = message + " but cryogenic";
            System.out.println(message);
        } else if ((!isCryo) && (isHyp)) {
            message = message + " but not cryogenic";
            System.out.println(message);
        } else {
            message = message + " or cryogenic";
            System.out.println(message);
        }
        String ThrottleRange;
        int uio96 = rN(1, 999);
        int uio97 = rN(1, 11);
        if (uio96 % uio97 == 0) {
            int Throttle_MinV = rN(1, 99);
            int Throttle_MaxV = rN(100, 15);
            ThrottleRange = Throttle_MinV + "-" + Throttle_MaxV + "%";
        } else {
            ThrottleRange = "Not Throttleable";
        }
        int gimbalangle = rN(0, 15);
        String piss;
        if ((!(gimbalangle >= 1)) || AOOC.equals("80 km+ (Vacuum)")) {
            piss = "None";
        } else {
            piss = gimbalangle + " degrees";
        }
        System.out.println("Altitude Of Operation: " + AOOC);
        System.out.println("Exhaust Nozzle Geometry: " + NTC);
        System.out.println("Engine Gimbal Range: " + piss);
        System.out.println("Engine Injector Design: " + injector);
        System.out.println("Engine Use Case: " + purpose);
        System.out.println("Tank repressurisation Method: " + TRC);
        System.out.println("Nozzle Cooling Mechanism: " + CMC);
        System.out.println("Engine Throttle Range: " + ThrottleRange + '\n');

        XWPFDocument docx = new XWPFDocument();
        if (new File(String.valueOf(pathn1)).exists()) {
            docx = new XWPFDocument(new FileInputStream(String.valueOf(pathn1)));
        }
        XWPFParagraph par = docx.createParagraph();
        XWPFRun run = par.createRun();
        run.setFontSize(12);
        run.setBold(true);
        run.setFontFamily("Arial");
        run.setText("Engine Designation: ");
        run.setTextPosition(15);
        XWPFRun run2 = par.createRun();
        run2.setFontSize(12);
        run2.setBold(true);
        run2.setFontFamily("Arial");
        run2.setText(ENN);
        run2.setTextPosition(15);
        run2.addBreak();
        // -----------------------------------------------------------
        XWPFRun run3 = par.createRun();
        run3.setFontSize(10);
        run3.setBold(true);
        run3.setFontFamily("Arial");
        run3.setText("Fuel Flow Cycle: ");
        XWPFRun run4 = par.createRun();
        run4.setFontSize(10);
        run4.setFontFamily("Arial");
        run4.setText(ECC);
        run4.addBreak();
        // -----------------------------------------------------------
        XWPFRun run5 = par.createRun();
        run5.setFontSize(10);
        run5.setBold(true);
        run5.setFontFamily("Arial");
        run5.setText("Engine Oxidizer: ");
        XWPFRun run6 = par.createRun();
        run6.setFontSize(10);
        run6.setFontFamily("Arial");
        run6.setText(OCC);
        run6.addBreak();
        // -----------------------------------------------------------
        XWPFRun run8 = par.createRun();
        run8.setFontSize(10);
        run8.setBold(true);
        run8.setFontFamily("Arial");
        run8.setText("Engine Fuel: ");
        XWPFRun run7 = par.createRun();
        run7.setFontSize(10);
        run7.setFontFamily("Arial");
        run7.setText(FCC);
        run7.addBreak();
        // -----------------------------------------------------------
        XWPFRun run100 = par.createRun();
        run100.setFontSize(10);
        run100.setBold(true);
        run100.setFontFamily("Arial");
        run100.setText(message);
        run100.addBreak();
        // -----------------------------------------------------------
        XWPFRun run9 = par.createRun();
        run9.setFontSize(10);
        run9.setBold(true);
        run9.setFontFamily("Arial");
        run9.setText("Exhaust Nozzle Geometry: ");
        XWPFRun run0 = par.createRun();
        run0.setFontSize(10);
        run0.setFontFamily("Arial");
        run0.setText(NTC);
        run0.addBreak();
        // -----------------------------------------------------------
        XWPFRun run101 = par.createRun();
        run101.setFontSize(10);
        run101.setBold(true);
        run101.setFontFamily("Arial");
        run101.setText("Engine Gimbal Range: ");
        XWPFRun run27 = par.createRun();
        run27.setFontSize(10);
        run27.setFontFamily("Arial");
        run27.setText(piss);
        run27.addBreak();
        // -----------------------------------------------------------
        XWPFRun run102 = par.createRun();
        run102.setFontSize(10);
        run102.setBold(true);
        run102.setFontFamily("Arial");
        run102.setText("Engine Injector Design: ");
        XWPFRun run103 = par.createRun();
        run103.setFontSize(10);
        run103.setFontFamily("Arial");
        run103.setText(injector);
        run103.addBreak();
        // -----------------------------------------------------------
        XWPFRun run104 = par.createRun();
        run104.setFontSize(10);
        run104.setBold(true);
        run104.setFontFamily("Arial");
        run104.setText("Engine Use Case: ");
        XWPFRun run105 = par.createRun();
        run105.setFontSize(10);
        run105.setFontFamily("Arial");
        run105.setText(purpose);
        run105.addBreak();
        // -----------------------------------------------------------
        XWPFRun run10 = par.createRun();
        run10.setFontSize(10);
        run10.setBold(true);
        run10.setFontFamily("Arial");
        run10.setText("Altitude Of Operation: ");
        XWPFRun run23 = par.createRun();
        run23.setFontSize(10);
        run23.setFontFamily("Arial");
        run23.setText(AOOC);
        run23.addBreak();
        // -----------------------------------------------------------
        XWPFRun run11 = par.createRun();
        run11.setFontSize(10);
        run11.setBold(true);
        run11.setFontFamily("Arial");
        run11.setText("Tank repressurisation Method: ");
        XWPFRun run12 = par.createRun();
        run12.setFontSize(10);
        run12.setFontFamily("Arial");
        run12.setText(TRC);
        run12.addBreak();
        // -----------------------------------------------------------
        XWPFRun run13 = par.createRun();
        run13.setFontSize(10);
        run13.setBold(true);
        run13.setFontFamily("Arial");
        run13.setText("Nozzle Cooling Mechanism: ");
        XWPFRun run14 = par.createRun();
        run14.setFontSize(10);
        run14.setFontFamily("Arial");
        run14.setText(CMC);
        run14.addBreak();
        // -----------------------------------------------------------
        XWPFRun run15 = par.createRun();
        run15.setFontSize(10);
        run15.setBold(true);
        run15.setFontFamily("Arial");
        run15.setText("Engine Throttle Range: ");
        XWPFRun run16 = par.createRun();
        run16.setFontSize(10);
        run16.setFontFamily("Arial");
        run16.setText(ThrottleRange);
        run16.addBreak();
        run16.addBreak();
        // -----------------------------------------------------------
        try (FileOutputStream out = new FileOutputStream(String.valueOf(pathn1))) {
            docx.write(out);
        }
    }
    public static boolean isHypergolic (String OCC, String FCC) {
        boolean isHypergolic = false;
        switch (OCC) {
            case "N2O4 (Nitrogen Tetroxide)" -> {
                switch (FCC) {
                    case "50% CH6N2 + 50% N2H4 (Aerosine-50)", "75% CH6N2 + 25% N2H4 (UH-25)", "C6H5NH2 (Aniline)" ,
                            "C2H8N2 (UnsymmetricalDimethylHydrazine)", "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)" ->{
                        isHypergolic = true;
                    } default -> {
                        isHypergolic = false;
                    }
                }
            } case "H2O2 (Hydrogen Peroxide) 95%", "H2O2 (Hydrogen Peroxide) 85%", "O2 (Oxygen)" -> {
                isHypergolic = false;
            } case "O3 (Ozone)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)", "ClF3 (Chlorine Trifluoride)", "ClF5 (Chlorine Pentafluoride)" -> {
                isHypergolic = true;
            } case "AK20F: 80% HNO3 + 20% N2O4 (Nitric Acid)", "AK20I: 80% HNO3 + 20% N2O4 (Nitric Acid)",
                    "AK20K: 80% HNO3 + 20% N2O4 (Nitric Acid)", "AK27I: 73% HNO3 + 27% N2O4 (Nitric Acid)",
                    "AK27P: 73% HNO3 + 27% N2O4 (Nitric Acid)" -> {
                switch (FCC) {
                    case "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)" ->{
                        isHypergolic = true;
                    } default -> {
                        isHypergolic = false;
                    }
                }
            }
        }
        return isHypergolic;
    }
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        File org = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData");
        org.mkdir();
        // -------------------------------------
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex.docx");
        if (!(new File(String.valueOf(pathn1)).exists())) {
            XWPFDocument docx1 = new XWPFDocument();
            XWPFParagraph par1 = docx1.createParagraph();
            par1.setAlignment(ParagraphAlignment.CENTER);
            XWPFRun run1 = par1.createRun();
            run1.setText("Rocket Engine Registry");
            run1.setFontFamily("Arial");
            run1.setBold(true);
            run1.setFontSize(33);
            run1.setTextPosition(60);
            // -----------------------------------------------------------------------------
            XWPFParagraph par2 = docx1.createParagraph();
            par2.setAlignment(ParagraphAlignment.RIGHT);
            XWPFRun run2 = par2.createRun();
            LocalDateTime date = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd MMM yyyy, HH:mm:ss");
            String dt = date.format(formatter);
            run2.setText("Created on: " + dt);
            run2.setFontFamily("Arial");
            run2.setBold(true);
            run2.setFontSize(10);
            run2.setTextPosition(75);
            // ----------------------------------------------------------------------------------------------------
            try (FileOutputStream out1 = new FileOutputStream(String.valueOf(pathn1))) {
                docx1.write(out1);
                out1.close();
                docx1.close();
            }
        }
        File ops = new File("C:\\Users\\Public\\Operational_Functional_Block\\Java_projects\\src\\DevData");
        ops.mkdir();
        System.out.println("Welcome to the Advanced Rocket Engine Generator!" + '\n');
        Scanner scanner = new Scanner(System.in);
        String repeatCommand = "y";
        int y = 0, h = 0;
        ArrayList<Double> yi = new ArrayList<>(100);
        while (!repeatCommand.equals("N")) {
            int am = 500;
            boolean test = true;
            if (test) {
                if ((new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex[Full]" + am + ".docx")).exists()) repeatCommand = "N";
            } else{
                System.out.println("Do you want to generate a new engine? [Y/N]");
                System.out.print("> ");
                repeatCommand = scanner.next();
            }
            Path onlyfans = Path.of(String.valueOf(pathn1));
            if (repeatCommand.equalsIgnoreCase("N") || repeatCommand.equalsIgnoreCase("NO")) {
                float sum = 0;
                for (int u = 0; u < (yi.size() - 1); u++) sum = (float) (sum + yi.get(u));
                long end = System.currentTimeMillis();
                float timen = (float)(end - start)/1000;
                int r = yi.size();
                String fugg = "Number of files created: " + am;
                String piss;
                if (r <= 1) {
                    piss = '\n' + "Average amount of bytes per engine: " + (pathn1.length()/y) + " bytes";
                    System.out.println(piss);
                } else {
                    piss = '\n' + "Average amount of bytes per engine: " + (sum / yi.size()) + " bytes";
                    System.out.println(piss);
                }
                String pussay = "Average amount of engines per file: " + sum + " engines";
                System.out.println(pussay);
                String hamstrings;
                if (timen < 60) {
                    hamstrings = "Total run time: " + timen + " secs";
                    System.out.println(hamstrings);
                } else if (timen/60 < 2) {
                    hamstrings = "Total run time: " + (int)Math.floor(timen/60) + " min " + Math.round(timen%60) + " secs";
                    System.out.println(hamstrings);
                } else {
                    hamstrings = "Total run time: " + (int)Math.floor(timen/60) + " mins " + Math.round(timen%60) + " secs";
                    System.out.println(hamstrings);
                }
                String shoe = "Rate of engine generation: " + h/timen + " engines/second";
                System.out.println(shoe);
                String back = "Number of engines generated: " + h;
                System.out.println(back);
                try {
                    FileWriter fwrite = new FileWriter("C:\\Users\\Public\\Operational_Functional_Block\\Java_projects\\src\\DevData\\dev.txt", true);
                    BufferedWriter fwriteFinal = new BufferedWriter(fwrite);
                    fwriteFinal.write("===========================================================================");
                    fwriteFinal.write('\n');
                    fwriteFinal.write(fugg);
                    fwriteFinal.write('\n');
                    fwriteFinal.write(piss);
                    fwriteFinal.write('\n');
                    fwriteFinal.write(pussay);
                    fwriteFinal.write('\n');
                    fwriteFinal.write(hamstrings);
                    fwriteFinal.write('\n');
                    fwriteFinal.write(shoe);
                    fwriteFinal.write('\n');
                    fwriteFinal.write(back);
                    fwriteFinal.write('\n' + '\n');
                    fwriteFinal.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                System.exit(0);
            } else if (repeatCommand.equalsIgnoreCase("Y") || repeatCommand.equalsIgnoreCase("YES")) {
                double sizeInbytes = pathn1.length();
                double sizeInKilobytes = (sizeInbytes / 1024);
                if (sizeInKilobytes >= 20) {
                    yi.add(sizeInbytes/y);
                    File logM = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData");
                    logM.mkdir();
                    // -------------------------------------------------------------------------------------------------
                    if ((new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex[Full].docx")).exists()) {
                        int i;
                        y = 0;
                        int x = 2;
                        for (i = 1; i < x; i++) {
                            if ((new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex[Full]" + i + ".docx")).exists()) {
                                x++;
                            } else {
                                Files.copy(onlyfans, Paths.get("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex[Full]" + i + ".docx"));
                            }
                        }
                    } else {
                        Path logPF = Paths.get("C:/Users/Public/Operational_Functional_Block/Java_projects/src/DevData/ofb_rex[Full].docx");
                        Files.copy(onlyfans, logPF);
                    }
                    XWPFDocument docx1 = new XWPFDocument();
                    XWPFParagraph par1 = docx1.createParagraph();
                    par1.setAlignment(ParagraphAlignment.CENTER);
                    XWPFRun run1 = par1.createRun();
                    run1.setText("Rocket Engine Generator");
                    run1.setFontFamily("Arial");
                    run1.setBold(true);
                    run1.setFontSize(33);
                    run1.setTextPosition(60);
                    // -----------------------------------------------------------------------------
                    XWPFParagraph par2 = docx1.createParagraph();
                    par2.setAlignment(ParagraphAlignment.RIGHT);
                    XWPFRun run2 = par2.createRun();
                    LocalDateTime date = LocalDateTime.now();
                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd MMM yyyy, HH:mm:ss");
                    String dt = date.format(formatter);
                    run2.setText("Created on: " + dt);
                    run2.setFontFamily("Arial");
                    run2.setBold(true);
                    run2.setFontSize(10);
                    run2.setTextPosition(60);
                    // ----------------------------------------------------------------------------------------------------
                    FileOutputStream out1 = new FileOutputStream(String.valueOf(pathn1));
                    docx1.write(out1);
                    out1.close();
                    docx1.close();
                }
                String[] engine_Name1 = {"\"Argosy\"", "\"Galileo\"", "\"Callisto\"", "\"Nauka\"", "\"Insider\"", "\"Granis\"",
                        "\"Rassvet\"", "\"Zvezda\"", "\"Zarya\"", "\"Orion\"", "\"Ares\"", "\"Delta\"", "\"Atlas\"", "\"Dreadnought\"",
                        "\"Daedalus\"", "\"Baltia\"", "\"Dizhou\"", "\"Hermes\"", "\"Icarus\"", "\"Connestoga\"", "\"Yupiter\"",
                        "\"Emphasis\"", "\"Olympus\"", "\"Kronos\"", "\"Helios\"", "\"Alabaster\"", "\"Falcon\"", "\"Saturn\"",
                        "\"Eagle\"", "\"Endeavour\"", "\"Atlantis\"", "\"Cygnus\"", "\"Apollo\"", "\"Horizon\"", "\"Bulava\"",
                        "\"Pioneer\"", "\"Voyager\"", "\"Exploration\"", "\"Expedition\"", "\"Vulcan\"", "\"Vysota\"",
                        "\"Federation\"", "\"Sojourner\"", "\"Nautilus\"", "\"Jubilance\"", "\"Lagrange\"",  "\"Volna\"",
                        "\"Prometheus\"", "\"Tellus\"", "\"Alpha\"", "\"Delta\"", "\"Proton\"", "\"Neutron\"", "\"Topol\"",
                        "\"Electron\"", "\"Pluton\"", "\"Poodle\"", "\"Skipper\"", "\"Convair\"", "\"Nexus\"", "\"Oko\"",
                        "\"Vector\"", "\"Terrier\"", "\"Rhino\"", "\"Panther\"", "\"Goliath\"", "\"Juno\"", "\"Shrimp\"",
                        "\"Thumper\"", "\"Mainsail\"", "\"Dart\"", "\"Twitch\"", "\"Stratus\"", "\"Oscar\"", "\"Kosmos\"",
                        "\"Sentinel\"", "\"Pegasus\"", "\"Kelus\"", "\"Starshot\"", "\"Vernor\"", "\"Mammoth\"", "\"Liberty\"",
                        "\"Douglas\"", "\"Heimdall\"", "\"Dynetics\"", "\"Pathfinder\"", "\"Horizon\"", "\"Poisk\"",
                        "\"Pirs\"", "\"Philae\"", "\"Mariner\"", "\"Centaur\"", "\"Orel\"", "\"Pratt\"", "\"Hyperion\"",
                        "\"Sagittarius\"", "\"Apollo\"", "\"Bryton\"", "\"Volga\"", "\"Harmony\"", "\"Cassini\"", "\"Contour\"",
                        "\"Altair\"", "\"Dream\"", "\"Baikal\"", "\"Zenith\"", "\"Urpinod\"", "\"Bernal\"", "\"Condor\"",
                        "\"Athena\"", "\"Astra\"", "\"Aerolus\"", "\"Rombus\"", "\"Lunokhod\"", "\"Fregat\"", "\"Glonass\"",
                        "\"Dragon\"", "\"Salyut\"", "\"Starliner\"", "\"Skylab\"", "\"Briz\"", "\"Colombus\"", "\"Rosetta\"",
                        "\"Redstone\"", "\"Antares\"", "\"Philae\"", "\"Prospero\"", "\"Leonardo\"", "\"Parker\"", "\"Dyson\"",
                        "\"Oberon\"", "\"DragonFly\"", "\"Energia\"", "\"Buran\"", "\"Urgan\"", "\"Angara\"", "\"Vostok\"",
                        "\"Voskhod\"", "\"Shenzhou\"", "\"Ingenuity\"", "\"Oberon\"", "\"Discovery\"", "\"Horizon\"", "\"Visionalis\"",
                        "\"Cerasus\"", "\"Progress\"", "\"Unity\"", "\"Surveyor\"", "\"Prospector\"", "\"Ikar\"", "\"Redstone\"",
                        "\"Lapis\"", "\"Caesius\"", "\"Iridium\"", "\"Daedlus\"", "\"Aelita\"", "\"Beta\"", "\"Gamma\"",
                        "\"Alpha\"", "\"Epsilon\"", "\"Omega\"", "\"Discoverer\"", "\"Explorer\"", "\"Hornet\"", "\"Serenity\"",
                        "\"Ariane\"", "\"Hornet\"", "\"Asimov\"", "\"Pegasus\"", "\"Venture\"", "\"Antares\"", "\"Star\"",
                        "\"Archimedes\"", "\"Hera\"", "\"Iris\"", "\"Titan\"", "\"Artemis\"", "\"Phoenix\"", "\"Ross\"",
                        "\"Sarychev\"", "\"Nemesis\"", "\"Heimdall\"", "\"Sturt\"", "\"Odin\"", "\"Aethelred\"", "\"Vesper\"",
                        "\"Aces\"", "\"Argon\"", "\"Olympia\"", "\"Perseus\"", "\"Chyron\"", "\"Proxima\"", "\"Arminus\"",
                        "\"Destiny\"", "\"Valient\"", "\"FireFly\"", "\"Obsidian\"", "\"Leviathan\"", "\"Magellan\"", "\"Voyager\"",
                        "\"Mariner\"", "\"Joist\"", "\"Crimson\"", "\"Fortune\"", "\"Vanguard\"", "\"Aurora\"", "\"Ulysses\"",
                        "\"Crusader\"", "\"Python\"", "\"Kuiper\"", "\"Insurgent\"", "\"Pathfinder\"", "\"Kvant\"", "\"Spektr\"",
                        "\"Cassini\"", "\"Zemlya\"", "\"Dawn\"", "\"Kepler\"", "\"Parom\"", "\"Elektron\"", "\"Aeonian\"",
                        "\"Node\"", "\"Burya\"", "\"Voyager\"", "\"Ceres\"", "\"Bayern\"", "\"Chasovoy\"", "\"Copernicus\"",
                        "\"Quaoar\"", "\"Minotaur\"", "\"Agena\"", "\"Thor\"", "\"Vega\"", "\"Scout\"", "\"Coeus\"", "\"Minerva\"",
                        "\"Kratos\"", "\"Neith\"", "\"Omoikane\"", "\"Gayamun\"", "\"Odin\"", "\"Kronos\"", "\"Hope\"", "\"Polet\"",
                        "\"Polyot\"", "\"Sputnik\"", "\"Clementine\"", "\"Sojourner\"", "\"Ingenuity\"", "\"Perseverence\"",
                        "\"Onatchesko\"", "\"Atlantis\"", "\"Tsyklon\"", "\"Zenit\"", "\"Almaz\"", "\"Soyuz\"", "\"Molniya\"",
                        "\"Oreol\"", "\"Yantar\"", "\"Foton\"", "\"Meteor\"", "\"Ekran\"", "\"Strela\"", "\"Bion\"", "\"Piroda\"",
                        "\"Salyut\"", "\"Strela\"", "\"Luch\"", "\"Potok\"", "\"Prognoz\"", "\"Orlets\"", "\"Etalon\"", "\"Astron\"",
                        "\"Efir\"", "\"Kometa\"", "\"Fram\"", "\"Zemlya\"", "\"Gorizont\"", "\"Arkon\"", "\"Gamma\"", "\"Ekspress\"",
                        "\"Gonets\"", "\"Taifun\"", "\"Okean\"", "\"Reflektor\"", "\"Kolibr\"", "\"Sever\"", "\"Comet\"",
                        "\"Roton\"", "\"Solaris\"", "\"Altaris\"", "\"Ithacus\"", "\"Dekto\"", "\"Dream\"", "\"Impuls\"",
                        "\"Vremya\"", "\"Portal\"", "\"Zodiak\"", "\"Slava\"", "\"Inertsiya\"", "\"Stimuls\"", "\"Ambross\"",
                        "\"Amal\"", "\"Thea\"", "\"Orphelia\"", "\"Polyot\"", "\"Mudrost\"", "\"Carrack\"", "\"Artak\"",
                        "\"Questar\"", "\"Artyom\"", "\"Tsyclon\"", "\"Ascension\"", "\"Tenacity\"", "\"Contour\"", "\"Zephyr\"",
                        "\"Atlanta\"", "\"Polaris\"", "\"Aeolus\"", "\"Mayak\"", "\"Pamir\"", "\"Taimyr\"", "\"Cheget\"", "\"Sirius\"",
                        "\"Uragan\"", "\"Agat\"", "\"Skiph\"", "\"Kristall\"", "\"Altair\"", "\"Uran\"", "\"Ingul\"", "\"Carat\"",
                        "\"Pulsar\"", "\"Titan\"", "\"Eridanus\"", "\"Parus\"", "\"Cepheus\"", "\"Varagian\"", "\"Olympus\"",
                        "\"Tarkhaniy\"", "\"Astraeus\"", "\"Antares\"", "\"Kazbek\"", "\"Burlak\"", "\"Borei\"", "\"Favor\"",
                        "\"Rubin\"", "\"Almaz\"", "\"Granit\"", "\"Ruby\"", "\"Sokol\"", "\"Argon\"", "\"Kavkaz\"", "\"Ural\"",
                        "\"Berkut\"", "\"Dunay\"", "\"Yastreb\"", "\"Terek\"", "\"Radon\"", "\"Taymyr\"", "\"Pamir\"", "\"Photon\"",
                        "\"Elbrus\"", "\"Isayiev\"", "\"Shmel\"", "\"Kobra\"", "\"Shturn\"", "\"Metis\"", "\"Malyutka\"", "\"Fleyta\"",
                        "\"Konkurs\"", "\"Bastion\"", "\"Svir\"", "\"Ataka\"", "\"Vodopad\"", "\"Veter\"", "\"Vyuga\"", "\"Vulga\"",
                        "\"Tochka\"", "\"Oka\"", "\"Dvina\"", "\"Almaz\"", "\"Araks\"", "\"Kanopus\"", "\"Kliper\"", "\"Kobalt\"",
                        "\"Siluet\"", "\"Kondor\"", "\"Lotos\"", "\"Luch\"", "\"Mir\"", "\"Neman\"", "\"Obzor\"", "\"Okean\"",
                        "\"Oktan\"", "\"Orlets\"", "\"Poisk\"", "\"Potok\"", "\"Pirs\"", "\"Prognoz\"", "\"Resurs\"", "\"Rodnik\"",
                        "\"Romb\"", "\"Kapustin\"", "\"Oplot\"", "\"Tsygan\"", "\"Teplokhod\"", "\"Sokosha\"", "\"Rubezh\"",
                        "\"Zircon\"", "\"Moskva\"", "\"Tryol\"", "\"Ustinov\"", "\"Belyayev\"", "\"Novorod\"", "\"Argos\"",
                        "\"Nerthus\"", "\"Janus\"", "\"Hephaestus\"", "\"Themis\"", "\"Chronos\"", "\"Tethys\"", "\"Minos\"",
                        "\"Autumn\"", "\"Resilience\"", "\"Aelita\"", "\"Rheus\"", "\"Solntspek\"", "\"Spitzer\"", "\"Cartago\"",
                        "\"Melibea\"", "\"Spartacus\"", "\"Pulsar\"", "\"Fusion\"", "\"Reliant\"", "\"Thunder\"", "\"Novo\"",
                        "\"Panthera\"", "\"Nematoda\"", "\"Anelida\"", "\"Chordata\"", "\"Tetrapoda\"", "\"Cyclero\"", "\"Carrier\"",
                        "\"Gaia\"", "\"Irtysh\"", "\"Wyvern\"", "\"Tarsier\"", "\"Alpina\"", "\"Espadon\"", "\"Parlos\"", "\"Nebula\"",
                        "\"Lazarus\"", "\"Rufus\"", "\"Dornier\"", "\"Argus\"", "\"Kybau\"", "\"Kalau\"", "\"Chasvoy\"", "\"Zephyr\"",
                        "\"Temny\"", "\"Gorizont\"", "\"Yars\"", "\"Krugazor\"", "\"Soprotivlenye\"", "\"Shtil\"", "\"Layner\"",
                        "\"Arthropoda\"", "\"Hexapoda\"", "\"Crustacea\"", "\"Tardigrada\"", "\"Mollusca\"", "\"Annelida\"",
                        "\"Bryozoa\"", "\"Rotifera", "\"Brachiopoda\"", "\"Echinodermata\"", "\"Hemichordata\"", "\"Cnidaria\"",
                        "\"Staurozoa\"", "\"Hydrozoa\"", "\"Porifera", "\"Placozoa\"", "\"Craniata\"", "\"Tunicata\"", "\"Conodonta\"",
                        "\"Tetrapoda\"", "\"Amniota\"", "\"Synapsida\"", "\"Sauropsida", "\"Mammalia\"", "\"Sarcodina\"", "\"Aspin\"",
                        "\"Sporozoa\"", "\"Ciliata\"", "\"Filosa\"", "\"Toxoplasma\"", "\"Plasmodium\"", "\"Cryptomonada",
                        "\"Heterokonta\"", "\"Haptophyta\"", "\"Cercozoa\"", "\"Heliozoa\"", "\"Anapsida\"", "\"Aves\"", "\"Peewee\""};
                String[] engine_Cycle = {"Gas Generator", "Staged Combustion (Oxidizer Rich)", "Staged Combustion (Fuel Rich)",
                        "Expander (Open/Bleed)", "Expander (Closed)", "Dual Expander (Open/Bleed)", "Dual Expander (Closed)",
                        "Pressure-Fed", "Full Flow Staged", "Electric Pump Fed", "Combustion Tap Off", "Monopropellant (Cold Gas)",
                        "Monopropellant (Decomposition)", "Gas Core", "Liquid Core", "Solid Core", "Pulsed Nuclear", "Pebble-Bed Core",
                        "Nuclear SaltWater", "MagnetoPlasmaDynamic Thruster", "Hall Effect Thruster", "Gridded Ion Thruster",
                        "Colloid Thruster", "Variable Specific Impulse Magnetoplasma Rocket (VASIMR)"};
                String[] propellant_List1 = {"H2O2 (Hydrogen Peroxide)", "N2H4 (Hydrazine)", "NH2OH+NO3 (Hydroxylammonium nitrate)",
                        "65% NH4N(NO2)2 (Ammonium Dinitramide) + 35% CH3OH(Methanol)"};
                String[] propellant_List2 = {"Nitrogen (N2)", "Helium (He)", "Carbon Dioxide (CO2)", "Ammonia (NH3)", "Hydrogen (H2)",
                        "Methane (CH4)"};
                String[] propellant_List3 = {"Hydrogen (H2)", "Helium (He)", "Nitrogen (N2)", "Hydrogen (H)", "Ammonia (NH3)",
                        "Water (H2O)", "Oxygen (O2)", "Carbon Dioxide (CO2)", "Carbon Monoxide (CO)", "Methane (CH4)"};
                String[] altitude_Of_Operation = {"0-10 km (Sea Level)", "20-30 km (Medium Atmosphere)", "30-80 km (High Atmosphere)",
                        "80 km+ (Vacuum)", "Any Altitude (0-80 km+)"};
                String[] tank_Repressurisation = {"Autogenous", "Inert Gas"};
                String[] firstPart = {"RD", "RS", "AJ", "XLR", "NK", "RL", "KDTU", "AR", "BE", "MV", "YF", "PKA", "J", "RSA",
                        "MJ", "XS", "LM10", "HM", "LE", "LRE", "CE", "DST", "DOK", "KDU", "KRD", "R", "RO", "LMS", "LMP", "RT",
                        "F", "E", "A", "B", "S.10", "R", "JDK", "SPP", "TYS", "SOK", "RES", "FWR", "NAA75", "LR", "MA", "GE",
                        "OSA", "OBA", "NA", "RM02", "RM", "H", "MBB", "MB", "DF", "DE", "BF", "X", "BW", "BADR", "HS", "DC",
                        "UA", "FG", "P", "KMV", "M", "SRMU", "V", "KVD", "JD", "PS", "CE"};
                String engine_Name = ass_crack(engine_Name1, firstPart);
                String engine_Cycle_Chosen = rand(engine_Cycle);
                switch (engine_Cycle_Chosen) {
                    case "Gas Core", "Liquid Core", "Solid Core", "Pulsed Nuclear", "Nuclear SaltWater", "Pebble-Bed Core" -> {
                        String propellant_List_Chosen = "", nuclear_Cycle_Chosen, reactor_Fuel_Chosen, nozzle_Type_List_Chosen, remass_List_Chosen;
                        switch (engine_Cycle_Chosen) {
                            case "Gas Core" -> {
                                String[] remass_List = {"Hydrogen (H2)", "Nitrogen (N2)", "Monoatomic Hydrogen (H)", "Ammonia (NH3)",
                                        "Water (H2O)", "Oxygen (O2)", "Carbon Dioxide (CO2)", "Carbon Monoxide (CO)",
                                        "Methane (CH4)"};
                                String[] nuclear_cycle = {"\"Expander Bleed\"", "\"Expander Closed\"", "\"Nuclear Lightbulb\"", "\"Vortex Confined\"",
                                        "\"Wheel Flow\"", "\"Magnetohydrodynamic(MHD) vortex\"", "\"Expander Open\""};
                                remass_List_Chosen = rand(remass_List);
                                propellant_List_Chosen = "Uranium HexaFluoride Salt (UF6) and " + remass_List_Chosen + " as remass";
                                nuclear_Cycle_Chosen = rand(nuclear_cycle);
                                reactor_Fuel_Chosen = "100-90% Uranium-235";
                                nozzle_Type_List_Chosen = "De Laval Bell (With Nozzle Extension)";
                            } case "Liquid Core", "Colloid-Core", "Pebble-Bed Core" -> {
                                String[] nuclear_cycle = {"\"Expander Bleed\"", "\"Expander Closed\"", "\"Vortex Confined\"", "\"Expander Open\""};
                                String[] remass_List = {"Hydrogen (H2)", "Nitrogen (N2)", "Monoatomic Hydrogen (H)", "Ammonia (NH3)",
                                        "Water (H2O)", "Oxygen (O2)", "Carbon Dioxide (CO2)", "Carbon Monoxide (CO)", "Methane (CH4)"};
                                String[] reactor_fuel = {"100-90% Uranium-235", "80-50% Uranium-235", "25-8% Uranium-235"};
                                remass_List_Chosen = rand(remass_List);
                                propellant_List_Chosen = "Uranium HexaFluoride Salt (UF6) and " + remass_List_Chosen + " as a remass";
                                nuclear_Cycle_Chosen = rand(nuclear_cycle);
                                reactor_Fuel_Chosen = rand(reactor_fuel);
                                nozzle_Type_List_Chosen = "De Laval Bell (With Nozzle Extension)";
                            } case "Nuclear SaltWater" -> {
                                String[] reactor_fuel = {"100-90% Uranium-235", "80-50% Uranium-235", "25-8% Uranium-235"};
                                propellant_List_Chosen = "Uranium TetraBromide (UBr4) + Water (H2O)";
                                remass_List_Chosen = "Water (H2O)";
                                nuclear_Cycle_Chosen = "";
                                reactor_Fuel_Chosen = rand(reactor_fuel);
                                nozzle_Type_List_Chosen = "De Laval Bell (With Nozzle Extension)";
                            } default -> {
                                remass_List_Chosen = rand(propellant_List3);
                                String[] nuclear_cycle = {"\"Expander Bleed\"", "\"Expander Closed\"", "\"Expander Open\""};
                                nuclear_Cycle_Chosen = rand(nuclear_cycle);
                                String[] reactor_fuel = {"100-90% Uranium-235", "80-50% Uranium-235", "20-8% Uranium-235", "1-2% Uranium-235",
                                        "100-90% Plutonium-238", "50% Plutonium-238", "25-8% Plutonium-238", "1-2% Plutonium-238"};
                                reactor_Fuel_Chosen = rand(reactor_fuel);
                                nozzle_Type_List_Chosen = "De Laval Bell (With Nozzle Extension)";
                            }
                        }
                        String[] cooling_mechanism = {"Radiative Cooling", "Dump Cooling", "Film Cooling",
                                "Regenerative Cooling", "Transpiration Cooling"};
                        String altitude_Of_Operation_Chosen = "80 km+ (Vacuum)";
                        String tank_Repressurisation_Chosen = rand(tank_Repressurisation);
                        String cooling_Mechanism_Chosen = rand(cooling_mechanism);
                        String reactor_gen_Chosen;
                        String[] reactor_gen;
                        if ((engine_Cycle_Chosen.equals("Liquid Core") || engine_Cycle_Chosen.equals("Solid Core")
                                || engine_Cycle_Chosen.equals("Pulsed Nuclear"))) {
                            reactor_gen = new String[]{"Generation III+", "Generation IV", "Generation V", "Generation V+"};
                        } else {
                            reactor_gen = new String[]{"Generation I", "Generation II", "Generation III", "Generation III+",
                                    "Generation IV", "Generation V", "Generation V+"};
                        }
                        reactor_gen_Chosen = rand(reactor_gen);
                        int uio97 = rN(1, 456);
                        int uio98 = rN(1, 77);
                        boolean isBimodal = uio97%uio98 != 0;
                        output_nt(engine_Name, engine_Cycle_Chosen, altitude_Of_Operation_Chosen, nuclear_Cycle_Chosen,
                                propellant_List_Chosen, reactor_Fuel_Chosen, nozzle_Type_List_Chosen, tank_Repressurisation_Chosen,
                                cooling_Mechanism_Chosen, "Orbital Manoeuvering", reactor_gen_Chosen, isBimodal,
                                remass_List_Chosen);
                        y++;
                        h++;
                    }

                    case "MagnetoPlasmaDynamic Thruster", "Hall Effect Thruster", "Gridded Ion Thruster",
                            "Colloid Thruster", "Variable Specific Impulse Magnetoplasma Rocket (VASIMR)" -> {
                        String propellant_List_Chosen = null;
                        String nozzle_Type_List_Chosen = null;
                        switch (engine_Cycle_Chosen) {
                            case "Hall Effect Thruster" -> {
                                String[] propellant_List = {"Xe (Xenon)", "Kr (Krypton)", "Ar (Argon)", "Bi (Bismuth)",
                                        "I2 (Iodine)", "Mg (Magnesium)", "Zn (Zinc)", "C10H16 (Adamantane)"};
                                propellant_List_Chosen = rand(propellant_List);
                                nozzle_Type_List_Chosen = "Hall Effect Thruster Nozzle";
                            } case "Gridded Ion Thruster" -> {
                                String[] propellant_List = {"Xe (Xenon)", "Hg (Mercury)", "Cs (Caesium)"};
                                propellant_List_Chosen = rand(propellant_List);
                                nozzle_Type_List_Chosen = "Electrostatic Ion Nozzle";
                            } case "Colloid Thruster" -> {
                                propellant_List_Chosen = "NH2OH+NO3 (Hydroxylammonium nitrate)";
                                nozzle_Type_List_Chosen = "Capillary Emitter-Electrode Cone";
                            } case "Variable Specific Impulse Magnetoplasma Rocket (VASIMR)" -> {
                                String[] propellant_List = {"Xe (Xenon)", "Kr (Krypton)", "Ar (Argon)"};
                                propellant_List_Chosen = rand(propellant_List);
                                nozzle_Type_List_Chosen = "VASIMR Magnetic Confinement Nozzle";
                            } case "MagnetoPlasmaDynamic Thruster" -> {
                                String[] propellant_List = {"Xe (Xenon)", "Ne (Neon)", "Ar (Argon)", "H2 (Hydrogen)", "N2H4 (Hydrazine)", "Li (Lithium)"};
                                propellant_List_Chosen = rand(propellant_List);
                                nozzle_Type_List_Chosen = "Cathode Plug Magnetic Confinement Nozzle";
                            }
                        }
                        String[] powerGen_List = {"Hydrogen Fuel cell", "Nuclear Fission Reactor",
                                "Nuclear Fusion Reactor", "Photovoltaic Panel", "Solar Thermal Panel",
                                "Radioisotope Thermoelectric Generator (RTG)"};
                        String powerGen_List_Chosen = rand(powerGen_List);
                        String altitude_Of_Operation_Chosen = "80 km+ (Vacuum)";
                        output_et(engine_Name, engine_Cycle_Chosen, altitude_Of_Operation_Chosen, propellant_List_Chosen,
                                nozzle_Type_List_Chosen, powerGen_List_Chosen, "Orbital Manoeuvering");
                        y++;
                        h++;
                    }

                    case "Monopropellant (Decomposition)" -> {
                        String[] nozzle_Type_List1 = {"De Laval Cone (Without Nozzle Extension)", "De Laval Bell (Without Nozzle Extension)"};
                        String[] cooling_mechanism = {"Ablative Cooling", "Radiative Cooling"};
                        String propellant_List_Chosen = rand(propellant_List1);
                        String altitude_Of_Operation_Chosen = "80 km+ (Vacuum)";
                        String nozzle_Type_List_Chosen = rand(nozzle_Type_List1);
                        String cooling_Mechanism_Chosen = rand(cooling_mechanism);
                        String catalyst_Chosen = null;
                        switch (propellant_List_Chosen) {
                            case "N2H4 (Hydrazine)", "65% NH4N(NO2)2 (Ammonium Dinitramide) + 35% CH3OH(Methanol)" -> {
                                catalyst_Chosen = "Iridium coated Alumina Pellets";
                            } case "H2O2 (Hydrogen Peroxide)" -> {
                                String[] catalyst = {"KMnO4 (Potassium Permanganate) Honeycomb", "Ag (Silver) Honeycomb",
                                "MnO2 (Manganese Dioxide) Honeycomb", "K2Cr2O7 (Potassium dichromate) Honeycomb",
                                "FeO (Iron (II) oxide)"};
                                catalyst_Chosen = rand(catalyst);
                            } case "NH2OH+NO3 (Hydroxylammonium nitrate)" -> {
                                catalyst_Chosen = "Iridium coated Copper Pellets";
                            }
                        }
                        String[] pot_uses = {"Orbital Manoeuvering", "Course Correction"};
                        String purpose = rand(pot_uses);
                        output_monod(engine_Name, engine_Cycle_Chosen, altitude_Of_Operation_Chosen, propellant_List_Chosen,
                                nozzle_Type_List_Chosen, cooling_Mechanism_Chosen, catalyst_Chosen, purpose);
                        y++;
                        h++;

                    } case "Monopropellant (Cold Gas)" -> {
                        String[] nozzle_Type_List1 = {"De Laval Cone (Without Nozzle Extension)", "De Laval Bell (Without Nozzle Extension)"};
                        String propellant_List_Chosen = rand(propellant_List2);
                        String altitude_Of_Operation_Chosen = "80 km+ (Vacuum)";
                        String nozzle_Type_List_Chosen = rand(nozzle_Type_List1);
                        String cooling_Mechanism_Chosen = "Ablative Cooling";
                        String[] pot_uses = {"Orbital Manoeuvering", "Course Correction"};
                        String purpose = rand(pot_uses);
                        output_mono(engine_Name, engine_Cycle_Chosen, altitude_Of_Operation_Chosen,
                                propellant_List_Chosen, nozzle_Type_List_Chosen, cooling_Mechanism_Chosen, purpose);
                        y++;
                        h++;
                    }

                    case "Expander (Closed)", "Expander (Open/Bleed)" -> {
                        String[] oxidizer_List = {"O2 (Oxygen)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)", "O3 (Ozone)"};
                        String oxidizer_Chosen = rand(oxidizer_List);
                        String fuel_Chosen = "";
                        switch (oxidizer_Chosen) {
                            case "O2 (Oxygen)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "NH3 (Ammonia)", "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)",
                                        "CH3OH (Methanol)", "C12H24 (Kerosene)", "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "NH3 (Ammonia)", "C2H8N2 (UnsymetricalDimethylHydrazine)",
                                        "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)", "CH3OH (Methanol)", "C12H24 (Kerosene)",
                                        "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine) + O2 (Oxygen)", "O3 (Ozone)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "N2H4 (Hydrazine)", "CH3OH (Methanol)",
                                        "C12H24 (Kerosene)", "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            }
                        }
                        String altitude_Of_Operation_Chosen = rand(altitude_Of_Operation);
                        String nozzle_Type_Chosen = bussy(altitude_Of_Operation_Chosen);
                        String[] cooling_mechanism = {"Ablative Cooling", "Radiative Cooling", "Dump Cooling", "Film Cooling",
                                "Regenerative Cooling", "Transpiration Cooling"};
                        String cooling_Mechanism_Chosen = rand(cooling_mechanism);
                        boolean isHypergolic = isHypergolic(oxidizer_Chosen, fuel_Chosen);
                        boolean isCryogenic = isCryogenic(oxidizer_Chosen, fuel_Chosen);
                        String injector = Injector(cooling_Mechanism_Chosen);
                        String purpose = uses(isHypergolic, isCryogenic, altitude_Of_Operation_Chosen);
                        output_ex(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen, altitude_Of_Operation_Chosen,
                                nozzle_Type_Chosen,"Autogenous", cooling_Mechanism_Chosen, isHypergolic, isCryogenic,
                                purpose, injector);
                        y++;
                        h++;
                    }

                    case "Dual Expander (Closed)", "Dual Expander (Open/Bleed)" -> {
                        String[] oxidizer_List = {"O2 (Oxygen)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)"};
                        String oxidizer_Chosen = rand(oxidizer_List);
                        String fuel_Chosen = "";
                        String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)"};
                        switch (oxidizer_Chosen) {
                            case "O2 (Oxygen)", "F2 (Fluorine)" -> {
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine) + O2 (Oxygen)" -> fuel_Chosen = "H2 (Hydrogen)";
                        }
                        String altitude_Of_Operation_Chosen = rand(altitude_Of_Operation);
                        String nozzle_Type_Chosen = bussy(altitude_Of_Operation_Chosen);
                        String[] cooling_mechanism = {"Ablative Cooling", "Radiative Cooling", "Dump Cooling", "Film Cooling",
                                "Regenerative Cooling", "Transpiration Cooling"};
                        String cooling_Mechanism_Chosen = rand(cooling_mechanism);
                        boolean isHypergolic = isHypergolic(oxidizer_Chosen, fuel_Chosen);
                        boolean isCryogenic = isCryogenic(oxidizer_Chosen, fuel_Chosen);
                        String injector = Injector(cooling_Mechanism_Chosen);
                        String purpose = uses(isHypergolic, isCryogenic, altitude_Of_Operation_Chosen);
                        output_ex(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen, altitude_Of_Operation_Chosen,
                                nozzle_Type_Chosen,"Autogenous", cooling_Mechanism_Chosen, isHypergolic, isCryogenic,
                                purpose, injector);
                        y++;
                        h++;
                    }

                    case "Staged Combustion (Fuel Rich)" -> {
                        String[] oxidizer_List = {"O2 (Oxygen)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)", "O3 (Ozone)"};
                        String oxidizer_Chosen = rand(oxidizer_List);
                        String fuel_Chosen = "";
                        switch (oxidizer_Chosen) {
                            case "O2 (Oxygen)", "F2 (Fluorine)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "NH3 (Ammonia)", "N2H4 (Hydrazine)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine) + O2 (Oxygen)", "O3 (Ozone)" -> fuel_Chosen = "H2 (Hydrogen)";
                        }
                        f_calc_o(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen, tank_Repressurisation, altitude_Of_Operation);
                        y++;
                        h++;
                    }

                    case "Staged Combustion (Oxidizer Rich)" -> {
                        String[] oxidizer_List = {"O2 (Oxygen)", "O3 (Ozone)", "N2O4 (Nitrogen Tetroxide)"};
                        String oxidizer_Chosen = rand(oxidizer_List);
                        String fuel_Chosen = "";
                        switch (oxidizer_Chosen) {
                            case "O2 (Oxygen)", "O3 (Ozone)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "NH3 (Ammonia)", "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)",
                                        "CH3OH (Methanol)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "N2O4 (Nitrogen Tetroxide)" -> {
                                String[] fuel_List = {"C6H5NH2 (Aniline)", "75% CH6N2 + 25% N2H4 (UH-25)", "50% CH6N2 + 50% N2H4 (Aerosine-50)",
                                        "C2H8N2 (UnsymetricalDimethylHydrazine)"};
                                fuel_Chosen = rand(fuel_List);
                            }
                        }
                        f_calc_o(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen, tank_Repressurisation, altitude_Of_Operation);
                        y++;
                        h++;
                    }

                    case "Full Flow Staged Combustion", "Combustion Tap Off" -> {
                        String[] oxidizer_List = {"O2 (Oxygen)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)",
                                "N2H4 (Hydrazine)", "O3 (Ozone)", "N2O4 (Nitrogen Tetroxide)"};
                        String oxidizer_Chosen = rand(oxidizer_List);
                        String fuel_Chosen = "";
                        switch (oxidizer_Chosen) {
                            case "O2 (Oxygen)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "NH3 (Ammonia)", "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)",
                                        "CH3OH (Methanol)", "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "NH3 (Ammonia)", "C2H8N2 (UnsymetricalDimethylHydrazine)", "CH6N2 (MonomethylHydrazine)",
                                        "N2H4 (Hydrazine)", "CH3OH (Methanol)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine) + O2 (Oxygen)", "O3 (Ozone)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "75% CH6N2 + 25% N2H4 (UH-25)", "50% CH6N2 + 50% N2H4 (Aerosine-50)",
                                        "CH6N2 (MonomethylHydrazine)", "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "N2H4 (Hydrazine)", "N2O4 (Nitrogen Tetroxide)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "75% CH6N2 + 25% N2H4 (UH-25)", "50% CH6N2 + 50% N2H4 (Aerosine-50)",
                                        "C2H8N2 (UnsymetricalDimethylHydrazine)", "CH3OH (Methanol)", "B2H6 (Diborane)"};
                                fuel_Chosen = rand(fuel_List);
                            }
                        }
                        f_calc_o(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen, tank_Repressurisation, altitude_Of_Operation);
                        y++;
                        h++;
                    }

                    default -> {
                        String[] oxidizer_List = {"O2 (Oxygen)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)",
                                "N2O4 (Nitrogen Tetroxide)", "H2O2 (Hydrogen Peroxide) 95%", "H2O2 (Hydrogen Peroxide) 85%",
                                "O3 (Ozone)", "AK20F: 80% HNO3 + 20% N2O4 (Nitric Acid)",
                                "AK20I: 80% HNO3 + 20% N2O4 (Nitric Acid)", "AK20K: 80% HNO3 + 20% N2O4 (Nitric Acid)",
                                "AK27I: 73% HNO3 + 27% N2O4 (Nitric Acid)", "AK27P: 73% HNO3 + 27% N2O4 (Nitric Acid)",
                                "ClF3 (Chlorine Trifluoride)", "ClF5 (Chlorine Pentafluoride)"};
                        String oxidizer_Chosen = rand(oxidizer_List);
                        String fuel_Chosen = "";
                        switch (oxidizer_Chosen) {
                            case "O2 (Oxygen)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "NH3 (Ammonia)", "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)",
                                        "CH3OH (Methanol)", "C12H24 (Kerosene)", "B2H6 (Diborane)", "B5H9 (Pentaborane)",
                                        "C2H6 (Ethane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH4 (Methane)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "NH3 (Ammonia)", "C2H8N2 (UnsymetricalDimethylHydrazine)",
                                        "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)", "CH3OH (Methanol)", "C12H24 (Kerosene)",
                                        "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine) + O2 (Oxygen)", "O3 (Ozone)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH3OH (Methanol)", "C12H24 (Kerosene)", "B2H6 (Diborane)",
                                        "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "AK20F: 80% HNO3 + 20% N2O4 (Nitric Acid)", "AK20I: 80% HNO3 + 20% N2O4 (Nitric Acid)",
                                    "AK20K: 80% HNO3 + 20% N2O4 (Nitric Acid)", "AK27I: 73% HNO3 + 27% N2O4 (Nitric Acid)",
                                    "AK27P: 73% HNO3 + 27% N2O4 (Nitric Acid)", "ClF3 (Chlorine Trifluoride)",
                                    "ClF5 (Chlorine Pentafluoride)" -> {
                                String[] fuel_List = {"C2H5OH(Ethanol) 85%", "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)",
                                        "CH3OH (Methanol)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "N2O4 (Nitrogen Tetroxide)", "H2O2 (Hydrogen Peroxide) 95%", "H2O2 (Hydrogen Peroxide) 85%" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "C2H5OH(Ethanol) 85%", "C2H5OH(Ethanol) 75%",
                                        "C6H5NH2 (Aniline)", "75% CH6N2 + 25% N2H4 (UH-25)", "50% CH6N2 + 50% N2H4 (Aerosine-50)",
                                        "C2H8N2 (UnsymmetricalDimethylHydrazine)", "CH6N2 (MonomethylHydrazine)", "N2H4 (Hydrazine)",
                                        "CH3OH (Methanol)", "C12H24 (Kerosene)"};
                                fuel_Chosen = rand(fuel_List);
                            }
                        }
                        f_calc_o(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen, tank_Repressurisation, altitude_Of_Operation);
                        y++;
                        h++;
                    }
                }
            } else {
                while (!(repeatCommand.equalsIgnoreCase("Y") && repeatCommand.equalsIgnoreCase("N"))) {
                    System.out.println("Wrong input! Please input an appropriate command [Y/N] ot [YES/NO]");
                    System.out.print("> ");
                    repeatCommand = scanner.next();
                    if (repeatCommand.equalsIgnoreCase("Y") || repeatCommand.equalsIgnoreCase("N") || repeatCommand.equalsIgnoreCase("YES") || repeatCommand.equalsIgnoreCase("NO")) {
                        break;
                    }
                }
            }
        }
    }
}