wasmtime/cranelift/filetests/filetests/isa/x64/i128.clif

test compile precise-output
set enable_llvm_abi_extensions=true
target x86_64

function %f0(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = iadd v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   addq    %rdi, %rdx, %rdi
;   adcq    %rsi, %rcx, %rsi
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f1(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = isub v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   subq    %rdi, %rdx, %rdi
;   sbbq    %rsi, %rcx, %rsi
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f2(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = band v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   andq    %rdi, %rdx, %rdi
;   andq    %rsi, %rcx, %rsi
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f3(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = bor v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   orq     %rdi, %rdx, %rdi
;   orq     %rsi, %rcx, %rsi
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f4(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = bxor v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   xorq    %rdi, %rdx, %rdi
;   xorq    %rsi, %rcx, %rsi
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f5(i128) -> i128 {
block0(v0: i128):
    v1 = bnot v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   notq    %rdi, %rdi
;   notq    %rsi, %rsi
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f6(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = imul v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %r9
;   imulq   %r9, %rcx, %r9
;   imulq   %rsi, %rdx, %rsi
;   movq    %r9, %r8
;   addq    %r8, %rsi, %r8
;   movq    %r8, %r9
;   movq    %rdi, %rax
;   mul     %rax, %rdx, %rax, %rdx
;   movq    %r9, %r11
;   addq    %r11, %rdx, %r11
;   movq    %r11, %r9
;   movq    %r9, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f7(i64, i64) -> i128 {
block0(v0: i64, v1: i64):
    v2 = iconcat.i64 v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f8(i128) -> i64, i64 {
block0(v0: i128):
    v1, v2 = isplit.i128 v0
    return v1, v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f9(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
    v2 = icmp eq v0, v1
    v3 = icmp ne v0, v1
    v4 = icmp slt v0, v1
    v5 = icmp sle v0, v1
    v6 = icmp sgt v0, v1
    v7 = icmp sge v0, v1
    v8 = icmp ult v0, v1
    v9 = icmp ule v0, v1
    v10 = icmp ugt v0, v1
    v11 = icmp uge v0, v1
    v12 = band v2, v3
    v13 = band v4, v5
    v14 = band v6, v7
    v15 = band v8, v9
    v16 = band v10, v11
    v17 = band v12, v13
    v18 = band v14, v15
    v19 = band v17, v18
    v20 = band v19, v16
    return v20
}

;   pushq   %rbp
;   movq    %rsp, %rbp
;   subq    %rsp, $64, %rsp
;   movq    %rbx, 16(%rsp)
;   movq    %r12, 24(%rsp)
;   movq    %r13, 32(%rsp)
;   movq    %r14, 40(%rsp)
;   movq    %r15, 48(%rsp)
; block0:
;   cmpq    %rdx, %rdi
;   setz    %al
;   cmpq    %rcx, %rsi
;   setz    %r8b
;   andq    %rax, %r8, %rax
;   testq   $1, %rax
;   setnz   %al
;   cmpq    %rdx, %rdi
;   setnz   %r8b
;   cmpq    %rcx, %rsi
;   setnz   %r9b
;   orq     %r8, %r9, %r8
;   testq   $1, %r8
;   setnz   %r8b
;   movq    %r8, rsp(0 + virtual offset)
;   cmpq    %rcx, %rsi
;   setl    %r8b
;   setz    %r10b
;   cmpq    %rdx, %rdi
;   setb    %r11b
;   andq    %r10, %r11, %r10
;   orq     %r8, %r10, %r8
;   andq    %r8, $1, %r8
;   cmpq    %rcx, %rsi
;   setl    %r10b
;   setz    %r11b
;   cmpq    %rdx, %rdi
;   setbe   %r13b
;   andq    %r11, %r13, %r11
;   orq     %r10, %r11, %r10
;   andq    %r10, $1, %r10
;   cmpq    %rcx, %rsi
;   setnle  %r11b
;   setz    %r14b
;   cmpq    %rdx, %rdi
;   setnbe  %r15b
;   andq    %r14, %r15, %r14
;   orq     %r11, %r14, %r11
;   andq    %r11, $1, %r11
;   cmpq    %rcx, %rsi
;   setnle  %r12b
;   setz    %bl
;   cmpq    %rdx, %rdi
;   setnb   %r13b
;   andq    %rbx, %r13, %rbx
;   orq     %r12, %rbx, %r12
;   andq    %r12, $1, %r12
;   cmpq    %rcx, %rsi
;   setb    %r13b
;   setz    %r14b
;   cmpq    %rdx, %rdi
;   setb    %r15b
;   andq    %r14, %r15, %r14
;   orq     %r13, %r14, %r13
;   andq    %r13, $1, %r13
;   cmpq    %rcx, %rsi
;   setb    %bl
;   setz    %r15b
;   cmpq    %rdx, %rdi
;   setbe   %r14b
;   andq    %r15, %r14, %r15
;   orq     %rbx, %r15, %rbx
;   andq    %rbx, $1, %rbx
;   cmpq    %rcx, %rsi
;   setnbe  %r14b
;   setz    %r15b
;   cmpq    %rdx, %rdi
;   setnbe  %r9b
;   andq    %r15, %r9, %r15
;   orq     %r14, %r15, %r14
;   andq    %r14, $1, %r14
;   cmpq    %rcx, %rsi
;   setnbe  %sil
;   setz    %cl
;   cmpq    %rdx, %rdi
;   setnb   %dl
;   andq    %rcx, %rdx, %rcx
;   orq     %rsi, %rcx, %rsi
;   andq    %rsi, $1, %rsi
;   movq    rsp(0 + virtual offset), %r9
;   andl    %eax, %r9d, %eax
;   andl    %r8d, %r10d, %r8d
;   andl    %r11d, %r12d, %r11d
;   andl    %r13d, %ebx, %r13d
;   andl    %r14d, %esi, %r14d
;   andl    %eax, %r8d, %eax
;   andl    %r11d, %r13d, %r11d
;   andl    %eax, %r11d, %eax
;   andl    %eax, %r14d, %eax
;   movq    16(%rsp), %rbx
;   movq    24(%rsp), %r12
;   movq    32(%rsp), %r13
;   movq    40(%rsp), %r14
;   movq    48(%rsp), %r15
;   addq    %rsp, $64, %rsp
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f10(i128) -> i32 {
block0(v0: i128):
    brz v0, block1
    jump block2

block1:
    v1 = iconst.i32 1
    return v1

block2:
    v2 = iconst.i32 2
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   cmpq    $0, %rdi
;   setz    %r11b
;   cmpq    $0, %rsi
;   setz    %al
;   andb    %al, %r11b, %al
;   jnz     label1; j label2
; block1:
;   movl    $1, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; block2:
;   movl    $2, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f11(i128) -> i32 {
block0(v0: i128):
    brnz v0, block1
    jump block2

block1:
    v1 = iconst.i32 1
    return v1

block2:
    v2 = iconst.i32 2
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   cmpq    $0, %rdi
;   setnz   %r11b
;   cmpq    $0, %rsi
;   setnz   %al
;   orb     %al, %r11b, %al
;   jnz     label1; j label2
; block1:
;   movl    $1, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; block2:
;   movl    $2, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f12(i64) -> i128 {
block0(v0: i64):
    v1 = uextend.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   xorq    %rdx, %rdx, %rdx
;   movq    %rdi, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f13(i64) -> i128 {
block0(v0: i64):
    v1 = sextend.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rdx
;   sarq    $63, %rdx, %rdx
;   movq    %rdi, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f14(i8) -> i128 {
block0(v0: i8):
    v1 = sextend.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movsbq  %dil, %rax
;   movq    %rax, %rdx
;   sarq    $63, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f15(i8) -> i128 {
block0(v0: i8):
    v1 = uextend.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movzbq  %dil, %rax
;   xorq    %rdx, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f16(i128) -> i64 {
block0(v0: i128):
    v1 = ireduce.i64 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f17(i128) -> i8 {
block0(v0: i128):
    v1 = ireduce.i8 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f18(b1) -> i128 {
block0(v0: b1):
    v1 = bint.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   andq    %rdi, $1, %rdi
;   xorq    %rdx, %rdx, %rdx
;   movq    %rdi, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f19(i128) -> i128 {
block0(v0: i128):
    v1 = popcnt.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %r8
;   shrq    $1, %r8, %r8
;   movabsq $8608480567731124087, %r11
;   andq    %r8, %r11, %r8
;   subq    %rdi, %r8, %rdi
;   shrq    $1, %r8, %r8
;   andq    %r8, %r11, %r8
;   subq    %rdi, %r8, %rdi
;   shrq    $1, %r8, %r8
;   andq    %r8, %r11, %r8
;   subq    %rdi, %r8, %rdi
;   movq    %rdi, %rax
;   shrq    $4, %rax, %rax
;   addq    %rax, %rdi, %rax
;   movabsq $1085102592571150095, %rcx
;   andq    %rax, %rcx, %rax
;   movabsq $72340172838076673, %r10
;   imulq   %rax, %r10, %rax
;   shrq    $56, %rax, %rax
;   movq    %rsi, %rcx
;   shrq    $1, %rcx, %rcx
;   movabsq $8608480567731124087, %r9
;   andq    %rcx, %r9, %rcx
;   subq    %rsi, %rcx, %rsi
;   shrq    $1, %rcx, %rcx
;   andq    %rcx, %r9, %rcx
;   subq    %rsi, %rcx, %rsi
;   shrq    $1, %rcx, %rcx
;   andq    %rcx, %r9, %rcx
;   subq    %rsi, %rcx, %rsi
;   movq    %rsi, %rcx
;   shrq    $4, %rcx, %rcx
;   addq    %rcx, %rsi, %rcx
;   movabsq $1085102592571150095, %rdi
;   andq    %rcx, %rdi, %rcx
;   movabsq $72340172838076673, %r8
;   imulq   %rcx, %r8, %rcx
;   shrq    $56, %rcx, %rcx
;   addq    %rax, %rcx, %rax
;   xorq    %rdx, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f20(i128) -> i128 {
block0(v0: i128):
    v1 = bitrev.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movabsq $6148914691236517205, %r9
;   movq    %rsi, %r10
;   andq    %r10, %r9, %r10
;   shrq    $1, %rsi, %rsi
;   andq    %rsi, %r9, %rsi
;   shlq    $1, %r10, %r10
;   orq     %r10, %rsi, %r10
;   movabsq $3689348814741910323, %rsi
;   movq    %r10, %rax
;   andq    %rax, %rsi, %rax
;   shrq    $2, %r10, %r10
;   andq    %r10, %rsi, %r10
;   shlq    $2, %rax, %rax
;   orq     %rax, %r10, %rax
;   movabsq $1085102592571150095, %rcx
;   movq    %rax, %rdx
;   andq    %rdx, %rcx, %rdx
;   shrq    $4, %rax, %rax
;   andq    %rax, %rcx, %rax
;   shlq    $4, %rdx, %rdx
;   orq     %rdx, %rax, %rdx
;   movabsq $71777214294589695, %r9
;   movq    %rdx, %r10
;   andq    %r10, %r9, %r10
;   shrq    $8, %rdx, %rdx
;   andq    %rdx, %r9, %rdx
;   shlq    $8, %r10, %r10
;   orq     %r10, %rdx, %r10
;   movabsq $281470681808895, %rax
;   movq    %r10, %rsi
;   andq    %rsi, %rax, %rsi
;   shrq    $16, %r10, %r10
;   andq    %r10, %rax, %r10
;   shlq    $16, %rsi, %rsi
;   orq     %rsi, %r10, %rsi
;   movabsq $4294967295, %rcx
;   movq    %rsi, %rax
;   andq    %rax, %rcx, %rax
;   shrq    $32, %rsi, %rsi
;   shlq    $32, %rax, %rax
;   orq     %rax, %rsi, %rax
;   movabsq $6148914691236517205, %rdx
;   movq    %rdi, %r8
;   andq    %r8, %rdx, %r8
;   shrq    $1, %rdi, %rdi
;   andq    %rdi, %rdx, %rdi
;   shlq    $1, %r8, %r8
;   orq     %r8, %rdi, %r8
;   movabsq $3689348814741910323, %r10
;   movq    %r8, %r11
;   andq    %r11, %r10, %r11
;   shrq    $2, %r8, %r8
;   andq    %r8, %r10, %r8
;   shlq    $2, %r11, %r11
;   orq     %r11, %r8, %r11
;   movabsq $1085102592571150095, %rdi
;   movq    %r11, %rcx
;   andq    %rcx, %rdi, %rcx
;   shrq    $4, %r11, %r11
;   andq    %r11, %rdi, %r11
;   shlq    $4, %rcx, %rcx
;   orq     %rcx, %r11, %rcx
;   movabsq $71777214294589695, %rdx
;   movq    %rcx, %r8
;   andq    %r8, %rdx, %r8
;   shrq    $8, %rcx, %rcx
;   andq    %rcx, %rdx, %rcx
;   shlq    $8, %r8, %r8
;   orq     %r8, %rcx, %r8
;   movabsq $281470681808895, %r11
;   movq    %r8, %r10
;   andq    %r10, %r11, %r10
;   shrq    $16, %r8, %r8
;   andq    %r8, %r11, %r8
;   shlq    $16, %r10, %r10
;   orq     %r10, %r8, %r10
;   movabsq $4294967295, %rdi
;   movq    %r10, %rdx
;   andq    %rdx, %rdi, %rdx
;   shrq    $32, %r10, %r10
;   shlq    $32, %rdx, %rdx
;   orq     %rdx, %r10, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f21(i128, i64) {
block0(v0: i128, v1: i64):
    store.i128 v0, v1
    return
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, 0(%rdx)
;   movq    %rsi, 8(%rdx)
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f22(i64) -> i128 {
block0(v0: i64):
    v1 = load.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    0(%rdi), %rax
;   movq    8(%rdi), %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f23(i128, b1) -> i128 {
block0(v0: i128, v1: b1):
    v2 = iconst.i128 0
    brnz v1, block1(v2)
    jump block2(v2)

block1(v3: i128):
    v4 = iconst.i128 1
    v5 = iadd.i128 v3, v4
    return v5

block2(v6: i128):
    v7 = iconst.i128 2
    v8 = iadd.i128 v6, v7
    return v8
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   testb   $1, %dl
;   jnz     label1; j label2
; block1:
;   xorq    %rax, %rax, %rax
;   xorq    %rdx, %rdx, %rdx
;   movl    $1, %ecx
;   xorq    %r8, %r8, %r8
;   addq    %rax, %rcx, %rax
;   adcq    %rdx, %r8, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; block2:
;   xorq    %rax, %rax, %rax
;   xorq    %rdx, %rdx, %rdx
;   movl    $2, %r10d
;   xorq    %rsi, %rsi, %rsi
;   addq    %rax, %r10, %rax
;   adcq    %rdx, %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f24(i128, i128, i64, i128, i128, i128) -> i128 {

block0(v0: i128, v1: i128, v2: i64, v3: i128, v4: i128, v5: i128):
    v6 = iadd.i128 v0, v1
    v7 = uextend.i128 v2
    v8 = iadd.i128 v3, v7
    v9 = iadd.i128 v4, v5
    v10 = iadd.i128 v6, v8
    v11 = iadd.i128 v9, v10
    return v11
}

;   pushq   %rbp
;   movq    %rsp, %rbp
;   subq    %rsp, $32, %rsp
;   movq    %r13, 16(%rsp)
;   movq    %r15, 24(%rsp)
; block0:
;   movq    %rdx, rsp(0 + virtual offset)
;   movq    16(%rbp), %r10
;   movq    24(%rbp), %rax
;   movq    32(%rbp), %rdx
;   movq    40(%rbp), %r15
;   movq    48(%rbp), %r11
;   movq    rsp(0 + virtual offset), %r13
;   addq    %rdi, %r13, %rdi
;   adcq    %rsi, %rcx, %rsi
;   xorq    %rcx, %rcx, %rcx
;   addq    %r9, %r8, %r9
;   adcq    %r10, %rcx, %r10
;   addq    %rax, %r15, %rax
;   adcq    %rdx, %r11, %rdx
;   addq    %rdi, %r9, %rdi
;   adcq    %rsi, %r10, %rsi
;   addq    %rax, %rdi, %rax
;   adcq    %rdx, %rsi, %rdx
;   movq    16(%rsp), %r13
;   movq    24(%rsp), %r15
;   addq    %rsp, $32, %rsp
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f25(i128) -> i128, i128, i128, i64, i128, i128 {
block0(v0: i128):
    v1 = ireduce.i64 v0
    return v0, v0, v0, v1, v0, v0
}

;   pushq   %rbp
;   movq    %rsp, %rbp
;   subq    %rsp, $32, %rsp
;   movq    %rbx, 0(%rsp)
;   movq    %r13, 8(%rsp)
;   movq    %r14, 16(%rsp)
; block0:
;   movq    %rdx, %r14
;   movq    %rdi, %rax
;   movq    %rsi, %rdx
;   movq    %rdi, %rbx
;   movq    %rsi, %r13
;   movq    %rdi, %r11
;   movq    %rsi, %r10
;   movq    %rdi, %r9
;   movq    %rdi, %rcx
;   movq    %rsi, %r8
;   movq    %rbx, 0(%r14)
;   movq    %r13, 8(%r14)
;   movq    %r11, 16(%r14)
;   movq    %r10, 24(%r14)
;   movq    %r9, 32(%r14)
;   movq    %rcx, 40(%r14)
;   movq    %r8, 48(%r14)
;   movq    %rdi, 56(%r14)
;   movq    %rsi, 64(%r14)
;   movq    0(%rsp), %rbx
;   movq    8(%rsp), %r13
;   movq    16(%rsp), %r14
;   addq    %rsp, $32, %rsp
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f26(i128, i128) -> i128, i128 {
    fn0 = %g(i128, i128) -> i128, i128
block0(v0: i128, v1: i128):
    v2, v3 = call fn0(v0, v1)
    return v2, v3
}

;   pushq   %rbp
;   movq    %rsp, %rbp
;   subq    %rsp, $16, %rsp
;   movq    %r12, 0(%rsp)
; block0:
;   movq    %r8, %r12
;   subq    %rsp, $16, %rsp
;   virtual_sp_offset_adjust 16
;   lea     0(%rsp), %r8
;   load_ext_name %g+0, %r9
;   call    *%r9
;   movq    0(%rsp), %rcx
;   movq    8(%rsp), %r8
;   addq    %rsp, $16, %rsp
;   virtual_sp_offset_adjust -16
;   movq    %r12, %r9
;   movq    %rcx, 0(%r9)
;   movq    %r8, 8(%r9)
;   movq    0(%rsp), %r12
;   addq    %rsp, $16, %rsp
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f27(i128) -> i128 {
block0(v0: i128):
    v1 = clz.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movabsq $-1, %r9
;   bsrq    %rsi, %rsi
;   cmovzq  %r9, %rsi, %rsi
;   movl    $63, %edx
;   subq    %rdx, %rsi, %rdx
;   movabsq $-1, %r10
;   bsrq    %rdi, %rdi
;   cmovzq  %r10, %rdi, %rdi
;   movl    $63, %eax
;   subq    %rax, %rdi, %rax
;   addq    %rax, $64, %rax
;   cmpq    $64, %rdx
;   cmovnzq %rdx, %rax, %rax
;   xorq    %rdx, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f28(i128) -> i128 {
block0(v0: i128):
    v1 = ctz.i128 v0
    return v1
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movl    $64, %r9d
;   bsfq    %rdi, %rax
;   cmovzq  %r9, %rax, %rax
;   movl    $64, %ecx
;   bsfq    %rsi, %r10
;   cmovzq  %rcx, %r10, %r10
;   addq    %r10, $64, %r10
;   cmpq    $64, %rax
;   cmovzq  %r10, %rax, %rax
;   xorq    %rdx, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f29(i8, i128) -> i8 {
block0(v0: i8, v1: i128):
    v2 = ishl v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %r9
;   movq    %r9, %rcx
;   shlb    %cl, %dil, %dil
;   movq    %rdi, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f30(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = ishl v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %rax
;   movq    %rax, %rcx
;   movq    %rdi, %rdx
;   shlq    %cl, %rdx, %rdx
;   shlq    %cl, %rsi, %rsi
;   movl    $64, %ecx
;   movq    %rax, %r11
;   subq    %rcx, %r11, %rcx
;   shrq    %cl, %rdi, %rdi
;   xorq    %rax, %rax, %rax
;   testq   $127, %r11
;   cmovzq  %rax, %rdi, %rdi
;   orq     %rdi, %rsi, %rdi
;   testq   $64, %r11
;   cmovzq  %rdx, %rax, %rax
;   cmovzq  %rdi, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f31(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = ushr v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %r9
;   movq    %r9, %rcx
;   shrq    %cl, %rdi, %rdi
;   movq    %rsi, %r8
;   shrq    %cl, %r8, %r8
;   movl    $64, %ecx
;   subq    %rcx, %r9, %rcx
;   shlq    %cl, %rsi, %rsi
;   xorq    %rax, %rax, %rax
;   testq   $127, %r9
;   cmovzq  %rax, %rsi, %rsi
;   orq     %rsi, %rdi, %rsi
;   xorq    %rdx, %rdx, %rdx
;   testq   $64, %r9
;   movq    %r8, %rax
;   cmovzq  %rsi, %rax, %rax
;   cmovzq  %r8, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f32(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = sshr v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %r8
;   movq    %r8, %rcx
;   shrq    %cl, %rdi, %rdi
;   movq    %rsi, %rdx
;   sarq    %cl, %rdx, %rdx
;   movl    $64, %ecx
;   movq    %r8, %r9
;   subq    %rcx, %r9, %rcx
;   movq    %rsi, %rax
;   shlq    %cl, %rax, %rax
;   xorq    %r8, %r8, %r8
;   testq   $127, %r9
;   cmovzq  %r8, %rax, %rax
;   orq     %rdi, %rax, %rdi
;   sarq    $63, %rsi, %rsi
;   testq   $64, %r9
;   movq    %rdx, %rax
;   cmovzq  %rdi, %rax, %rax
;   cmovzq  %rdx, %rsi, %rsi
;   movq    %rsi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f33(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = rotl v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %r11
;   movq    %r11, %rcx
;   movq    %rdi, %rdx
;   shlq    %cl, %rdx, %rdx
;   movq    %rsi, %r9
;   shlq    %cl, %r9, %r9
;   movl    $64, %ecx
;   movq    %r11, %r10
;   subq    %rcx, %r10, %rcx
;   movq    %rdi, %r8
;   shrq    %cl, %r8, %r8
;   xorq    %rax, %rax, %rax
;   testq   $127, %r10
;   cmovzq  %rax, %r8, %r8
;   orq     %r8, %r9, %r8
;   testq   $64, %r10
;   cmovzq  %rdx, %rax, %rax
;   cmovzq  %r8, %rdx, %rdx
;   movl    $128, %ecx
;   movq    %r11, %r9
;   subq    %rcx, %r9, %rcx
;   shrq    %cl, %rdi, %rdi
;   movq    %rsi, %r8
;   shrq    %cl, %r8, %r8
;   movq    %rcx, %r9
;   movl    $64, %ecx
;   movq    %r9, %r10
;   subq    %rcx, %r10, %rcx
;   shlq    %cl, %rsi, %rsi
;   xorq    %r9, %r9, %r9
;   testq   $127, %r10
;   cmovzq  %r9, %rsi, %rsi
;   orq     %rsi, %rdi, %rsi
;   xorq    %rdi, %rdi, %rdi
;   testq   $64, %r10
;   movq    %r8, %rcx
;   cmovzq  %rsi, %rcx, %rcx
;   cmovzq  %r8, %rdi, %rdi
;   orq     %rax, %rcx, %rax
;   orq     %rdx, %rdi, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret

function %f34(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
    v2 = rotr v0, v1
    return v2
}

;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %r11
;   movq    %r11, %rcx
;   movq    %rdi, %rax
;   shrq    %cl, %rax, %rax
;   movq    %rsi, %r8
;   shrq    %cl, %r8, %r8
;   movl    $64, %ecx
;   movq    %r11, %r10
;   subq    %rcx, %r10, %rcx
;   movq    %rsi, %r9
;   shlq    %cl, %r9, %r9
;   xorq    %rdx, %rdx, %rdx
;   testq   $127, %r10
;   cmovzq  %rdx, %r9, %r9
;   orq     %r9, %rax, %r9
;   xorq    %rdx, %rdx, %rdx
;   testq   $64, %r10
;   movq    %r8, %rax
;   cmovzq  %r9, %rax, %rax
;   cmovzq  %r8, %rdx, %rdx
;   movl    $128, %ecx
;   subq    %rcx, %r10, %rcx
;   movq    %rdi, %r8
;   shlq    %cl, %r8, %r8
;   shlq    %cl, %rsi, %rsi
;   movq    %rcx, %r9
;   movl    $64, %ecx
;   movq    %r9, %r10
;   subq    %rcx, %r10, %rcx
;   shrq    %cl, %rdi, %rdi
;   xorq    %r9, %r9, %r9
;   testq   $127, %r10
;   cmovzq  %r9, %rdi, %rdi
;   orq     %rdi, %rsi, %rdi
;   testq   $64, %r10
;   cmovzq  %r8, %r9, %r9
;   cmovzq  %rdi, %r8, %r8
;   orq     %rax, %r9, %rax
;   orq     %rdx, %r8, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret