def verfahren(funktionen: list, startwerte: list, weite: float, schritte: int, fein: bool = True) -> list:
    """
    Runge-Kutta-Verfahren für ein beliebiges DGLS
    :param funktionen: Liste mit allen Funktionen
    :param startwerte: Liste mit allen Startwerten der Variablen
    :param weite: gesamte Weite über die integriert werden soll
    :param schritte: Anzahl der Schritte über die gesamte Weite
    :return: Liste mit Listen für alle Wertepaare
    """
    h = weite / schritte
    werte = [startwerte]
    for i in range(schritte):

        zuschlaege_grob = zuschlaege(funktionen, werte[-1], h)
        werte_grob = [werte[-1][j] if j == 0 else werte[-1][j] + zuschlaege_grob[j - 1]
                      for j in range(len(startwerte))]
        if fein:
            zuschlaege_fein_1 = zuschlaege(funktionen, werte[-1], h / 2)
            werte_fein_1 = [werte[-1][j] + h/2 if j == 0 else werte[-1][j]+zuschlaege_fein_1[j-1]
                            for j in range(len(startwerte))]

            zuschlaege_fein_2 = zuschlaege(funktionen, werte_fein_1, h / 2)
            werte_fein_2 = [werte_fein_1[j] + h/2 if j == 0 else werte_fein_1[j]+zuschlaege_fein_2[j-1]
                            for j in range(len(startwerte))]

            werte_korr = [werte_fein_2[j] if j == 0 else werte_fein_2[j] + 1/15 * (werte_fein_2[j] - werte_grob[j])
                          for j in range(len(startwerte))]

            werte.append(werte_korr)
        else:
            werte.append(werte_grob)
    return werte


def zuschlaege(funktionen: list, startwerte: list, h: float) -> list:
    """
    Berechnung der Zuschläge eines einzelnen Schritts
    :param funktionen: Liste mit allen Funktionen
    :param startwerte: Liste mit allen Startwerten der Variablen
    :param h: Schrittweite
    :return: Liste mit Zuschlägen für die einzelnen Variablen
    """
    werte = [wert for wert in startwerte]

    k1 = [h * funktion(*werte) for funktion in funktionen]

    werte = [startwerte[i] + (h / 2 if i == 0 else k1[i - 1] / 2)
             for i in range(len(startwerte))]

    k2 = [h * funktion(*werte) for funktion in funktionen]

    werte = [startwerte[i] + (h / 2 if i == 0 else k2[i - 1] / 2)
             for i in range(len(startwerte))]

    k3 = [h * funktion(*werte) for funktion in funktionen]

    werte = [startwerte[i] + (h if i == 0 else k3[i - 1])
             for i in range(len(startwerte))]

    k4 = [h * funktion(*werte) for funktion in funktionen]

    k_ = [(k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]) / 6 for i in range(len(k1))]

    return k_

def rk_chat(F, v0: list, weite: float, schritte: int):
    h = weite/schritte
    v = v0
    werte = [v]

    for _ in range(schritte):
        k1 = F(v)
        k2 = F([v[i] + 0.5 * h * k1[i] for i in range(6)])
        k3 = F([v[i] + 0.5 * h * k2[i] for i in range(6)])
        k4 = F([v[i] + h * k3[i] for i in range(6)])

        v = [
            v[i] + (h / 6) * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i])
            for i in range(6)
        ]

        werte.append(v)

    return werte