typ i = int
typ c = char
typ b = bool
typ pi = ^i
typ pb = ^b

var counter : i
var flag : b
var result : i

fun ext_print(x : i) : i
fun ext_read() : i

fun is_zero(n : i) : b =
    n == 0

fun is_even(n : i) : b =
    n % 2 == 0

fun abs_val(n : i) : i =
    if n < 0 then
        0 - n
    else
        n
    end

fun max(a : i, b : i) : i =
    if a > b then
        a
    else
        b
    end

fun min(a : i, b : i) : i =
    if a < b then
        a
    else
        b
    end

fun pow(base : i, exp : i) : i =
    if is_zero(exp) then
        1
    else
        base * pow(base, exp - 1)
    end

fun gcd(a : i, b : i) : i =
    if is_zero(b) then
        a
    else
        gcd(b, a % b)
    end

fun fib(n : i) : i =
    if n == 0 then
        0
    else
        if n == 1 then
            1
        else
            fib(n - 1) + fib(n - 2)
        end
    end

fun sum_to(n : i) : i =
    if is_zero(n) then
        0
    else
        n + sum_to(n - 1)
    end

fun collatz(n : i) : i =
    if n == 1 then
        0
    else
        if is_even(n) then
            1 + collatz(n / 2)
        else
            1 + collatz(3 * n + 1)
        end
    end

fun ackermann(m : i, n : i) : i =
    if is_zero(m) then
        n + 1
    else
        if is_zero(n) then
            ackermann(m - 1, 1)
        else
            ackermann(m - 1, ackermann(m, n - 1))
        end
    end

fun digit_sum(n : i) : i =
    if n < 10 then
        n
    else
        n % 10 + digit_sum(n / 10)
    end

fun is_palindrome(n : i, rev : i) : b =
    if is_zero(n) then
        n == rev
    else
        is_palindrome(n / 10, rev * 10 + n % 10)
    end

fun count_bits(n : i) : i =
    if is_zero(n) then
        0
    else
        n % 2 + count_bits(n / 2)
    end

fun main() : i =
    let
        var a : i
        var bb : i
        var cc : i
        var dd : i
        var e : i
        var f : b
        var g : b
        typ li = i
        typ lb = b
        fun local_max(x : li, y : li) : li =
            if x > y then
                x
            else
                y
            end
        fun local_and(x : lb, y : lb) : lb =
            x and y
        fun triple(x : li) : li =
            x * 3
        fun compose(x : li) : li =
            triple(triple(x))
    in
        counter = 0,
        result = 0,
        flag = true,
        a = fib(10),
        bb = pow(2, 8),
        cc = gcd(bb, a),
        dd = sum_to(100),
        e = collatz(27),
        f = is_even(a),
        g = is_palindrome(12321, 0),
        result = local_max(a, bb),
        result = compose(result),
        counter = ackermann(3, 2),
        let
            var shadow_a : i
            var shadow_b : i
            var shadow_f : b
            var counter : i
            var result : i
            fun shadow_fib(n : i) : i =
                if n == 0 then
                    0
                else
                    if n == 1 then
                        1
                    else
                        shadow_fib(n - 1) + shadow_fib(n - 2)
                    end
                end
            fun accumulate(n : i, acc : i) : i =
                if is_zero(n) then
                    acc
                else
                    accumulate(n - 1, acc + n)
                end
        in
            shadow_a = shadow_fib(15),
            shadow_b = accumulate(50, 0),
            shadow_f = local_and(f, g),
            counter = digit_sum(shadow_a * shadow_b),
            result = min(shadow_a, shadow_b),
            while counter > 0 do
                if is_even(counter) then
                    result = result + shadow_fib(counter)
                else
                    result = result - digit_sum(counter)
                end,
                counter = counter - 1
            end,
            let
                var deep1 : i
                var deep2 : i
                var deep3 : b
                var deep4 : i
                typ di = i
                fun deep_pow(b : di, e : di) : di =
                    if is_zero(e) then
                        1
                    else
                        b * deep_pow(b, e - 1)
                    end
                fun deep_collatz(n : di) : di =
                    if n == 1 then
                        0
                    else
                        if is_even(n) then
                            1 + deep_collatz(n / 2)
                        else
                            1 + deep_collatz(3 * n + 1)
                        end
                    end
                fun toggle(x : lb) : lb =
                    if x then
                        false
                    else
                        true
                    end
            in
                deep1 = deep_pow(2, counter % 10),
                deep2 = deep_collatz(abs_val(result) + 1),
                deep3 = toggle(shadow_f),
                deep4 = max(deep1, deep2),
                flag = local_and(deep3, is_even(deep4)),
                while deep4 > 0 do
                    if is_even(deep4) then
                        if deep4 > 100 then
                            deep4 = deep4 / 2
                        else
                            deep4 = deep4 - 1
                        end
                    else
                        if is_zero(deep4 % 3) then
                            deep4 = deep4 - 3
                        else
                            deep4 = deep4 * 2 - deep4 - 1
                        end
                    end
                end,
                let
                    var ultra1 : i
                    var ultra2 : b
                    var ultra3 : i
                    fun ultra_gcd(a : i, b : i) : i =
                        if is_zero(b) then
                            a
                        else
                            ultra_gcd(b, a % b)
                        end
                    fun ultra_sum(n : i) : i =
                        if is_zero(n) then
                            0
                        else
                            n + ultra_sum(n - 1)
                        end
                    fun ultra_bits(n : i) : i =
                        if is_zero(n) then
                            0
                        else
                            n % 2 + ultra_bits(n / 2)
                        end
                in
                    ultra1 = ultra_gcd(deep1, deep2),
                    ultra2 = is_even(ultra1),
                    ultra3 = ultra_sum(ultra_bits(deep4 + ultra1)),
                    counter = ultra3 + count_bits(ultra1),
                    result = ext_print(counter),
                    flag = local_and(ultra2, deep3),
                    while ultra3 > 0 do
                        ultra1 = ultra_gcd(ultra3, ultra1 + 1),
                        ultra3 = ultra3 - 1
                    end,
                    ext_print(result),
                    ultra3
                end
            end
        end
    end