Помогите преобразовать код из Pascal в Python

Я всего лишь правильно расставил пробелы

y1_t = -3000
y2_t = 250
y3_t = 350
y12_t = 90
y13_t = 150
y23_t = 200
y123_t = 225
y1_r = 10000
y2_r = 350
y3_r = 400
y12_r = 2000
y13_r = 2800
y23_r = 500
y123_r = 900

tks = []

b1_t = y1_t
b2_t = y2_t
b3_t = y3_t
tks.append(b1_t)
tks.append(b2_t)
tks.append(b3_t)


b12_t = 4 * y12_t - 2 * y1_t - 2 * y2_t
b13_t = 4 * y13_t - 2 * y1_t - 2 * y3_t
b23_t = 4 * y23_t - 2 * y2_t - 2 * y3_t
tks.append(b12_t)
tks.append(b13_t)
tks.append(b23_t)

b123_t = 27 * y123_t - 12 * (y12_t + y13_t + y23_t) + 3 * (y1_t + y2_t + y3_t)
tks.append(b123_t)

Re = 0
Si = 100
Ti = 0

while Re <= 100:
    Ti = 0
    Si = 100 - Re
    tks.append(Ti)
    tks.append(Si)

    while Si >= 0:
        tks1 = b1_t*Si/100+b2_t*Re/100+b3_t*Ti/100+b12_t*Si*Re/10000+b13_t*Si*Ti/10000+b23_t*Re*Ti/10000+b123_t*Si*Re*Ti/1000000
        tks.append(tks1)

        Si = Si - 5
        Ti = Ti + 5
    Re = Re + 5

tks.append(Si)
tks.append(Ti)
tks.append(Re)

print(tks)

PROGRAM Sort(input, output);
    CONST
        { Max array size. }
        MaxElts = 50;
    TYPE 
        { Type of the element array. }
        IntArrType = ARRAY [1..MaxElts] OF Integer;

    VAR
        { Indexes, exchange temp, array size. }
        i, j, tmp, size: integer;

        { Array of ints }
        arr: IntArrType;

    { Read in the integers. }
    PROCEDURE ReadArr(VAR size: Integer; VAR a: IntArrType);
        BEGIN
            size := 1;
            WHILE NOT eof DO BEGIN
                readln(a[size]);
                IF NOT eof THEN 
                    size := size + 1
            END
        END;

    { Use quicksort to sort the array of integers. }
    PROCEDURE Quicksort(size: Integer; VAR arr: IntArrType);
        { This does the actual work of the quicksort.  It takes the
          parameters which define the range of the array to work on,
          and references the array as a global. }
        PROCEDURE QuicksortRecur(start, stop: integer);
            VAR
                m: integer;

                { The location separating the high and low parts. }
                splitpt: integer;

            { The quicksort split algorithm.  Takes the range, and
              returns the split point. }
            FUNCTION Split(start, stop: integer): integer;
                VAR
                    left, right: integer;       { Scan pointers. }
                    pivot: integer;             { Pivot value. }

                { Interchange the parameters. }
                PROCEDURE swap(VAR a, b: integer);
                    VAR
                        t: integer;
                    BEGIN
                        t := a;
                        a := b;
                        b := t
                    END;

                BEGIN { Split }
                    { Set up the pointers for the hight and low sections, and
                      get the pivot value. }
                    pivot := arr[start];
                    left := start + 1;
                    right := stop;

                    { Look for pairs out of place and swap 'em. }
                    WHILE left <= right DO BEGIN
                        WHILE (left <= stop) AND (arr[left] < pivot) DO
                            left := left + 1;
                        WHILE (right > start) AND (arr[right] >= pivot) DO
                            right := right - 1;
                        IF left < right THEN 
                            swap(arr[left], arr[right]);
                    END;

                    { Put the pivot between the halves. }
                    swap(arr[start], arr[right]);

                    { This is how you return function values in pascal.
                      Yeccch. }
                    Split := right
                END;

            BEGIN { QuicksortRecur }
                { If there's anything to do... }
                IF start < stop THEN BEGIN
                    splitpt := Split(start, stop);
                    QuicksortRecur(start, splitpt-1);
                    QuicksortRecur(splitpt+1, stop);
                END
            END;
                    
        BEGIN { Quicksort }
            QuicksortRecur(1, size)
        END;

    BEGIN
        { Read }
        ReadArr(size, arr);

        { Sort the contents. }
        Quicksort(size, arr);

        { Print. }
        FOR i := 1 TO size DO
            writeln(arr[i])
    END.