Problem p02831 (python)

Fixed submission:
A, B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 1
while n <= A:
    if A == 1:
        sosuA += [n]
        numberA += 1
        break
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
        if n == 1:
            n += 1
    else:
        n += 1
n = 1
while n <= B:
    if B == 1:
        sosuB += [n]
        numberB += 1
        break
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
        if n == 1:
            n += 1
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        rase = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        if n == numberB - 1 or numberB:
            i += 1
            n = 0
            rase = 0
            continue
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        if i == numberA - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        rase = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        if n == numberA or numberA - 1:
            i += 1
            n = 0
            rase = 0
        if i == numberB - 1 or numberB:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        if i == numberB - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
            if n == len(flagA):
                sai = len(sosuB) - i
                for m in range(sai):
                    tuika += [sosuB[i]]
                    i += 1
                break
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        if n == len(flagB):
                sai = len(sosuA) - i
                for m in range(sai):
                    tuika += [sosuA[i]]
                    i += 1
                break
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
A, B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 1
while n <= A:
    if A == 1:
        sosuA += [n]
        numberA += 1
        break
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
        if n == 1:
            n += 1
    else:
        n += 1
n = 1
while n <= B:
    if B == 1:
        sosuB += [n]
        numberB += 1
        break
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
        if n == 1:
            n += 1
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberB - 1 or numberB:
            i += 1
            n = 0
            rase = 0
            continue
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        if i == numberA - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        if n == numberA - 1 or numberA:
            i += 1
            n = 0
            rase = 0
            continue
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        if i == numberB - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
            if n == len(flagA):
                sai = len(sosuB) - i
                for m in range(sai):
                    tuika += [sosuB[i]]
                    i += 1
                break
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        if n == len(flagB):
                sai = len(sosuA) - i
                for m in range(sai):
                    tuika += [sosuA[i]]
                    i += 1
                break
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
A, B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 1
while n <= A:
    if A == 1:
        sosuA += [n]
        numberA += 1
        break
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
        if n == 1:
            n += 1
    else:
        n += 1
n = 1
while n <= B:
    if B == 1:
        sosuB += [n]
        numberB += 1
        break
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
        if n == 1:
            n += 1
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberB - 1 or numberB:
            i += 1
            n = 0
            rase = 0
            continue
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        if i == numberA - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        if n == numberA - 1 or numberA:
            i += 1
            n = 0
            rase = 0
            continue
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        if i == numberB - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
            if n == len(flagA):
                sai = len(sosuB) - i
                for m in range(sai - 1):
                    tuika += [sosuB[i]]
                    i += 1
                break
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        if n == len(flagB):
                sai = len(sosuA) - i
                for m in range(sai - 1):
                    tuika += [sosuA[i]]
                    i += 1
                break
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
A, B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 1
while n <= A:
    if A == 1:
        sosuA += [n]
        numberA += 1
        break
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
        if n == 1:
            n += 1
    else:
        n += 1
n = 1
while n <= B:
    if B == 1:
        sosuB += [n]
        numberB += 1
        break
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
        if n == 1:
            n += 1
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberB - 1 or numberB:
            i += 1
            n = 0
            rase = 0
            continue
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        if i == numberA - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        if n == numberA - 1 or numberA:
            i += 1
            n = 0
            rase = 0
            continue
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        if i == numberB - 1:
            break
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
A, B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 2
while n <= A:
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
    else:
        n += 1
n = 2
while n <= B:
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberB - 1:
            i += 1
            n = 0
            continue
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberA - 1:
            i += 1
            n = 0
            continue
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
A, B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 2
while n <= A:
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
    else:
        n += 1
n = 2
while n <= B:
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberB - 1:
            i += 1
            n = 0
            continue
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberA - 1:
            i += 1
            n = 0
            continue
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
A,B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 2
while n <= A:
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
    else:
        n += 1
n = 2
while n <= B:
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
    else:
        n += 1
i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberB - 1:
            i += 1
            n = 0
            continue
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        boc = n
        if n == numberA - 1:
            i += 1
            n = 0
            continue
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
A, B = map(int, input().split())
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 2
while n <= A:
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
    else:
        n += 1
n = 2
while n <= B:
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
    else:
        n += 1

i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuA[i - 1]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuB[i - 1]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        boc = n
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
    else:
        n += 1
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)

Buggy submission (verdict: Runtime Error):
str = list(map(int, input().split()))
A = str[0]
B = str[1]
numberA = 0
numberB = 0
dataA = []
dataB = []
sosuA = []
sosuB = []
flagA = []
flagB = []
i = 1
boc = 0
while i <= A:
    dataA += [i]
    i += 1
i = 1
while i <= B:
    dataB += [i]
    i += 1
n = 2
while n <= A:
    if A % n == 0:
        sosuA += [n]
        A = A / n
        numberA += 1
    else:
        n += 1
print(sosuA)
n = 2
while n <= B:
    if B % n == 0:
        sosuB += [n]
        B = B / n
        numberB += 1
    else:
        n += 1
print(sosuB)

i = 0
n = 0
rase = 0
while i <= numberA - 1:
    if i != 0 and sosuA[i] == sosuB[boc]:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
        continue
    if sosuA[i] == sosuB[n]:
        kai = sosuA[i]
        flagA += [kai]
        n += 1
        rase = 1
        boc = n
        if i == numberA - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuA[i] != sosuB[n] and n == numberB - 1:
        kai = sosuA[i]
        flagA += [kai]
        i += 1
        n = 0
    else:
        n += 1
print(flagA)
i = 0
n = 0
while i <= numberB - 1:
    if i != 0 and sosuB[i] == sosuA[boc]:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
        continue
    if sosuB[i] == sosuA[n]:
        kai = sosuB[i]
        flagB += [kai]
        n += 1
        rase = 1
        boc = n
        if i == numberB - 1:
            break
    elif rase == 1:
        i += 1
        n = 0
        rase = 0
    elif sosuB[i] != sosuA[n] and n == numberA - 1:
        kai = sosuB[i]
        flagB += [kai]
        i += 1
        n = 0
    else:
        n += 1
print(flagB)
i = 0
n = 0
tuika = []
if len(flagA) >= len(flagB):
    while i <= numberB - 1:
        if sosuB[i] == flagA[n]:
            n += 1
            i += 1
        elif n == numberA - 1:
            kai = sosuB[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuB[i] < sosuA[n]:
            kai = sosuB[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagA += tuika
    ans = 1
    for i in flagA:
        ans = ans * i
    print(ans)
else:
    while i <= numberA - 1:
        if sosuA[i] == flagB[n]:
            n += 1
            i += 1
        elif n == numberB - 1:
            kai = sosuA[i]
            tuika += [kai]
            i += 1
            n = 0
        elif sosuA[i] < sosuB[n]:
            kai = sosuA[i]
            tuika += [kai]
            n = 0
            i += 1
        else:
            n += 1
    flagB += tuika
    ans = 1
    for i in flagB:
        ans = ans * i
    print(ans)