Total Days: 931 (133 weeks)

2 - From Passover until Gregorian Easter Sunday
Total Days: 53

3 - From Passover until Julian Easter Sunday
Total Days: 984

4 - From Julian Easter Full Moon until Gregorian Easter Full Moon
Total Days: 0 (0 weeks)

5 - From Julian Easter Full Moon until Julian Easter Sunday
Total Days: 0 (0 weeks)

6 - From Julian Easter Full Moon until Gregorian Easter Sunday
Total Days: 0 (0 weeks)

7 - From Julian Easter Full Moon until Passover
Total Days: 0 (0 weeks)

8 - From Gregorian Easter Full Moon until Gregorian Easter Sunday
Total Days: 0 (0 weeks)

9 - From Gregorian Easter Full Moon until Julian Easter Sunday
Total Days: 0 (0 weeks)

10 - From Gregorian Easter Full Moon until Passover
Total Days: 0 (0 weeks)



vsechny nulove hodnoty je treba dopocitat






import math

def gmod(m, n):
    """Generalized modulo function to handle negative numbers."""
    return ((m % n) + n) % n

def addspace(x):
    """Adds a leading space to single-digit numbers for alignment."""
    return f" {x}" if x < 10 else f"{x}"

def yeartype(year, cal='j'):
    """
    Determines if the year is a leap year based on the calendar.
    cal='j' for Julian, 'g' for Gregorian.
    """
    yt = 0
    if gmod(year, 4) == 0:
        yt = 1
    if cal == 'g':
        if gmod(year, 100) == 0:
            yt = 0
        if gmod(year, 400) == 0:
            yt = 1
    return yt

# Arrays as per the source code
domletname = ["G","F","E","D","C","B","A","AG","GF","FE","ED","DC","CB","BA"]
epactname = ["*(XXX)","I","II","III","IV","V","VI","VII","VIII","IX","X","XI","XII","XIII",
            "XIV","XV","XVI","XVII","XVIII","XIX","XX","XXI","XXII","XXIII","XXIV","XXV",
            "XXVI","XXVII","XXVIII","XXIX"]
martyrj = ["a","b","c","d","e","f","g","h","i","k","l","m","n","p","q","r","s","t","u"]
martyrg = ["a","b","c","d","e","f","g","h","i","k","l","m","n","p","q","r","s","t","u",
           "A","B","C","D","E","F","G","H","M","N","P"]
monthname = ["January","February","March","April","May","June","July","August","September",
            "October","November","December"]
wdname = ["Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"]
yearlength = ["common","bissextile"]

def calculate_jd(year, month, day, calendar='g'):
    """Calculate the Julian Day Number for the given date."""
    if month <= 2:
        year -=1
        month +=12
    A = math.floor(year / 100)
    if calendar == 'g':
        B = 2 - A + math.floor(A /4)
    else:
        B =0
    JD = math.floor(365.25*(year + 4716)) + math.floor(30.6001*(month +1)) + day + B -1524.5
    JD_int = int(math.floor(JD + 0.5))
    return JD_int

def jul_easter(year, emod):
    """Calculates Julian Easter Sunday date."""
    a = gmod(year, 19)
    gn = a + 1  # Golden Number
    b = gmod(year, 4)
    c = gmod(year, 7)
    d = gmod((19 * a + 15), 30)
    if emod == 1 and gn == 1:
        d += 1
    e = gmod((2 * b + 4 * c - d + 6), 7)
    fmj = 113 + d  # Easter full moon [days after -92 March]
    dmj = fmj + e + 1  # Easter Sunday [days after -92 March]
    fmmj = math.floor(fmj / 31)
    fmdj = gmod(fmj, 31) + 1
    esmj = math.floor(dmj / 31)
    esdj = gmod(dmj, 31) + 1
    sc = gmod((year + 8), 28) + 1
    s = gmod((4 + math.floor(5 * year / 4)), 7)
    yt = yeartype(year, 'j')
    dl_index = s + 7 * yt
    dl = domletname[dl_index] if dl_index < len(domletname) else "Unknown"
    return [dmj, esdj, esmj, fmj, fmdj, fmmj, gn, sc, dl]

def greg_easter(year):
    """Calculates Gregorian Easter Sunday date."""
    a = gmod(year, 19)
    gn = a + 1  # Golden Number
    b = math.floor(year / 100)
    c = gmod(year, 100)
    d = math.floor(b / 4)
    e = gmod(b, 4)
    f = math.floor((b + 8) / 25)
    g = math.floor((b - f + 1) / 3)
    h = gmod((19 * a + b - d - g + 15), 30)
    i = math.floor(c / 4)
    k = gmod(c, 4)
    l = gmod((2 * e + 2 * i - h - k + 4), 7)
    m = math.floor((a + 11 * h + 22 * l) / 451)
    ep = gmod((11 * a + 8 - b + d + math.floor((8 * b + 13) / 25)), 30)
    if ep <= 23:
        fmg = 136 - ep
    elif ep in [24, 25]:
        fmg = 141
    if ep == 25 and gn > 11:
        fmg = 140
    if ep >= 26:
        fmg = 166 - ep
    dmg = 114 + h - 7 * m + l  # Easter Sunday [days after -92 March]
    fmmg = math.floor(fmg / 31)
    fmdg = gmod(fmg, 31) + 1
    esmg = math.floor(dmg / 31)
    esdg = gmod(dmg, 31) + 1
    sc = gmod((year + 8), 28) + 1  # Number in Solar Cycle
    s = gmod((6 + math.floor(5 * year / 4) - math.floor(year / 100) + math.floor(year / 400)), 7)
    yt = yeartype(year, 'g')
    dl_index = s + 7 * yt
    dl = domletname[dl_index] if dl_index < len(domletname) else "Unknown"
    return [dmg, esdg, esmg, fmg, fmdg, fmmg, gn, ep, sc, dl]

def easter_passover(year, prol=0, emod=1):
    """
    Calculates all Easter and Passover related data for a given year.
    
    Parameters:
    - year: The year to calculate.
    - prol: Show Gregorian dates before 1583 (0 for No, 1 for Yes).
    - emod: Julian Easter mode (1 for Dionysian, 2 for Armenian/Non-Chalcedonian).
    
    Returns:
    A dictionary containing all relevant fields.
    """
    # Calculate Julian Easter
    j_easter = jul_easter(year, emod)
    # Calculate Gregorian Easter
    g_easter = greg_easter(year)

    # Calculate offset between Julian and Gregorian calendar
    diff_jg = math.floor(year / 100) - math.floor(year / 400) - 2

    # Julian reckoning dates
    j_full_moon_day = j_easter[4]
    j_full_moon_month = j_easter[5]
    j_full_moon_jd = calculate_jd(year, j_full_moon_month, j_full_moon_day, 'j')

    j_sunday_day = j_easter[1]
    j_sunday_month = j_easter[2]
    j_sunday_jd = calculate_jd(year, j_sunday_month, j_sunday_day, 'j')

    # Gregorian reckoning dates (shifted Julian dates)
    fmjg = j_easter[3] + diff_jg
    fmmjg = math.floor(fmjg / 31)
    fmdjg = gmod(fmjg, 31) + 1
    # Correction: Ensure month increment is appropriate
    if fmdjg > 31:
        fmmjg +=1
        fmdjg -=31
    greg_rec_full_moon_day = fmdjg
    greg_rec_full_moon_month = fmmjg
    greg_rec_full_moon_jd = calculate_jd(year, greg_rec_full_moon_month, greg_rec_full_moon_day, 'g')

    dmgj = j_easter[0] + diff_jg
    mjg = math.floor(dmgj / 31)
    djg_day = gmod(dmgj, 31) + 1
    # Correction: Ensure month increment is appropriate
    if djg_day > 31:
        mjg +=1
        djg_day -=31
    greg_rec_sunday_day = djg_day
    greg_rec_sunday_month = mjg
    greg_rec_sunday_jd = calculate_jd(year, greg_rec_sunday_month, greg_rec_sunday_day, 'g')

    # Gregorian calendar date (standard Gregorian Easter)
    g_full_moon_day = g_easter[4]
    g_full_moon_month = g_easter[5]
    g_full_moon_jd = calculate_jd(year, g_full_moon_month, g_full_moon_day, 'g')

    g_sunday_day = g_easter[1]
    g_sunday_month = g_easter[2]
    g_sunday_jd = calculate_jd(year, g_sunday_month, g_sunday_day, 'g')

    # Solar Cycle and Dominical Letters
    sc = j_easter[7]
    dl_j = j_easter[8]
    dl_g = g_easter[9] if (prol ==1 or year >=1583) else "--"

    # Golden Number and Epact
    gn = j_easter[6]
    ep = g_easter[7]

    # Martyrology letters
    if (prol ==1 or year >=1583):
        if 1 <= ep <= len(martyrg):
            litmartyrg = martyrg[ep -1]
        elif ep ==0 and len(martyrg) >29:
            litmartyrg = martyrg[29]
        else:
            litmartyrg = "--"
    else:
        litmartyrg = "--"

    litmartyrj = martyrj[gn -1] if 1 <= gn <= len(martyrj) else "--"

    # Epact handling
    if prol ==0 and year < 1582:
        epact = "--"
    else:
        if ep < len(epactname):
            epact = epactname[ep]
        else:
            epact = f"Unknown({ep})"
        if ep ==25 and gn >11:
            epact = "25"

    # Offset between Julian and Gregorian calendar
    offset_j_g = f"{diff_jg} days" if not (prol ==0 and year <1582) else "--"

    # deljg: From Gregorian until Julian Easter Sunday
    deljg = (j_sunday_jd - g_sunday_jd) if (prol ==1 or year >=1583) else "--"

    # Passover calculation
    a = gmod((12 * year + 12), 19)
    b = gmod(year, 4)
    s = (5 * (1979335 - 313 * year) + (765433 * a)) / 492480 + b /4
    q = math.floor(s)
    r = s - q
    c_calc = gmod((q + 3 * year +5 * b +1),7)
    dmh = q + diff_jg + 92
    p =0
    if c_calc in [2,4,6]:
        p =1
    if c_calc ==1 and a >6 and r >1366/2160:
        p =2
    if c_calc ==0 and a >11 and r >23268/25920:
        p =1
    dmh += p

    if prol ==0 and year <1583:
        dmh_jd = dmh - diff_jg
        mh = math.floor((dmh_jd -62)/30.6) +2
        dh = math.floor(dmh_jd -62 -30.6 * math.floor((dmh_jd -62)/30.6)) +1
        passover_jd = calculate_jd(year, mh, dh, 'j')
    else:
        dmh_jd = dmh
        mh = math.floor((dmh_jd -62)/30.6) +2
        dh = math.floor(dmh_jd -62 -30.6 * math.floor((dmh_jd -62)/30.6)) +1
        passover_jd = calculate_jd(year, mh, dh, 'g')

    ddhj = j_sunday_jd - passover_jd  # From Passover until Julian Easter Sunday
    if (prol ==1 or year >=1583):
        ddhg = g_sunday_jd - passover_jd  # From Passover until Gregorian Easter Sunday
    else:
        ddhg = "--"

    # Weekday Passover
    wh = gmod(c_calc + p +5,7)
    wd_passover = wdname[wh] if 0 <= wh < len(wdname) else "--"

    # Passover Day and Month
    passover_day = addspace(dh) if isinstance(dh, int) else "--"
    passover_month = monthname[mh -1] if isinstance(mh, int) and 1 <= mh <=12 else "--"

    # Amundi
    amundi = year + 3760

    # Passover Feast Date and JD
    passover_label = f"15 Nisan {amundi} AM"
    # Recompute passover_jd to ensure consistency
    passover_jd = calculate_jd(year, mh, dh, 'g') if (prol ==1 or year >=1583) else calculate_jd(year, mh, dh, 'j')

    # Prepare record
    record = {
        "Year": str(year),
        "Offset between Julian and Gregorian calendar": offset_j_g,
        "Number in Solar Cycle": str(sc),
        "Dominical Letter - Julian reckoning": dl_j,
        "Dominical Letter - Gregorian reckoning": dl_g,
        "Lunar age parameters - Golden Number": str(gn),
        "Lunar age parameters - Gregorian Epact": epact,
        "Martyrology letters - Julian reckoning": litmartyrj,
        "Martyrology letters - Gregorian reckoning": litmartyrg,
        "Julian reckoning": {
            "Easter Full Moon (luna XIV)": f"{j_full_moon_day} {j_full_moon_month} (JD {j_full_moon_jd})",
            "Easter Sunday": f"{j_sunday_day} {j_sunday_month} (JD {j_sunday_jd})"
        },
        "Gregorian reckoning": {
            "Easter Full Moon (luna XIV)": f"{greg_rec_full_moon_day} {greg_rec_full_moon_month} (JD {greg_rec_full_moon_jd})" if (prol ==1 or year >=1583) else "--",
            "Easter Sunday": f"{greg_rec_sunday_day} {greg_rec_sunday_month} (JD {greg_rec_sunday_jd})" if (prol ==1 or year >=1583) else "--"
        },
        "Gregorian calendar date": {
            "Easter Full Moon (luna XIV)": f"{g_full_moon_day} {g_full_moon_month} (JD {g_full_moon_jd})" if (prol ==1 or year >=1583) else "--",
            "Easter Sunday": f"{g_sunday_day} {g_sunday_month} (JD {g_sunday_jd})" if (prol ==1 or year >=1583) else "--"
        },
        "Jewish Passover Feast": f"{passover_label}    {wd_passover} {passover_day} {passover_month} (JD {passover_jd})",
        "From Gregorian until Julian Easter Sunday": f"{deljg} days",
        "From Passover until Gregorian Easter Sunday": f"{ddhg} days" if (prol ==1 or year >=1583) else "--",
        "From Passover until Julian Easter Sunday": f"{ddhj} days"
    }

    return record

def main_menu():
    print("Please select an option:")
    print("A - List all the dates for Easter")
    print("B - List of Easter Sundays")
    print("C - List of Easter Full Moons")
    print("D - List of Jewish Passover Feast")
    print("E - Calculate the difference between Easters and/or Full Moons")
    print("F - Find the difference number between Easters and/or Full Moons")
    print("X - Exit")

def submenu_option_B():
    print("\nSelect a sub-option for Easter Sundays:")
    print("1 - Julian and Gregorian calendar")
    print("2 - Julian and Gregorian calendar with conversions")
    print("3 - Julian calendar")
    print("4 - Julian calendar with conversion")
    print("5 - Gregorian calendar")
    print("6 - Gregorian calendar with conversion")
    choice = input("Enter your choice (1-6): ").strip()
    return choice

def submenu_option_C():
    print("\nSelect a sub-option for Easter Full Moons:")
    print("1 - Julian and Gregorian calendar")
    print("2 - Julian and Gregorian calendar with conversions")
    print("3 - Julian calendar")
    print("4 - Julian calendar with conversion")
    print("5 - Gregorian calendar")
    print("6 - Gregorian calendar with conversion")
    choice = input("Enter your choice (1-6): ").strip()
    return choice

def submenu_option_D():
    print("\nSelect a sub-option for Jewish Passover Feast:")
    print("1 - Passover")
    print("2 - Passover with Julian and Gregorian calendar conversions")
    print("3 - Passover with Julian calendar conversion")
    print("4 - Passover with Gregorian calendar conversion")
    choice = input("Enter your choice (1-4): ").strip()
    return choice

def submenu_option_E():
    print("\nSelect a difference category to sum:")
    print("1 - From Gregorian until Julian Easter Sunday")
    print("2 - From Passover until Gregorian Easter Sunday")
    print("3 - From Passover until Julian Easter Sunday")
    print("4 - From Julian Easter Full Moon until Gregorian Easter Full Moon")
    print("5 - From Julian Easter Full Moon until Julian Easter Sunday")
    print("6 - From Julian Easter Full Moon until Gregorian Easter Sunday")
    print("7 - From Julian Easter Full Moon until Passover")
    print("8 - From Gregorian Easter Full Moon until Gregorian Easter Sunday")
    print("9 - From Gregorian Easter Full Moon until Julian Easter Sunday")
    print("10 - From Gregorian Easter Full Moon until Passover")
    choice = input("Enter your choice (1-10): ").strip()
    return choice

def submenu_option_F():
    print("\nSelect a difference category to find:")
    print("1 - From Gregorian until Julian Easter Sunday")
    print("2 - From Passover until Gregorian Easter Sunday")
    print("3 - From Passover until Julian Easter Sunday")
    print("4 - From Julian Easter Full Moon until Gregorian Easter Full Moon")
    print("5 - From Julian Easter Full Moon until Julian Easter Sunday")
    print("6 - From Julian Easter Full Moon until Gregorian Easter Sunday")
    print("7 - From Julian Easter Full Moon until Passover")
    print("8 - From Gregorian Easter Full Moon until Gregorian Easter Sunday")
    print("9 - From Gregorian Easter Full Moon until Julian Easter Sunday")
    print("10 - From Gregorian Easter Full Moon until Passover")
    choice = input("Enter your choice (1-10): ").strip()
    return choice

def option_A(prol, emod):
    """List all the dates for Easter."""
    start_year = 400
    end_year = 6000
    filename = "easter_dates_A.txt"
    with open(filename, "w", encoding="utf-8") as f:
        for year in range(start_year, end_year +1):
            record = easter_passover(year, prol, emod)
            f.write(f"Year: {record['Year']}\n")
            f.write(f"Offset between Julian and Gregorian calendar: {record['Offset between Julian and Gregorian calendar']}\n")
            f.write(f"Number in Solar Cycle: {record['Number in Solar Cycle']}\n")
            f.write(f"Dominical Letter - Julian reckoning: {record['Dominical Letter - Julian reckoning']}  Dominical Letter - Gregorian reckoning: {record['Dominical Letter - Gregorian reckoning']}\n")
            f.write(f"Lunar age parameters - Golden Number: {record['Lunar age parameters - Golden Number']}  Gregorian Epact: {record['Lunar age parameters - Gregorian Epact']}\n")
            f.write(f"Martyrology letters - Julian reckoning: {record['Martyrology letters - Julian reckoning']}  Martyrology letters - Gregorian reckoning: {record['Martyrology letters - Gregorian reckoning']}\n")
            f.write("\n")
            f.write("Julian reckoning\t\tJulian calendar date\t\t\tGregorian calendar date\n")
            f.write(f"Easter Full Moon (luna XIV)\t{record['Julian reckoning']['Easter Full Moon (luna XIV)']}\t\t{record['Gregorian reckoning']['Easter Full Moon (luna XIV)']}\n")
            f.write(f"Easter Sunday\t\t\t{record['Julian reckoning']['Easter Sunday']}\t\t{record['Gregorian reckoning']['Easter Sunday']}\n")
            f.write("\n")
            f.write("Gregorian reckoning\t\tGregorian calendar date\n")
            f.write(f"Easter Full Moon (luna XIV)\t{record['Gregorian calendar date']['Easter Full Moon (luna XIV)']}\n")
            f.write(f"Easter Sunday\t\t\t{record['Gregorian calendar date']['Easter Sunday']}\n")
            f.write("\n")
            f.write(f"Jewish Passover Feast\t{record['Jewish Passover Feast']}\n")
            f.write("\n")
            f.write(f"From Gregorian until Julian Easter Sunday {record['From Gregorian until Julian Easter Sunday']}\n")
            f.write(f"From Passover until Gregorian Easter Sunday {record['From Passover until Gregorian Easter Sunday']}\n")
            f.write(f"From Passover until Julian Easter Sunday {record['From Passover until Julian Easter Sunday']}\n")
            f.write("\n")
            f.write("-" * 80 + "\n\n")
            if year % 1000 == 0:
                print(f"Processed year: {year}")
    print(f"Easter dates have been written to '{filename}'.")

def option_B_main(sub_choice, prol, emod):
    """Handle Option B: List of Easter Sundays."""
    start_year = 400
    end_year = 6000
    filename = "easter_sundays_B.txt"

    with open(filename, "w", encoding="utf-8") as f:
        # Determine header based on sub_choice
        if sub_choice == "1":
            header = "Year; Julian Easter Sunday; Gregorian Easter Sunday\n"
        elif sub_choice == "2":
            header = "Year; Julian Easter Sunday (JD) [Gregorian Easter Sunday (JD)]; Gregorian Easter Sunday (JD) [Julian Easter Sunday (JD)]\n"
        elif sub_choice == "3":
            header = "Year; Julian Easter Sunday\n"
        elif sub_choice == "4":
            header = "Year; Julian Easter Sunday (JD)\n"
        elif sub_choice == "5":
            header = "Year; Gregorian Easter Sunday\n"
        elif sub_choice == "6":
            header = "Year; Gregorian Easter Sunday (JD)\n"
        else:
            print("Invalid sub-option selected.")
            return
        f.write(header)

        for year in range(start_year, end_year +1):
            record = easter_passover(year, prol, emod)
            jul_sunday = record["Julian reckoning"]["Easter Sunday"]
            greg_sunday = record["Gregorian reckoning"]["Easter Sunday"]
            
            line = f"{year} "

            if sub_choice == "1":
                line += f"; {jul_sunday}; {greg_sunday}\n"
            elif sub_choice == "2":
                if (prol ==1 or year >=1583):
                    line += f"; {jul_sunday} [{greg_sunday}]; {greg_sunday} [{jul_sunday}]\n"
                else:
                    line += "; --; --\n"
            elif sub_choice == "3":
                line += f"; {jul_sunday}\n"
            elif sub_choice == "4":
                jul_jd = j_sunday_jd = jul_sunday.split("(JD ")[1].rstrip(")")
                line += f"; (JD {jul_jd})\n"
            elif sub_choice == "5":
                line += f"; {greg_sunday}\n"
            elif sub_choice == "6":
                if (prol ==1 or year >=1583):
                    greg_jd = greg_sunday.split("(JD ")[1].rstrip(")")
                    line += f"; (JD {greg_jd})\n"
                else:
                    line += "; --\n"
            f.write(line)
    print(f"Easter Sundays have been written to '{filename}'.")

def option_C_main(sub_choice, prol, emod):
    """Handle Option C: List of Easter Full Moons."""
    start_year = 400
    end_year = 6000
    filename = "easter_full_moons_C.txt"

    with open(filename, "w", encoding="utf-8") as f:
        # Determine header based on sub_choice
        if sub_choice == "1":
            header = "Year; Julian Full Moon; Gregorian Full Moon\n"
        elif sub_choice == "2":
            header = "Year; Julian Full Moon (JD) [Gregorian Full Moon (JD)]; Gregorian Full Moon (JD) [Julian Full Moon (JD)]\n"
        elif sub_choice == "3":
            header = "Year; Julian Full Moon\n"
        elif sub_choice == "4":
            header = "Year; Julian Full Moon (JD)\n"
        elif sub_choice == "5":
            header = "Year; Gregorian Full Moon\n"
        elif sub_choice == "6":
            header = "Year; Gregorian Full Moon (JD)\n"
        else:
            print("Invalid sub-option selected.")
            return
        f.write(header)

        for year in range(start_year, end_year +1):
            record = easter_passover(year, prol, emod)
            jul_full_moon = record["Julian reckoning"]["Easter Full Moon (luna XIV)"]
            greg_full_moon = record["Gregorian reckoning"]["Easter Full Moon (luna XIV)"]
            
            line = f"{year} "

            if sub_choice == "1":
                line += f"; {jul_full_moon}; {greg_full_moon}\n"
            elif sub_choice == "2":
                if (prol ==1 or year >=1583):
                    line += f"; {jul_full_moon} [{greg_full_moon}]; {greg_full_moon} [{jul_full_moon}]\n"
                else:
                    line += "; --; --\n"
            elif sub_choice == "3":
                line += f"; {jul_full_moon}\n"
            elif sub_choice == "4":
                jul_jd = jul_full_moon.split("(JD ")[1].rstrip(")")
                line += f"; (JD {jul_jd})\n"
            elif sub_choice == "5":
                line += f"; {greg_full_moon}\n"
            elif sub_choice == "6":
                if (prol ==1 or year >=1583):
                    greg_jd = greg_full_moon.split("(JD ")[1].rstrip(")")
                    line += f"; (JD {greg_jd})\n"
                else:
                    line += "; --\n"
            f.write(line)
    print(f"Easter Full Moons have been written to '{filename}'.")

def option_D_main(sub_choice, prol, emod):
    """Handle Option D: List of Jewish Passover Feast."""
    start_year = 400
    end_year = 6000
    filename = "jewish_passover_D.txt"

    with open(filename, "w", encoding="utf-8") as f:
        # Determine header based on sub_choice
        if sub_choice == "1":
            header = "Year; Passover\n"
        elif sub_choice == "2":
            header = "Year; Passover with Julian and Gregorian conversions\n"
        elif sub_choice == "3":
            header = "Year; Passover with Julian conversion\n"
        elif sub_choice == "4":
            header = "Year; Passover with Gregorian conversion\n"
        else:
            print("Invalid sub-option selected.")
            return
        f.write(header)

        for year in range(start_year, end_year +1):
            record = easter_passover(year, prol, emod)
            passover = record["Jewish Passover Feast"]
            
            line = f"{year} "

            if sub_choice == "1":
                line += f"; {passover}\n"
            elif sub_choice == "2":
                # Assuming conversion means including Julian and Gregorian dates
                jul_pass = record["Julian reckoning"]["Easter Sunday"]
                greg_pass = record["Gregorian reckoning"]["Easter Sunday"]
                line += f"; {passover} [Julian: {jul_pass}; Gregorian: {greg_pass}]\n"
            elif sub_choice == "3":
                jul_pass = record["Julian reckoning"]["Easter Sunday"]
                line += f"; {passover} [Julian: {jul_pass}]\n"
            elif sub_choice == "4":
                greg_pass = record["Gregorian reckoning"]["Easter Sunday"]
                line += f"; {passover} [Gregorian: {greg_pass}]\n"
            f.write(line)
    print(f"Jewish Passover Feast data has been written to '{filename}'.")

def option_E(prol, emod):
    """Handle Option E: Calculate the difference between Easters and/or Full Moons."""
    try:
        year_range = input("Enter the year range (e.g., 1600-1700): ").strip()
        start_year, end_year = map(int, year_range.split('-'))
        if start_year > end_year:
            print("Invalid range. Start year must be less than or equal to end year.")
            return
    except:
        print("Invalid input format.")
        return

    filename = "easter_differences_E.txt"
    categories = {
        "1": "From Gregorian until Julian Easter Sunday",
        "2": "From Passover until Gregorian Easter Sunday",
        "3": "From Passover until Julian Easter Sunday",
        "4": "From Julian Easter Full Moon until Gregorian Easter Full Moon",
        "5": "From Julian Easter Full Moon until Julian Easter Sunday",
        "6": "From Julian Easter Full Moon until Gregorian Easter Sunday",
        "7": "From Julian Easter Full Moon until Passover",
        "8": "From Gregorian Easter Full Moon until Gregorian Easter Sunday",
        "9": "From Gregorian Easter Full Moon until Julian Easter Sunday",
        "10": "From Gregorian Easter Full Moon until Passover"
    }

    sums = {k:0 for k in categories.keys()}

    for year in range(start_year, end_year +1):
        record = easter_passover(year, prol, emod)
        # Extract differences
        sums["1"] += int(record["From Gregorian until Julian Easter Sunday"].split()[0]) if record["From Gregorian until Julian Easter Sunday"] != "--" else 0
        sums["2"] += int(record["From Passover until Gregorian Easter Sunday"].split()[0]) if record["From Passover until Gregorian Easter Sunday"] != "--" else 0
        sums["3"] += int(record["From Passover until Julian Easter Sunday"].split()[0]) if record["From Passover until Julian Easter Sunday"] != "--" else 0
        if record["From Gregorian until Julian Easter Sunday"] != "--":
            pass
        # Additional differences can be added similarly

    # Writing to file
    with open(filename, "w", encoding="utf-8") as f:
        f.write(f"Year Range: {start_year}-{end_year}\n\n")
        for key in sorted(categories.keys(), key=lambda x: int(x)):
            total_days = sums[key]
            weeks = total_days //7
            f.write(f"{key} - {categories[key]}\n")
            f.write(f"Total Days: {total_days}")
            if total_days %7 ==0:
                f.write(f" ({weeks} weeks)\n\n")
            else:
                f.write("\n\n")
    print(f"Difference calculations have been written to '{filename}'.")

def option_F(prol, emod):
    """Handle Option F: Find the difference number between Easters and/or Full Moons."""
    try:
        target_number = int(input("Enter the number to find (positive integer): ").strip())
    except:
        print("Invalid input. Please enter a positive integer.")
        return

    filename = "easter_findings_F.txt"
    categories = {
        "1": "From Gregorian until Julian Easter Sunday",
        "2": "From Passover until Gregorian Easter Sunday",
        "3": "From Passover until Julian Easter Sunday",
        "4": "From Julian Easter Full Moon until Gregorian Easter Full Moon",
        "5": "From Julian Easter Full Moon until Julian Easter Sunday",
        "6": "From Julian Easter Full Moon until Gregorian Easter Sunday",
        "7": "From Julian Easter Full Moon until Passover",
        "8": "From Gregorian Easter Full Moon until Gregorian Easter Sunday",
        "9": "From Gregorian Easter Full Moon until Julian Easter Sunday",
        "10": "From Gregorian Easter Full Moon until Passover"
    }

    with open(filename, "w", encoding="utf-8") as f:
        f.write(f"Searching for the number: {target_number}\n\n")
        for year in range(1583, 6001):
            record = easter_passover(year, prol, emod)
            for key in categories.keys():
                diff = 0
                if key == "1":
                    diff_str = record["From Gregorian until Julian Easter Sunday"]
                elif key == "2":
                    diff_str = record["From Passover until Gregorian Easter Sunday"]
                elif key == "3":
                    diff_str = record["From Passover until Julian Easter Sunday"]
                elif key == "4":
                    diff_str = "--"  # Placeholder
                elif key == "5":
                    diff_str = "--"  # Placeholder
                elif key == "6":
                    diff_str = "--"  # Placeholder
                elif key == "7":
                    diff_str = "--"  # Placeholder
                elif key == "8":
                    diff_str = "--"  # Placeholder
                elif key == "9":
                    diff_str = "--"  # Placeholder
                elif key == "10":
                    diff_str = "--"  # Placeholder
                if diff_str != "--":
                    try:
                        diff = int(diff_str.split()[0])
                        if abs(diff) == target_number:
                            f.write(f"Year Range: {year}-{year}\n")
                            for k in categories.keys():
                                f.write(f"{k} - {categories[k]}: {record.get(categories[k], '--')} days\n")
                            f.write("\n")
                    except:
                        continue
    print(f"Search results have been written to '{filename}'.")

def main():
    # Settings
    prol = 0  # Show Gregorian dates before 1583 - No
    emod = 1  # Julian Easter mode - Dionysian

    while True:
        main_menu()
        choice = input("Enter your choice (A-F or X to exit): ").strip().upper()
        
        if choice == "A":
            option_A(prol, emod)
        elif choice == "B":
            sub_choice = submenu_option_B()
            option_B_main(sub_choice, prol, emod)
        elif choice == "C":
            sub_choice = submenu_option_C()
            option_C_main(sub_choice, prol, emod)
        elif choice == "D":
            sub_choice = submenu_option_D()
            option_D_main(sub_choice, prol, emod)
        elif choice == "E":
            option_E(prol, emod)
        elif choice == "F":
            option_F(prol, emod)
        elif choice == "X":
            print("Exiting the program.")
            break
        else:
            print("Invalid choice. Please select a valid option.")

if __name__ == "__main__":
    main()