fn test_inline_asm() {
    a, mut b := 10, 0
    asm arm64 {
        mov x0, a
        mov b, x0
        ; +r (b)
        ; r (a)
        ; x0
    }
    assert a == 10
    assert b == 10

    mut c := 0
    asm arm64 {
        mov c, 5
        ; +r (c)
    }
    assert c == 5
    d, e, mut f := 10, 2, 0
    asm arm64 {
        mov x0, d
        mov x1, e
        add x0, x0, x1
        add x0, x0, 5
        mov f, x0
        ; +r (f) // output
        ; r (d)
          r (e) // input
        ; x0
          x1
    }
    assert d == 10
    assert e == 2
    assert f == 17

    mut j := 0
    asm arm64 {
        mov x0, 5 // loop 5 times
        mov x1, 0
        loop_start:
        add x1, x1, 3
        sub x0, x0, 1
        cmp x0, 0
        b.gt loop_start
        mov j, x1
        ; +r (j)
        ; ; x0
          x1
    }
    assert j == 5 * 3

    l := 5
    m := &l
    asm arm64 {
        mov w0, 7
        str w0, [m]
        ; ; r (m)
        ; w0
          memory
    }
    assert l == 7
}

fn test_asm_generic() {
    u := u64(49)
    b := unsafe { bool(0) }
    assert generic_asm(u) == 14
    assert u == 63
    assert generic_asm(b) == true
    assert b == true
}

fn generic_asm[T](var &T) T {
    mut ret := unsafe { T(14) }
    unsafe {
        asm volatile arm64 {
            ldr x0, [var]
            add x0, x0, ret
            str x0, [var]
            ; ; r (var)
              r (ret)
            ; x0
              memory
        }
    }
    return ret
}