ITAR is a pain in my side (Whyy US government?????)

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 boolean MStringS(String[] strings, String tbc) {
        boolean IsThere = false;
        for (String s : strings) {
            if (tbc.contains(s)) {
                IsThere = true;
                break;
            }
        }
        return IsThere;
    }
    public static int rN (double add, int maxV){
        return (int)(add + (Math.random() * maxV));
    }
    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 searched){
        ArrayList<String> clist = new ArrayList<>();
        Collections.addAll(clist, array);
        return clist.indexOf(searched);
    }
    public static String[] split(String string, String Separator) {
        return string.split(Separator);
    }
    public static void StndrdDet(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 NzlReturnP = NzlParameters(altitude_Of_Operation_Chosen);
        String[] parts = split(NzlReturnP, ", ");
        String nozzle_Type_Chosen = parts[0];
        String AreaRatio = parts[1];
        boolean isHypergolic = isHypergolic(oxidizer_Chosen, fuel_Chosen);
        boolean isCryogenic = isCryogenic(oxidizer_Chosen, fuel_Chosen);
        String purpose = uses(isHypergolic, isCryogenic, altitude_Of_Operation_Chosen, engine_Cycle_Chosen);
        String[] search_for = {"Upper", "Payload", "Space"}, cooling_mechanism;
        boolean longDur = MStringS(search_for, purpose);
        if (longDur) {
            cooling_mechanism = new String[]{"Radiative Cooling", "Dump Cooling", "Film Cooling", "Regenerative Cooling",
                    "Transpiration Cooling"};
        } else {
            cooling_mechanism = new String[]{"Ablative Cooling", "Radiative Cooling", "Dump Cooling", "Film Cooling",
                    "Regenerative Cooling", "Transpiration Cooling"};
        }
        String cooling_Mechanism_Chosen = rand(cooling_mechanism);
        String f_regen = "";
        if (cooling_Mechanism_Chosen.equals("Regenerative Cooling")) {
            int choice = (rN(4, 63))/2;
            if (Math.ceil(choice) == Math.floor(choice)) {
                f_regen = "Fuel ";
            } else {
                f_regen = "Oxidizer ";
            }
        }
        String cooling_Mechanism_C = f_regen + cooling_Mechanism_Chosen;
        String injector = Injector(cooling_Mechanism_C, engine_Cycle_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, AreaRatio);
    }
    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)",
                    "ClF5 (Chlorine Pentafluoride)", "O2 (Oxygen)" -> {
                isCryo = true;
            }
        }
        switch (fuel_chosen) {
            case "CH3OH (Methanol)", "C12H26 (n-Dodecane)", "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 En_Cycle) {
        String use = "";
        String[] pot_uses;
        boolean complex = En_Cycle.contains("Combustion Tap") || En_Cycle.contains("Staged") || En_Cycle.contains("Full Flow");
        if ((alt.equals("0-10 km (Sea Level)")) || (alt.equals("20-30 km (Medium Atmosphere)"))) {
            if (complex) {
                pot_uses = new String[]{"Lower Stage (Main Propulsion)"};
            } else {
                pot_uses = new String[]{"Lower Stage (Main Propulsion)", "Lower Stage (Course Correction)", "Lower Stage (Vernier)"};
            }
            use = rand(pot_uses);
        } else if ((alt.equals("30-80 km (High Atmosphere)")) || (alt.equals("80 km+ (Vacuum)"))) {
            if (isHypergolic && isCryogenic) {
                if (complex) {
                    pot_uses = new String[]{"Upper Stage (Main Propulsion)"};
                } else {
                    pot_uses = new String[]{"Upper Stage(Main Propulsion)", "Upper Stage(Course Correction)",
                            "Upper Stage(Vernier)", "Upper Stage (Ullage)", "Payload (Main Propulsion)", "Payload (ACS)"};
                }
                use = rand(pot_uses);
            } else if (!isHypergolic && isCryogenic) {
                if (complex) {
                    pot_uses = new String[]{"Upper Stage (Main Propulsion)"};
                } else {
                    pot_uses = new String[]{"Upper Stage (Main Propulsion)", "Upper Stage (Vernier)"};
                }
                use = rand(pot_uses);
            } else if (isHypergolic && !isCryogenic) {
                if (complex) {
                    pot_uses = new String[]{"Upper Stage(Main Propulsion)", "Payload (Main Propulsion)",
                            "Space Tug (Main Propulsion)"};
                } else {
                    pot_uses = new String[]{"Upper Stage(Main Propulsion)", "Upper Stage(Course Correction)",
                            "Upper Stage(Vernier)", "Upper Stage (Ullage)", "Payload (Main Propulsion)",
                            "Payload (ACS)", "Payload (Course Correction)", "Payload (Vernier)",
                            "Space Tug (Main Propulsion)", "Space Tug (Course Correction)", "Space Tug (Vernier)",
                            "Space Tug (Ullage)"};
                }
                use = rand(pot_uses);
            }
        } else {
            pot_uses = new String[]{"Lower Stage (Main Propulsion)", "Upper Stage(Main Propulsion)", "Payload (Main Propulsion)"};
            use = rand(pot_uses);
        }
        return use;
    }
    public static String Injector(String cooling_Mechanism, String engine_Cycle_Chosen) {
        String fuel_state = "Liquid";
        if (cooling_Mechanism.contains("Regenerative Cooling") || engine_Cycle_Chosen.contains("Expander")) {
            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 NzlParameters (String altitude_Of_Operation_Chosen) {
        String nozzle_Type_Chosen = "", OExpansionRatio = "";
        switch (altitude_Of_Operation_Chosen) {
            case "0-20 km (Sea Level)" -> {
                String[] nozzle_Type_List_SL = {"Contour Bell Nozzle", "Parabolic Bell Nozzle", "Conical Nozzle",
                        "Stepped Dual Bell Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_SL);
                if (nozzle_Type_Chosen.equalsIgnoreCase("Conical Nozzle")) {
                    OExpansionRatio = rN(10, 9) + ":1";
                } else {
                    OExpansionRatio = rN(10, 12) + ":1";
                }
            } case "20-30 km (Medium Atmosphere)" -> {
                String[] nozzle_Type_List_HA = {"Contour Bell Nozzle", "Parabolic Bell Nozzle", "Stepped Dual Bell Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_HA);
                OExpansionRatio = rN(32, 14) + ":1";
            } case "30-80 km (High Atmosphere)" -> {
                String[] nozzle_Type_List_HAi = {"Contour Bell Nozzle", "Parabolic Bell Nozzle", "Stepped Dual Bell Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_HAi);
                OExpansionRatio = rN(47, 43) + ":1";
            } case "80 km+ (Vacuum)" -> {
                String[] nozzle_Type_List_VA = {"Contour Bell Nozzle", "Parabolic Bell Nozzle", "Expanding Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_VA);
                OExpansionRatio = rN(90, 110) + ":1";
            } case "Any Altitude (0-80 km+)" -> {
                String[] nozzle_Type_List_Aero = {"Linear Aerospike Nozzle", "Toroidal Aerospike Nozzle",
                                                  "Stepped Dual Bell Nozzle"};
                nozzle_Type_Chosen = rand(nozzle_Type_List_Aero);
                if (nozzle_Type_Chosen.equalsIgnoreCase("Stepped Dual Bell Nozzle")) {
                    OExpansionRatio = rN(10, 9) + ":1";
                } else {
                    OExpansionRatio = "";
                }
            }
        }
        return nozzle_Type_Chosen + ", " + OExpansionRatio;
    }
    public static String nameGen(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/GenFiles/GenData/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/GenFiles/GenData/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_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,
                                 String PRS, String ARR) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/ofb_rex.docx");
        System.out.println(lbrk + '\n' + "Engine Designation: " + ENN + '\n');
        if (ECC.equals("Nuclear SaltWater")) {
            System.out.println("Fuel Flow Cycle: " + NCC + " " + ECC);
        } else {
            System.out.println("Fuel Flow Cycle: " + ECC);
        }
        System.out.println("Propellant (Remass): " + PLC);
        System.out.println("Propellant State: " + PRS);
        System.out.println("Reactor Fuel: " + RFC);
        System.out.println("Reactor Generation: " + react_gen);
        System.out.println("Reactor Coolant: " + ERC + " - Xenon (Xe)");
        String bimm1, bimm2, oo1, oo2;
        if (!bimodal || ECC.equals("Nuclear SaltWater")) {
            bimm1 = "Engine Bimodality: ";
            oo1 = "Engine isn't bimodal";
            bimm2 = "Engine Electrical Output: ";
            oo2 = "None";
        } 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");
        if (ECC.equals("Nuclear SaltWater")) {
            run4.setText(ECC);
        } else {
            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 run65 = par.createRun();
        run65.setFontSize(10);
        run65.setBold(true);
        run65.setFontFamily("Arial");
        run65.setText("Propellant State: ");
        XWPFRun run66 = par.createRun();
        run66.setFontSize(10);
        run66.setFontFamily("Arial");
        run66.setText(PRS);
        run66.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 run69 = par.createRun();
        run69.setFontSize(10);
        run69.setBold(true);
        run69.setFontFamily("Arial");
        run69.setText("Exhaust Nozzle Area Ratio: ");
        XWPFRun run60 = par.createRun();
        run60.setFontSize(10);
        run60.setFontFamily("Arial");
        run60.setText(ARR);
        run60.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/GenFiles/GenData/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, String ARR) throws IOException {
        String lbrk = "======================================================================================================================";
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/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 message1 = "Propellant properties: ", message2, ThrottleRange, piss;

        if ((isCryo) && (isHyp)) {
            message2 = "Hypergolic and cryogenic";
            System.out.println(message1 + message2);
        } else if ((isCryo) && (!isHyp)) {
            message2 = "Not Hypergolic but cryogenic";
            System.out.println(message1 + message2);
        } else if ((!isCryo) && (isHyp)) {
            message2 = "Hypergolic but not cryogenic";
            System.out.println(message1 + message2);
        } else {
            message2 = "Neither Hypergolic nor cryogenic";
            System.out.println(message1 + message2);
        }

        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";
        }

        if (purpose.contains("Vernier")) {
            int gimbalangle = rN(0, 30);
            if ((!(gimbalangle >= 1)) || AOOC.equals("80 km+ (Vacuum)")) {
                piss = "None";
            } else {
                piss = gimbalangle + "°";
            }
        } else if (purpose.contains("Course Correction") && !purpose.contains("Lower Stage")) {
            piss = "None";
        } else {
            int gimbalangle = rN(0, 10);
            if ((!(gimbalangle >= 1)) || AOOC.equals("80 km+ (Vacuum)")) {
                piss = "None";
            } else {
                piss = gimbalangle + "°";
            }
        }
        int chambers = rN(1, 2);
        String chamberN = "", cmbrM = "Engine chamber configuration: ";
        if (chambers == 1 || NTC.contains("Aerospike")) {
            chamberN = "Single Chamber";
        } else if (chambers == 2) {
            chamberN = "Dual Chamber";
        } else if (chambers == 3) {
            chamberN = "Quadruple Chamber";
        }
        System.out.println("Altitude Of Operation: " + AOOC);
        System.out.println("Exhaust Nozzle Geometry: " + NTC);
        System.out.println("Exhaust Nozzle Area Ratio: " + ARR);
        System.out.println("Engine Gimbal Range: " + piss);
        System.out.println("Engine Injector Design: " + injector);
        System.out.println(cmbrM + chamberN);
        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(message1);
        XWPFRun run107 = par.createRun();
        run107.setFontSize(10);
        run107.setBold(false);
        run107.setFontFamily("Arial");
        run107.setText(message2);
        run107.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 run69 = par.createRun();
        run69.setFontSize(10);
        run69.setBold(true);
        run69.setFontFamily("Arial");
        run69.setText("Exhaust Nozzle Area Ratio: ");
        XWPFRun run60 = par.createRun();
        run60.setFontSize(10);
        run60.setFontFamily("Arial");
        run60.setText(ARR);
        run60.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 run167 = par.createRun();
        run167.setFontSize(10);
        run167.setBold(true);
        run167.setFontFamily("Arial");
        run167.setText(cmbrM);
        XWPFRun run168 = par.createRun();
        run168.setFontSize(10);
        run168.setFontFamily("Arial");
        run168.setText(chamberN);
        run168.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%",
                    "H2O2 (Hydrogen Peroxide) 75%", "O2 (Oxygen)" -> {
                isHypergolic = false;
            } case "O3 (Ozone)", "F2 (Fluorine)", "F2 (Fluorine) + O2 (Oxygen)", "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/GenFiles");
        org.mkdir();
        File org1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/DevData");
        org1.mkdir();
        File org2 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData");
        org2.mkdir();
        // -------------------------------------
        File pathn1 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/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/GenFiles/GenData");
        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 = 25;
            boolean test = true;
            if (test) {
                if ((new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/FullFolders/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";
                } else {
                    piss = '\n' + "Average amount of bytes per engine: " + (sum / yi.size()) + " bytes";
                }
                String pussay = "Average amount of engines per file: " + sum + " engines";
                String hamstrings;
                if (timen < 60) {
                    hamstrings = "Total run time: " + timen + " secs";
                } else if (timen/60 < 2) {
                    hamstrings = "Total run time: " + (int)Math.floor(timen/60) + " min " + Math.round(timen%60) + " secs";
                } else {
                    hamstrings = "Total run time: " + (int)Math.floor(timen/60) + " mins " + Math.round(timen%60) + " secs";
                }
                String shoe = "Rate of engine generation: " + h/timen + " engines/second";
                String back = "Number of engines in files: " + h;
                try {
                    FileWriter fwrite = new FileWriter("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/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/GenFiles");
                    logM.mkdir();
                    // -------------------------------------------------------------------------------------------------
                    if ((new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/FullFolders/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/GenFiles/GenData/FullFolders/ofb_rex[Full]" + i + ".docx")).exists()) {
                                x++;
                            } else {
                                Files.copy(onlyfans, Paths.get("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/FullFolders/ofb_rex[Full]" + i + ".docx"));
                            }
                        }
                    } else {
                        File org3 = new File("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/FullFolders");
                        org3.mkdir();
                        Path logPF = Paths.get("C:/Users/Public/Operational_Functional_Block/Java_projects/src/GenFiles/GenData/FullFolders/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", "Radioisotope Engine", "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[] altitude_Of_Operation = {"0-20 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 = nameGen(engine_Name1, firstPart);
                String engine_Cycle_Chosen = rand(engine_Cycle);
                switch (engine_Cycle_Chosen) {
                    case "Gas Core", "Liquid Core", "Solid Core", "Pulsed Nuclear", "Pebble-Bed Core", "Nuclear SaltWater", "Radioisotope Engine" -> {
                        String propellant_List_Chosen = "", nuclear_Cycle_Chosen = "", reactor_Fuel_Chosen = "",
                                nozzle_Type_List_Chosen, remass_List_Chosen = "", propellantState = "";
                        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\""};
                                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";
                                propellantState = "Cryogenic Liquid";
                            } case "Liquid Core", "Colloid-Core", "Pebble-Bed Core", "Pulsed Nuclear" -> {
                                String[] nuclear_cycle = {"\"Expander Bleed\"", "\"Expander Closed\"", "\"Vortex Confined\""};
                                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 = {"80-95% Uranium-235", "50-80% Uranium-235", "20-50% Uranium-235", "8-20% 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);
                                propellantState = "Aqueous";
                            } case "Nuclear SaltWater" -> {
                                propellant_List_Chosen = "Uranium TetraBromide (UBr4) + Water (H2O)";
                                remass_List_Chosen = "Water (H2O)";
                                nuclear_Cycle_Chosen = "";
                                reactor_Fuel_Chosen = "The engine has no reactor";
                                propellantState = "Aqueous";
                            } case "Solid Core" -> {
                                String[] remass_List = {"Hydrogen (H2)", "Helium (He)", "Nitrogen (N2)", "Hydrogen (H)", "Ammonia (NH3)",
                                        "Water (H2O)", "Oxygen (O2)", "Carbon Dioxide (CO2)", "Carbon Monoxide (CO)", "Methane (CH4)"};
                                remass_List_Chosen = rand(remass_List);
                                propellant_List_Chosen = remass_List_Chosen;
                                String[] nuclear_cycle = {"\"Expander Bleed\"", "\"Expander Closed\""};
                                nuclear_Cycle_Chosen = rand(nuclear_cycle);
                                String[] reactor_fuel = {"80-95% Uranium-235", "50-80% Uranium-235", "20-50% Uranium-235", "8-20% Uranium-235", "5-8% Uranium-235",
                                        "80-95% Plutonium-238", "50-80% Plutonium-238", "20-50% Plutonium-238" , "8-20% Plutonium-238", "5-8% Plutonium-238"};
                                reactor_Fuel_Chosen = rand(reactor_fuel);
                                propellantState = "Cryogenic Liquid";
                            } case "Radioisotope Engine" -> {
                                String[] remass_List = {"Hydrogen (H2)", "Helium (He)", "Nitrogen (N2)", "Hydrogen (H)", "Ammonia (NH3)",
                                        "Water (H2O)", "Oxygen (O2)", "Carbon Dioxide (CO2)", "Carbon Monoxide (CO)", "Methane (CH4)"};
                                remass_List_Chosen = rand(remass_List);
                                propellant_List_Chosen = remass_List_Chosen;
                                nuclear_Cycle_Chosen = "";
                                String[] reactor_fuel = {"Polonium-210", "Fermium-252"};
                                reactor_Fuel_Chosen = rand(reactor_fuel);
                                propellantState = "Cryogenic Liquid";
                            }
                        }
                        String[] pot_uses = new String[]{"Upper Stage(Main Propulsion)", "Payload (Main Propulsion)",
                                "Space Tug (Main Propulsion)"};
                        String use = rand(pot_uses);
                        nozzle_Type_List_Chosen = rand(new String[]{"Contour Bell Nozzle", "Parabolic Bell Nozzle"});
                        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 if (engine_Cycle_Chosen.equals("Nuclear SaltWater") || engine_Cycle_Chosen.equals("Radioisotope Engine")) {
                            reactor_gen = new String[]{"Engine has no reactor"};
                        } else {
                            reactor_gen = new String[]{"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;
                        String NzlReturnP = NzlParameters(altitude_Of_Operation_Chosen);
                        String[] parts = NzlReturnP.split(", ");
                        String AreaRatio = parts[1];
                        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, use, reactor_gen_Chosen,
                                isBimodal, remass_List_Chosen, propellantState, AreaRatio);
                        y++;
                        h++;
                    }

                    case "MagnetoPlasmaDynamic Thruster", "Hall Effect Thruster", "Gridded Ion Thruster",
                            "Colloid Thruster", "Variable Specific Impulse Magnetoplasma Rocket (VASIMR)" -> {
                        String propellant_List_Chosen = null, 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[] pot_uses = new String[]{"Payload (Main Propulsion)", "Payload (Vernier)",
                                "Space Tug (Main Propulsion)", "Space Tug (Vernier)"};
                        String use = rand(pot_uses);
                        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, use);
                        y++;
                        h++;
                    }

                    case "Monopropellant (Decomposition)" -> {
                        String[] nozzle_Type_List1 = {"Conical Nozzle", "Contour Bell Nozzle", "Parabolic Bell Nozzle"};
                        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 = new String[]{"Upper Stage(Ullage)", "Upper Stage(Vernier)", "Payload (Main Propulsion)",
                                "Payload (Vernier)", "Space Tug (Ullage)", "Space Tug (Vernier)"};
                        String use = 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, use);
                        y++;
                        h++;

                    } case "Monopropellant (Cold Gas)" -> {
                        String[] nozzle_Type_List1 = {"Conical Nozzle", "Contour Bell Nozzle", "Parabolic Bell Nozzle"};
                        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 = {"Upper Stage(Ullage)", "Upper Stage(Vernier)", "Payload (Main Propulsion)",
                                             "Payload (Vernier)", "Space Tug (Ullage)", "Space Tug (Vernier)"};
                        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)", "C12H26 (n-Dodecane)", "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)", "C12H26 (n-Dodecane)",
                                        "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)",
                                        "C12H26 (n-Dodecane)", "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            }
                        }
                        StndrdDet(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen,
                                tank_Repressurisation, altitude_Of_Operation);
                        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)";
                        }
                        StndrdDet(engine_Name, engine_Cycle_Chosen, oxidizer_Chosen, fuel_Chosen,
                                tank_Repressurisation, altitude_Of_Operation);
                        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)";
                        }
                        StndrdDet(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);
                            }
                        }
                        StndrdDet(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);
                            }
                        }
                        StndrdDet(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%",
                                "H2O2 (Hydrogen Peroxide) 75%", "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)",
                                "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)", "C12H26 (n-Dodecane)", "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)", "C12H26 (n-Dodecane)",
                                        "B2H6 (Diborane)", "B5H9 (Pentaborane)"};
                                fuel_Chosen = rand(fuel_List);
                            } case "F2 (Fluorine) + O2 (Oxygen)", "O3 (Ozone)" -> {
                                String[] fuel_List = {"H2 (Hydrogen)", "CH3OH (Methanol)", "C12H26 (n-Dodecane)", "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)",
                                    "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%",
                                    "H2O2 (Hydrogen Peroxide) 75%" -> {
                                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)", "C12H26 (n-Dodecane)"};
                                fuel_Chosen = rand(fuel_List);
                            }
                        }
                        StndrdDet(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;
                    }
                }
            }
        }
    }
}