Columns

Show Target

Show Op

Show C++ Code

Show Compiler Output

Filter

Sign: Show All Unsigned Signed

Bits: Show All Multiples of 4 Multiples of 8 Register Widths

Target: Show All x86-64 ARM ARM64

Operation: Show All add subtract multiply divide

Note: You can sort by each column by clicking on the column header.

Target	Bits	Op	Signed	C++ Code	Compiler Output
x86_64	4	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return adds<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax addb %dil, %dil andb $16, %dil addb $112, %dil sarb $4, %dil movzbl %dil, %ecx xorb %sil, %dil xorb %al, %sil notb %sil orb %dil, %sil shlb $4, %al sarb $4, %al testb $8, %sil movzbl %al, %eax cmovel %ecx, %eax movsbl %al, %eax popq %rbp retq
x86_64	4	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return addu<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movl %eax, %ecx andb $15, %cl cmpb $16, %al movzbl %cl, %eax movl $15, %ecx cmovael %ecx, %eax addb %dil, %sil cmovbl %ecx, %eax movzbl %al, %eax popq %rbp retq
x86_64	5	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return adds<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrb %dil andb $8, %dil addb $120, %dil sarb $3, %dil movzbl %dil, %ecx xorb %sil, %dil xorb %al, %sil notb %sil orb %dil, %sil shlb $3, %al sarb $3, %al testb $16, %sil movzbl %al, %eax cmovel %ecx, %eax movsbl %al, %eax popq %rbp retq
x86_64	5	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return addu<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movl %eax, %ecx andb $31, %cl cmpb $32, %al movzbl %cl, %eax movl $31, %ecx cmovael %ecx, %eax addb %dil, %sil cmovbl %ecx, %eax movzbl %al, %eax popq %rbp retq
x86_64	6	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return adds<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrb $3, %dil andb $4, %dil addb $124, %dil sarb $2, %dil movzbl %dil, %ecx xorb %sil, %dil xorb %al, %sil notb %sil orb %dil, %sil shlb $2, %al sarb $2, %al testb $32, %sil movzbl %al, %eax cmovel %ecx, %eax movsbl %al, %eax popq %rbp retq
x86_64	6	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return addu<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movl %eax, %ecx andb $63, %cl cmpb $64, %al movzbl %cl, %eax movl $63, %ecx cmovael %ecx, %eax addb %dil, %sil cmovbl %ecx, %eax movzbl %al, %eax popq %rbp retq
x86_64	7	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return adds<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrb $5, %dil andb $2, %dil addb $126, %dil sarb %dil movzbl %dil, %ecx xorb %sil, %dil xorb %al, %sil notb %sil orb %dil, %sil addb %al, %al sarb %al testb $64, %sil movzbl %al, %eax cmovel %ecx, %eax movsbl %al, %eax popq %rbp retq
x86_64	7	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return addu<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp addb %dil, %sil setb %al movl %esi, %ecx shrb $7, %cl orb %al, %cl negb %cl orb %sil, %cl andb $127, %cl movzbl %cl, %eax popq %rbp retq
x86_64	8	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return adds<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrb $7, %dil addb $127, %dil movzbl %dil, %ecx xorb %sil, %dil xorb %al, %sil notb %sil orb %dil, %sil movzbl %al, %eax cmovnsl %ecx, %eax movsbl %al, %eax popq %rbp retq
x86_64	8	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return addu<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp addb %sil, %dil sbbb %al, %al orb %al, %dil movzbl %dil, %eax popq %rbp retq
x86_64	9	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return adds<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl %edi andl $128, %edi addl $32640, %edi ## imm = 0x7F80 movswl %di, %ecx sarl $7, %ecx movl %ecx, %edx xorl %esi, %edx xorl %eax, %esi notl %esi orl %edx, %esi shll $7, %eax cwtl sarl $7, %eax testl $256, %esi ## imm = 0x100 cmovel %ecx, %eax cwtl popq %rbp retq
x86_64	9	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return addu<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movzwl %ax, %ecx andl $511, %eax ## imm = 0x1FF cmpl $512, %ecx ## imm = 0x200 movl $511, %ecx ## imm = 0x1FF cmovael %ecx, %eax addw %di, %si cmovbl %ecx, %eax popq %rbp retq
x86_64	10	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return adds<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $3, %edi andl $64, %edi addl $32704, %edi ## imm = 0x7FC0 movswl %di, %ecx sarl $6, %ecx movl %ecx, %edx xorl %esi, %edx xorl %eax, %esi notl %esi orl %edx, %esi shll $6, %eax cwtl sarl $6, %eax testl $512, %esi ## imm = 0x200 cmovel %ecx, %eax cwtl popq %rbp retq
x86_64	10	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return addu<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movzwl %ax, %ecx andl $1023, %eax ## imm = 0x3FF cmpl $1024, %ecx ## imm = 0x400 movl $1023, %ecx ## imm = 0x3FF cmovael %ecx, %eax addw %di, %si cmovbl %ecx, %eax popq %rbp retq
x86_64	11	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return adds<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $5, %edi andl $32, %edi addl $32736, %edi ## imm = 0x7FE0 movswl %di, %ecx sarl $5, %ecx movl %ecx, %edx xorl %esi, %edx xorl %eax, %esi notl %esi orl %edx, %esi shll $5, %eax cwtl sarl $5, %eax testl $1024, %esi ## imm = 0x400 cmovel %ecx, %eax cwtl popq %rbp retq
x86_64	11	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return addu<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movzwl %ax, %ecx andl $2047, %eax ## imm = 0x7FF cmpl $2048, %ecx ## imm = 0x800 movl $2047, %ecx ## imm = 0x7FF cmovael %ecx, %eax addw %di, %si cmovbl %ecx, %eax popq %rbp retq
x86_64	12	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return adds<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $7, %edi andl $16, %edi addl $32752, %edi ## imm = 0x7FF0 movswl %di, %ecx sarl $4, %ecx movl %ecx, %edx xorl %esi, %edx xorl %eax, %esi notl %esi orl %edx, %esi shll $4, %eax cwtl sarl $4, %eax testl $2048, %esi ## imm = 0x800 cmovel %ecx, %eax cwtl popq %rbp retq
x86_64	12	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return addu<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movzwl %ax, %ecx andl $4095, %eax ## imm = 0xFFF cmpl $4096, %ecx ## imm = 0x1000 movl $4095, %ecx ## imm = 0xFFF cmovael %ecx, %eax addw %di, %si cmovbl %ecx, %eax popq %rbp retq
x86_64	13	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return adds<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $9, %edi andl $8, %edi addl $32760, %edi ## imm = 0x7FF8 movswl %di, %ecx sarl $3, %ecx movl %ecx, %edx xorl %esi, %edx xorl %eax, %esi notl %esi orl %edx, %esi shll $3, %eax cwtl sarl $3, %eax testl $4096, %esi ## imm = 0x1000 cmovel %ecx, %eax cwtl popq %rbp retq
x86_64	13	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return addu<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movzwl %ax, %ecx andl $8191, %eax ## imm = 0x1FFF cmpl $8192, %ecx ## imm = 0x2000 movl $8191, %ecx ## imm = 0x1FFF cmovael %ecx, %eax addw %di, %si cmovbl %ecx, %eax popq %rbp retq
x86_64	14	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return adds<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $11, %edi andl $4, %edi addl $32764, %edi ## imm = 0x7FFC movswl %di, %ecx sarl $2, %ecx movl %ecx, %edx xorl %esi, %edx xorl %eax, %esi notl %esi orl %edx, %esi shll $2, %eax cwtl sarl $2, %eax testl $8192, %esi ## imm = 0x2000 cmovel %ecx, %eax cwtl popq %rbp retq
x86_64	14	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return addu<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax movzwl %ax, %ecx andl $16383, %eax ## imm = 0x3FFF cmpl $16384, %ecx ## imm = 0x4000 movl $16383, %ecx ## imm = 0x3FFF cmovael %ecx, %eax addw %di, %si cmovbl %ecx, %eax popq %rbp retq
x86_64	15	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return adds<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $13, %edi andl $2, %edi addl $32766, %edi ## imm = 0x7FFE movswl %di, %ecx sarl %ecx movl %ecx, %edx xorl %esi, %edx xorl %eax, %esi notl %esi orl %edx, %esi addl %eax, %eax cwtl sarl %eax testl $16384, %esi ## imm = 0x4000 cmovel %ecx, %eax cwtl popq %rbp retq
x86_64	15	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return addu<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx addw %di, %si movzwl %si, %edx setb %cl movl %edx, %eax shrl $15, %eax orl %ecx, %eax negl %eax orl %edx, %eax andl $32767, %eax ## imm = 0x7FFF popq %rbp retq
x86_64	16	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return adds<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movzwl %di, %eax movl %eax, %ecx shrl $15, %ecx addl $32767, %ecx ## imm = 0x7FFF addw %si, %ax cmovow %cx, %ax cwtl popq %rbp retq
x86_64	16	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return addu<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp addw %si, %di sbbw %ax, %ax orl %eax, %edi movzwl %di, %eax popq %rbp retq
x86_64	17	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return adds<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl %edi andl $32768, %edi ## imm = 0x8000 addl $2147450880, %edi ## imm = 0x7FFF8000 sarl $15, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $15, %eax sarl $15, %eax testl $65536, %esi ## imm = 0x10000 cmovel %edi, %eax popq %rbp retq
x86_64	17	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return addu<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $131071, %eax ## imm = 0x1FFFF cmpl $131072, %ecx ## imm = 0x20000 movl $131071, %ecx ## imm = 0x1FFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	18	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return adds<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $3, %edi andl $16384, %edi ## imm = 0x4000 addl $2147467264, %edi ## imm = 0x7FFFC000 sarl $14, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $14, %eax sarl $14, %eax testl $131072, %esi ## imm = 0x20000 cmovel %edi, %eax popq %rbp retq
x86_64	18	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return addu<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $262143, %eax ## imm = 0x3FFFF cmpl $262144, %ecx ## imm = 0x40000 movl $262143, %ecx ## imm = 0x3FFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	19	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return adds<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $5, %edi andl $8192, %edi ## imm = 0x2000 addl $2147475456, %edi ## imm = 0x7FFFE000 sarl $13, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $13, %eax sarl $13, %eax testl $262144, %esi ## imm = 0x40000 cmovel %edi, %eax popq %rbp retq
x86_64	19	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return addu<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $524287, %eax ## imm = 0x7FFFF cmpl $524288, %ecx ## imm = 0x80000 movl $524287, %ecx ## imm = 0x7FFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	20	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return adds<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $7, %edi andl $4096, %edi ## imm = 0x1000 addl $2147479552, %edi ## imm = 0x7FFFF000 sarl $12, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $12, %eax sarl $12, %eax testl $524288, %esi ## imm = 0x80000 cmovel %edi, %eax popq %rbp retq
x86_64	20	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return addu<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $1048575, %eax ## imm = 0xFFFFF cmpl $1048576, %ecx ## imm = 0x100000 movl $1048575, %ecx ## imm = 0xFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	21	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return adds<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $9, %edi andl $2048, %edi ## imm = 0x800 addl $2147481600, %edi ## imm = 0x7FFFF800 sarl $11, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $11, %eax sarl $11, %eax testl $1048576, %esi ## imm = 0x100000 cmovel %edi, %eax popq %rbp retq
x86_64	21	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return addu<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $2097151, %eax ## imm = 0x1FFFFF cmpl $2097152, %ecx ## imm = 0x200000 movl $2097151, %ecx ## imm = 0x1FFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	22	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return adds<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $11, %edi andl $1024, %edi ## imm = 0x400 addl $2147482624, %edi ## imm = 0x7FFFFC00 sarl $10, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $10, %eax sarl $10, %eax testl $2097152, %esi ## imm = 0x200000 cmovel %edi, %eax popq %rbp retq
x86_64	22	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return addu<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $4194303, %eax ## imm = 0x3FFFFF cmpl $4194304, %ecx ## imm = 0x400000 movl $4194303, %ecx ## imm = 0x3FFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	23	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return adds<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $13, %edi andl $512, %edi ## imm = 0x200 addl $2147483136, %edi ## imm = 0x7FFFFE00 sarl $9, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $9, %eax sarl $9, %eax testl $4194304, %esi ## imm = 0x400000 cmovel %edi, %eax popq %rbp retq
x86_64	23	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return addu<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $8388607, %eax ## imm = 0x7FFFFF cmpl $8388608, %ecx ## imm = 0x800000 movl $8388607, %ecx ## imm = 0x7FFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	24	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return adds<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $15, %edi andl $256, %edi ## imm = 0x100 addl $2147483392, %edi ## imm = 0x7FFFFF00 sarl $8, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $8, %eax sarl $8, %eax testl $8388608, %esi ## imm = 0x800000 cmovel %edi, %eax popq %rbp retq
x86_64	24	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return addu<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $16777215, %eax ## imm = 0xFFFFFF cmpl $16777216, %ecx ## imm = 0x1000000 movl $16777215, %ecx ## imm = 0xFFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	25	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return adds<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $17, %edi andl $128, %edi addl $2147483520, %edi ## imm = 0x7FFFFF80 sarl $7, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $7, %eax sarl $7, %eax testl $16777216, %esi ## imm = 0x1000000 cmovel %edi, %eax popq %rbp retq
x86_64	25	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return addu<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $33554431, %eax ## imm = 0x1FFFFFF cmpl $33554432, %ecx ## imm = 0x2000000 movl $33554431, %ecx ## imm = 0x1FFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	26	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return adds<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $19, %edi andl $64, %edi addl $2147483584, %edi ## imm = 0x7FFFFFC0 sarl $6, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $6, %eax sarl $6, %eax testl $33554432, %esi ## imm = 0x2000000 cmovel %edi, %eax popq %rbp retq
x86_64	26	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return addu<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $67108863, %eax ## imm = 0x3FFFFFF cmpl $67108864, %ecx ## imm = 0x4000000 movl $67108863, %ecx ## imm = 0x3FFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	27	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return adds<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $21, %edi andl $32, %edi addl $2147483616, %edi ## imm = 0x7FFFFFE0 sarl $5, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $5, %eax sarl $5, %eax testl $67108864, %esi ## imm = 0x4000000 cmovel %edi, %eax popq %rbp retq
x86_64	27	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return addu<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $134217727, %eax ## imm = 0x7FFFFFF cmpl $134217728, %ecx ## imm = 0x8000000 movl $134217727, %ecx ## imm = 0x7FFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	28	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return adds<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $23, %edi andl $16, %edi addl $2147483632, %edi ## imm = 0x7FFFFFF0 sarl $4, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $4, %eax sarl $4, %eax testl $134217728, %esi ## imm = 0x8000000 cmovel %edi, %eax popq %rbp retq
x86_64	28	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return addu<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $268435455, %eax ## imm = 0xFFFFFFF cmpl $268435456, %ecx ## imm = 0x10000000 movl $268435455, %ecx ## imm = 0xFFFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	29	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return adds<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $25, %edi andl $8, %edi addl $2147483640, %edi ## imm = 0x7FFFFFF8 sarl $3, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $3, %eax sarl $3, %eax testl $268435456, %esi ## imm = 0x10000000 cmovel %edi, %eax popq %rbp retq
x86_64	29	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return addu<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $536870911, %eax ## imm = 0x1FFFFFFF cmpl $536870912, %ecx ## imm = 0x20000000 movl $536870911, %ecx ## imm = 0x1FFFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	30	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return adds<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $27, %edi andl $4, %edi addl $2147483644, %edi ## imm = 0x7FFFFFFC sarl $2, %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi shll $2, %eax sarl $2, %eax testl $536870912, %esi ## imm = 0x20000000 cmovel %edi, %eax popq %rbp retq
x86_64	30	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return addu<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %ecx movl %ecx, %eax andl $1073741823, %eax ## imm = 0x3FFFFFFF cmpl $1073741824, %ecx ## imm = 0x40000000 movl $1073741823, %ecx ## imm = 0x3FFFFFFF cmovael %ecx, %eax addl %esi, %edi cmovbl %ecx, %eax popq %rbp retq
x86_64	31	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return adds<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal (%rsi,%rdi), %eax shrl $29, %edi andl $2, %edi addl $2147483646, %edi ## imm = 0x7FFFFFFE sarl %edi movl %edi, %ecx xorl %esi, %ecx xorl %eax, %esi notl %esi orl %ecx, %esi addl %eax, %eax sarl %eax testl $1073741824, %esi ## imm = 0x40000000 cmovel %edi, %eax popq %rbp retq
x86_64	31	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return addu<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx addl %esi, %edi setb %cl movl %edi, %eax shrl $31, %eax orl %ecx, %eax negl %eax orl %edi, %eax andl $2147483647, %eax ## imm = 0x7FFFFFFF popq %rbp retq
x86_64	32	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return adds<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %edi, %ecx shrl $31, %ecx addl $2147483647, %ecx ## imm = 0x7FFFFFFF addl %esi, %eax cmovol %ecx, %eax popq %rbp retq
x86_64	32	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return addu<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp addl %esi, %edi sbbl %eax, %eax orl %edi, %eax popq %rbp retq
x86_64	33	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return adds<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq %rdi andl $-2147483648, %edi ## imm = 0x80000000 movabsq $9223372034707292160, %rcx ## imm = 0x7FFFFFFF80000000 addq %rdi, %rcx sarq $31, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $31, %rax sarq $31, %rax btq $32, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	33	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return addu<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $33, %rcx movabsq $8589934591, %rdx ## imm = 0x1FFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	34	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return adds<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $3, %rdi andl $1073741824, %edi ## imm = 0x40000000 movabsq $9223372035781033984, %rcx ## imm = 0x7FFFFFFFC0000000 addq %rdi, %rcx sarq $30, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $30, %rax sarq $30, %rax btq $33, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	34	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return addu<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $34, %rcx movabsq $17179869183, %rdx ## imm = 0x3FFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	35	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return adds<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $5, %rdi andl $536870912, %edi ## imm = 0x20000000 movabsq $9223372036317904896, %rcx ## imm = 0x7FFFFFFFE0000000 addq %rdi, %rcx sarq $29, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $29, %rax sarq $29, %rax btq $34, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	35	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return addu<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $35, %rcx movabsq $34359738367, %rdx ## imm = 0x7FFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	36	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return adds<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $7, %rdi andl $268435456, %edi ## imm = 0x10000000 movabsq $9223372036586340352, %rcx ## imm = 0x7FFFFFFFF0000000 addq %rdi, %rcx sarq $28, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $28, %rax sarq $28, %rax btq $35, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	36	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return addu<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $36, %rcx movabsq $68719476735, %rdx ## imm = 0xFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	37	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return adds<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $9, %rdi andl $134217728, %edi ## imm = 0x8000000 movabsq $9223372036720558080, %rcx ## imm = 0x7FFFFFFFF8000000 addq %rdi, %rcx sarq $27, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $27, %rax sarq $27, %rax btq $36, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	37	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return addu<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $37, %rcx movabsq $137438953471, %rdx ## imm = 0x1FFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	38	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return adds<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $11, %rdi andl $67108864, %edi ## imm = 0x4000000 movabsq $9223372036787666944, %rcx ## imm = 0x7FFFFFFFFC000000 addq %rdi, %rcx sarq $26, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $26, %rax sarq $26, %rax btq $37, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	38	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return addu<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $38, %rcx movabsq $274877906943, %rdx ## imm = 0x3FFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	39	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return adds<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $13, %rdi andl $33554432, %edi ## imm = 0x2000000 movabsq $9223372036821221376, %rcx ## imm = 0x7FFFFFFFFE000000 addq %rdi, %rcx sarq $25, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $25, %rax sarq $25, %rax btq $38, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	39	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return addu<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $39, %rcx movabsq $549755813887, %rdx ## imm = 0x7FFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	40	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return adds<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $15, %rdi andl $16777216, %edi ## imm = 0x1000000 movabsq $9223372036837998592, %rcx ## imm = 0x7FFFFFFFFF000000 addq %rdi, %rcx sarq $24, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $24, %rax sarq $24, %rax btq $39, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	40	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return addu<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $40, %rcx movabsq $1099511627775, %rdx ## imm = 0xFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	41	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return adds<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $17, %rdi andl $8388608, %edi ## imm = 0x800000 movabsq $9223372036846387200, %rcx ## imm = 0x7FFFFFFFFF800000 addq %rdi, %rcx sarq $23, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $23, %rax sarq $23, %rax btq $40, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	41	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return addu<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $41, %rcx movabsq $2199023255551, %rdx ## imm = 0x1FFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	42	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return adds<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $19, %rdi andl $4194304, %edi ## imm = 0x400000 movabsq $9223372036850581504, %rcx ## imm = 0x7FFFFFFFFFC00000 addq %rdi, %rcx sarq $22, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $22, %rax sarq $22, %rax btq $41, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	42	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return addu<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $42, %rcx movabsq $4398046511103, %rdx ## imm = 0x3FFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	43	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return adds<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $21, %rdi andl $2097152, %edi ## imm = 0x200000 movabsq $9223372036852678656, %rcx ## imm = 0x7FFFFFFFFFE00000 addq %rdi, %rcx sarq $21, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $21, %rax sarq $21, %rax btq $42, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	43	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return addu<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $43, %rcx movabsq $8796093022207, %rdx ## imm = 0x7FFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	44	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return adds<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $23, %rdi andl $1048576, %edi ## imm = 0x100000 movabsq $9223372036853727232, %rcx ## imm = 0x7FFFFFFFFFF00000 addq %rdi, %rcx sarq $20, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $20, %rax sarq $20, %rax btq $43, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	44	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return addu<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $44, %rcx movabsq $17592186044415, %rdx ## imm = 0xFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	45	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return adds<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $25, %rdi andl $524288, %edi ## imm = 0x80000 movabsq $9223372036854251520, %rcx ## imm = 0x7FFFFFFFFFF80000 addq %rdi, %rcx sarq $19, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $19, %rax sarq $19, %rax btq $44, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	45	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return addu<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $45, %rcx movabsq $35184372088831, %rdx ## imm = 0x1FFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	46	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return adds<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $27, %rdi andl $262144, %edi ## imm = 0x40000 movabsq $9223372036854513664, %rcx ## imm = 0x7FFFFFFFFFFC0000 addq %rdi, %rcx sarq $18, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $18, %rax sarq $18, %rax btq $45, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	46	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return addu<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $46, %rcx movabsq $70368744177663, %rdx ## imm = 0x3FFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	47	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return adds<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $29, %rdi andl $131072, %edi ## imm = 0x20000 movabsq $9223372036854644736, %rcx ## imm = 0x7FFFFFFFFFFE0000 addq %rdi, %rcx sarq $17, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $17, %rax sarq $17, %rax btq $46, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	47	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return addu<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $47, %rcx movabsq $140737488355327, %rdx ## imm = 0x7FFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	48	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return adds<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $31, %rdi andl $65536, %edi ## imm = 0x10000 movabsq $9223372036854710272, %rcx ## imm = 0x7FFFFFFFFFFF0000 addq %rdi, %rcx sarq $16, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $16, %rax sarq $16, %rax btq $47, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	48	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return addu<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $48, %rcx movabsq $281474976710655, %rdx ## imm = 0xFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	49	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return adds<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $33, %rdi andl $32768, %edi ## imm = 0x8000 movabsq $9223372036854743040, %rcx ## imm = 0x7FFFFFFFFFFF8000 addq %rdi, %rcx sarq $15, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $15, %rax sarq $15, %rax btq $48, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	49	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return addu<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $49, %rcx movabsq $562949953421311, %rdx ## imm = 0x1FFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	50	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return adds<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $35, %rdi andl $16384, %edi ## imm = 0x4000 movabsq $9223372036854759424, %rcx ## imm = 0x7FFFFFFFFFFFC000 addq %rdi, %rcx sarq $14, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $14, %rax sarq $14, %rax btq $49, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	50	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return addu<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $50, %rcx movabsq $1125899906842623, %rdx ## imm = 0x3FFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	51	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return adds<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $37, %rdi andl $8192, %edi ## imm = 0x2000 movabsq $9223372036854767616, %rcx ## imm = 0x7FFFFFFFFFFFE000 addq %rdi, %rcx sarq $13, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $13, %rax sarq $13, %rax btq $50, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	51	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return addu<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $51, %rcx movabsq $2251799813685247, %rdx ## imm = 0x7FFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	52	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return adds<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $39, %rdi andl $4096, %edi ## imm = 0x1000 movabsq $9223372036854771712, %rcx ## imm = 0x7FFFFFFFFFFFF000 addq %rdi, %rcx sarq $12, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $12, %rax sarq $12, %rax btq $51, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	52	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return addu<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $52, %rcx movabsq $4503599627370495, %rdx ## imm = 0xFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	53	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return adds<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $41, %rdi andl $2048, %edi ## imm = 0x800 movabsq $9223372036854773760, %rcx ## imm = 0x7FFFFFFFFFFFF800 addq %rdi, %rcx sarq $11, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $11, %rax sarq $11, %rax btq $52, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	53	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return addu<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $53, %rcx movabsq $9007199254740991, %rdx ## imm = 0x1FFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	54	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return adds<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $43, %rdi andl $1024, %edi ## imm = 0x400 movabsq $9223372036854774784, %rcx ## imm = 0x7FFFFFFFFFFFFC00 addq %rdi, %rcx sarq $10, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $10, %rax sarq $10, %rax btq $53, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	54	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return addu<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $54, %rcx movabsq $18014398509481983, %rdx ## imm = 0x3FFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	55	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return adds<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $45, %rdi andl $512, %edi ## imm = 0x200 movabsq $9223372036854775296, %rcx ## imm = 0x7FFFFFFFFFFFFE00 addq %rdi, %rcx sarq $9, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $9, %rax sarq $9, %rax btq $54, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	55	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return addu<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $55, %rcx movabsq $36028797018963967, %rdx ## imm = 0x7FFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	56	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return adds<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $47, %rdi andl $256, %edi ## imm = 0x100 movabsq $9223372036854775552, %rcx ## imm = 0x7FFFFFFFFFFFFF00 addq %rdi, %rcx sarq $8, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $8, %rax sarq $8, %rax btq $55, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	56	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return addu<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $56, %rcx movabsq $72057594037927935, %rdx ## imm = 0xFFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	57	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return adds<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $49, %rdi andl $128, %edi movabsq $9223372036854775680, %rcx ## imm = 0x7FFFFFFFFFFFFF80 addq %rdi, %rcx sarq $7, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $7, %rax sarq $7, %rax btq $56, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	57	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return addu<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $57, %rcx movabsq $144115188075855871, %rdx ## imm = 0x1FFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	58	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return adds<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $51, %rdi andl $64, %edi movabsq $9223372036854775744, %rcx ## imm = 0x7FFFFFFFFFFFFFC0 addq %rdi, %rcx sarq $6, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $6, %rax sarq $6, %rax btq $57, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	58	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return addu<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $58, %rcx movabsq $288230376151711743, %rdx ## imm = 0x3FFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	59	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return adds<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $53, %rdi andl $32, %edi movabsq $9223372036854775776, %rcx ## imm = 0x7FFFFFFFFFFFFFE0 addq %rdi, %rcx sarq $5, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $5, %rax sarq $5, %rax btq $58, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	59	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return addu<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $59, %rcx movabsq $576460752303423487, %rdx ## imm = 0x7FFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	60	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return adds<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $55, %rdi andl $16, %edi movabsq $9223372036854775792, %rcx ## imm = 0x7FFFFFFFFFFFFFF0 addq %rdi, %rcx sarq $4, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $4, %rax sarq $4, %rax btq $59, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	60	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return addu<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $60, %rcx movabsq $1152921504606846975, %rdx ## imm = 0xFFFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	61	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return adds<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $57, %rdi andl $8, %edi movabsq $9223372036854775800, %rcx ## imm = 0x7FFFFFFFFFFFFFF8 addq %rdi, %rcx sarq $3, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $3, %rax sarq $3, %rax btq $60, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	61	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return addu<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $61, %rcx movabsq $2305843009213693951, %rdx ## imm = 0x1FFFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	62	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return adds<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $59, %rdi andl $4, %edi movabsq $9223372036854775804, %rcx ## imm = 0x7FFFFFFFFFFFFFFC addq %rdi, %rcx sarq $2, %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi shlq $2, %rax sarq $2, %rax btq $61, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	62	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return addu<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax movq %rax, %rcx shrq $62, %rcx movabsq $4611686018427387903, %rdx ## imm = 0x3FFFFFFFFFFFFFFF andq %rdx, %rax testq %rcx, %rcx cmovneq %rdx, %rax addq %rdi, %rsi cmovbq %rdx, %rax popq %rbp retq
x86_64	63	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return adds<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq (%rsi,%rdi), %rax shrq $61, %rdi andl $2, %edi movabsq $9223372036854775806, %rcx ## imm = 0x7FFFFFFFFFFFFFFE addq %rdi, %rcx sarq %rcx movq %rcx, %rdx xorq %rsi, %rdx xorq %rax, %rsi notq %rsi orq %rdx, %rsi addq %rax, %rax sarq %rax btq $62, %rsi cmovaeq %rcx, %rax popq %rbp retq
x86_64	63	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return addu<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax addq %rsi, %rdi setb %al movq %rdi, %rcx shrq $63, %rcx orq %rax, %rcx negq %rcx orq %rdi, %rcx movabsq $9223372036854775807, %rax ## imm = 0x7FFFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	64	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return adds<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx shrq $63, %rcx movabsq $9223372036854775807, %rdx ## imm = 0x7FFFFFFFFFFFFFFF addq %rcx, %rdx addq %rsi, %rax cmovoq %rdx, %rax popq %rbp retq
x86_64	64	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return addu<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp addq %rsi, %rdi sbbq %rax, %rax orq %rdi, %rax popq %rbp retq
x86_64	4	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return subs<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subb %sil, %al xorb %dil, %sil movzbl %al, %ecx xorb %dil, %al andb %sil, %al shrb $3, %dil andb $1, %dil addb $7, %dil testb $8, %al movzbl %dil, %eax cmovel %ecx, %eax shlb $4, %al sarb $4, %al movsbl %al, %eax popq %rbp retq
x86_64	4	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return subu<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subb %sil, %dil movzbl %dil, %eax cmovbl %ecx, %eax andl $15, %eax popq %rbp retq
x86_64	5	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return subs<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subb %sil, %al xorb %dil, %sil movzbl %al, %ecx xorb %dil, %al andb %sil, %al shrb $4, %dil andb $1, %dil addb $15, %dil testb $16, %al movzbl %dil, %eax cmovel %ecx, %eax shlb $3, %al sarb $3, %al movsbl %al, %eax popq %rbp retq
x86_64	5	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return subu<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subb %sil, %dil movzbl %dil, %eax cmovbl %ecx, %eax andl $31, %eax popq %rbp retq
x86_64	6	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return subs<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subb %sil, %al xorb %dil, %sil movzbl %al, %ecx xorb %dil, %al andb %sil, %al shrb $5, %dil andb $1, %dil addb $31, %dil testb $32, %al movzbl %dil, %eax cmovel %ecx, %eax shlb $2, %al sarb $2, %al movsbl %al, %eax popq %rbp retq
x86_64	6	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return subu<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subb %sil, %dil movzbl %dil, %eax cmovbl %ecx, %eax andl $63, %eax popq %rbp retq
x86_64	7	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return subs<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subb %sil, %al xorb %dil, %sil movzbl %al, %ecx xorb %dil, %al andb %sil, %al shrb $6, %dil andb $1, %dil addb $63, %dil testb $64, %al movzbl %dil, %eax cmovel %ecx, %eax addb %al, %al sarb %al movsbl %al, %eax popq %rbp retq
x86_64	7	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return subu<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subb %sil, %dil movzbl %dil, %eax cmovbl %ecx, %eax andl $127, %eax popq %rbp retq
x86_64	8	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return subs<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subb %sil, %al xorb %dil, %sil movzbl %al, %ecx xorb %dil, %al shrb $7, %dil addb $127, %dil testb %sil, %al movzbl %dil, %eax cmovnsl %ecx, %eax movsbl %al, %eax popq %rbp retq
x86_64	8	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return subu<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subb %sil, %dil movzbl %dil, %ecx cmovbl %eax, %ecx movzbl %cl, %eax popq %rbp retq
x86_64	9	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return subs<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $8, %edi andl $1, %edi addl $255, %edi testl $256, %ecx ## imm = 0x100 cmovel %eax, %edi shll $7, %edi movswl %di, %eax sarl $7, %eax popq %rbp retq
x86_64	9	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return subu<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovael %edi, %eax andl $511, %eax ## imm = 0x1FF popq %rbp retq
x86_64	10	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return subs<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $9, %edi andl $1, %edi addl $511, %edi ## imm = 0x1FF testl $512, %ecx ## imm = 0x200 cmovel %eax, %edi shll $6, %edi movswl %di, %eax sarl $6, %eax popq %rbp retq
x86_64	10	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return subu<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovael %edi, %eax andl $1023, %eax ## imm = 0x3FF popq %rbp retq
x86_64	11	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return subs<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $10, %edi andl $1, %edi addl $1023, %edi ## imm = 0x3FF testl $1024, %ecx ## imm = 0x400 cmovel %eax, %edi shll $5, %edi movswl %di, %eax sarl $5, %eax popq %rbp retq
x86_64	11	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return subu<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovael %edi, %eax andl $2047, %eax ## imm = 0x7FF popq %rbp retq
x86_64	12	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return subs<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $11, %edi andl $1, %edi addl $2047, %edi ## imm = 0x7FF testl $2048, %ecx ## imm = 0x800 cmovel %eax, %edi shll $4, %edi movswl %di, %eax sarl $4, %eax popq %rbp retq
x86_64	12	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return subu<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovael %edi, %eax andl $4095, %eax ## imm = 0xFFF popq %rbp retq
x86_64	13	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return subs<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $12, %edi andl $1, %edi addl $4095, %edi ## imm = 0xFFF testl $4096, %ecx ## imm = 0x1000 cmovel %eax, %edi shll $3, %edi movswl %di, %eax sarl $3, %eax popq %rbp retq
x86_64	13	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return subu<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovael %edi, %eax andl $8191, %eax ## imm = 0x1FFF popq %rbp retq
x86_64	14	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return subs<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $13, %edi andl $1, %edi addl $8191, %edi ## imm = 0x1FFF testl $8192, %ecx ## imm = 0x2000 cmovel %eax, %edi shll $2, %edi movswl %di, %eax sarl $2, %eax popq %rbp retq
x86_64	14	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return subu<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovael %edi, %eax andl $16383, %eax ## imm = 0x3FFF popq %rbp retq
x86_64	15	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return subs<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $14, %edi andl $1, %edi addl $16383, %edi ## imm = 0x3FFF testl $16384, %ecx ## imm = 0x4000 cmovel %eax, %edi addl %edi, %edi movswl %di, %eax sarl %eax popq %rbp retq
x86_64	15	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return subu<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovael %edi, %eax andl $32767, %eax ## imm = 0x7FFF popq %rbp retq
x86_64	16	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return subs<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movzwl %di, %eax movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi xorl %ecx, %edi shrl $15, %eax addl $32767, %eax ## imm = 0x7FFF testw %si, %di cmovnsl %ecx, %eax cwtl popq %rbp retq
x86_64	16	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return subu<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subw %si, %di cmovbw %ax, %di movzwl %di, %eax popq %rbp retq
x86_64	17	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return subs<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl %edi andl $32768, %edi ## imm = 0x8000 leal 2147450880(%rdi), %edx shll $15, %eax testl $65536, %ecx ## imm = 0x10000 cmovnel %edx, %eax sarl $15, %eax popq %rbp retq
x86_64	17	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return subu<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $131071, %eax ## imm = 0x1FFFF popq %rbp retq
x86_64	18	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return subs<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $3, %edi andl $16384, %edi ## imm = 0x4000 leal 2147467264(%rdi), %edx shll $14, %eax testl $131072, %ecx ## imm = 0x20000 cmovnel %edx, %eax sarl $14, %eax popq %rbp retq
x86_64	18	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return subu<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $262143, %eax ## imm = 0x3FFFF popq %rbp retq
x86_64	19	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return subs<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $5, %edi andl $8192, %edi ## imm = 0x2000 leal 2147475456(%rdi), %edx shll $13, %eax testl $262144, %ecx ## imm = 0x40000 cmovnel %edx, %eax sarl $13, %eax popq %rbp retq
x86_64	19	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return subu<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $524287, %eax ## imm = 0x7FFFF popq %rbp retq
x86_64	20	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return subs<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $7, %edi andl $4096, %edi ## imm = 0x1000 leal 2147479552(%rdi), %edx shll $12, %eax testl $524288, %ecx ## imm = 0x80000 cmovnel %edx, %eax sarl $12, %eax popq %rbp retq
x86_64	20	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return subu<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $1048575, %eax ## imm = 0xFFFFF popq %rbp retq
x86_64	21	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return subs<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $9, %edi andl $2048, %edi ## imm = 0x800 leal 2147481600(%rdi), %edx shll $11, %eax testl $1048576, %ecx ## imm = 0x100000 cmovnel %edx, %eax sarl $11, %eax popq %rbp retq
x86_64	21	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return subu<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $2097151, %eax ## imm = 0x1FFFFF popq %rbp retq
x86_64	22	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return subs<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $11, %edi andl $1024, %edi ## imm = 0x400 leal 2147482624(%rdi), %edx shll $10, %eax testl $2097152, %ecx ## imm = 0x200000 cmovnel %edx, %eax sarl $10, %eax popq %rbp retq
x86_64	22	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return subu<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $4194303, %eax ## imm = 0x3FFFFF popq %rbp retq
x86_64	23	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return subs<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $13, %edi andl $512, %edi ## imm = 0x200 leal 2147483136(%rdi), %edx shll $9, %eax testl $4194304, %ecx ## imm = 0x400000 cmovnel %edx, %eax sarl $9, %eax popq %rbp retq
x86_64	23	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return subu<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $8388607, %eax ## imm = 0x7FFFFF popq %rbp retq
x86_64	24	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return subs<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $15, %edi andl $256, %edi ## imm = 0x100 leal 2147483392(%rdi), %edx shll $8, %eax testl $8388608, %ecx ## imm = 0x800000 cmovnel %edx, %eax sarl $8, %eax popq %rbp retq
x86_64	24	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return subu<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $16777215, %eax ## imm = 0xFFFFFF popq %rbp retq
x86_64	25	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return subs<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi movl %ecx, %edx xorl %edi, %edx andl %esi, %edx shrl $24, %edi andl $1, %edi leal 16777215(%rdi), %eax testl $16777216, %edx ## imm = 0x1000000 cmovel %ecx, %eax shll $7, %eax sarl $7, %eax popq %rbp retq
x86_64	25	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return subu<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $33554431, %eax ## imm = 0x1FFFFFF popq %rbp retq
x86_64	26	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return subs<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi movl %ecx, %edx xorl %edi, %edx andl %esi, %edx shrl $25, %edi andl $1, %edi leal 33554431(%rdi), %eax testl $33554432, %edx ## imm = 0x2000000 cmovel %ecx, %eax shll $6, %eax sarl $6, %eax popq %rbp retq
x86_64	26	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return subu<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $67108863, %eax ## imm = 0x3FFFFFF popq %rbp retq
x86_64	27	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return subs<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi movl %ecx, %edx xorl %edi, %edx andl %esi, %edx shrl $26, %edi andl $1, %edi leal 67108863(%rdi), %eax testl $67108864, %edx ## imm = 0x4000000 cmovel %ecx, %eax shll $5, %eax sarl $5, %eax popq %rbp retq
x86_64	27	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return subu<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $134217727, %eax ## imm = 0x7FFFFFF popq %rbp retq
x86_64	28	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return subs<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi movl %ecx, %edx xorl %edi, %edx andl %esi, %edx shrl $27, %edi andl $1, %edi leal 134217727(%rdi), %eax testl $134217728, %edx ## imm = 0x8000000 cmovel %ecx, %eax shll $4, %eax sarl $4, %eax popq %rbp retq
x86_64	28	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return subu<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $268435455, %eax ## imm = 0xFFFFFFF popq %rbp retq
x86_64	29	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return subs<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi movl %ecx, %edx xorl %edi, %edx andl %esi, %edx shrl $28, %edi andl $1, %edi leal 268435455(%rdi), %eax testl $268435456, %edx ## imm = 0x10000000 cmovel %ecx, %eax shll $3, %eax sarl $3, %eax popq %rbp retq
x86_64	29	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return subu<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $536870911, %eax ## imm = 0x1FFFFFFF popq %rbp retq
x86_64	30	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return subs<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi movl %ecx, %edx xorl %edi, %edx andl %esi, %edx shrl $29, %edi andl $1, %edi leal 536870911(%rdi), %eax testl $536870912, %edx ## imm = 0x20000000 cmovel %ecx, %eax shll $2, %eax sarl $2, %eax popq %rbp retq
x86_64	30	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return subu<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $1073741823, %eax ## imm = 0x3FFFFFFF popq %rbp retq
x86_64	31	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return subs<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax subl %esi, %eax xorl %edi, %esi movl %eax, %ecx xorl %edi, %ecx andl %esi, %ecx shrl $30, %edi andl $1, %edi addl $1073741823, %edi ## imm = 0x3FFFFFFF testl $1073741824, %ecx ## imm = 0x40000000 cmovel %eax, %edi leal (%rdi,%rdi), %eax sarl %eax popq %rbp retq
x86_64	31	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return subu<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %eax, %eax subl %esi, %edi cmovael %edi, %eax andl $2147483647, %eax ## imm = 0x7FFFFFFF popq %rbp retq
x86_64	32	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return subs<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %ecx subl %esi, %ecx xorl %edi, %esi movl %ecx, %edx xorl %edi, %edx shrl $31, %edi leal 2147483647(%rdi), %eax testl %esi, %edx cmovnsl %ecx, %eax popq %rbp retq
x86_64	32	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return subu<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %ecx, %ecx subl %esi, %eax cmovbl %ecx, %eax popq %rbp retq
x86_64	33	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return subs<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq %rdi andl $-2147483648, %edi ## imm = 0x80000000 movabsq $9223372034707292160, %rdx ## imm = 0x7FFFFFFF80000000 addq %rdi, %rdx shlq $31, %rax btq $32, %rcx cmovbq %rdx, %rax sarq $31, %rax popq %rbp retq
x86_64	33	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return subu<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $8589934591, %rax ## imm = 0x1FFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	34	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return subs<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $3, %rdi andl $1073741824, %edi ## imm = 0x40000000 movabsq $9223372035781033984, %rdx ## imm = 0x7FFFFFFFC0000000 addq %rdi, %rdx shlq $30, %rax btq $33, %rcx cmovbq %rdx, %rax sarq $30, %rax popq %rbp retq
x86_64	34	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return subu<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $17179869183, %rax ## imm = 0x3FFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	35	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return subs<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $5, %rdi andl $536870912, %edi ## imm = 0x20000000 movabsq $9223372036317904896, %rdx ## imm = 0x7FFFFFFFE0000000 addq %rdi, %rdx shlq $29, %rax btq $34, %rcx cmovbq %rdx, %rax sarq $29, %rax popq %rbp retq
x86_64	35	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return subu<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $34359738367, %rax ## imm = 0x7FFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	36	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return subs<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $7, %rdi andl $268435456, %edi ## imm = 0x10000000 movabsq $9223372036586340352, %rdx ## imm = 0x7FFFFFFFF0000000 addq %rdi, %rdx shlq $28, %rax btq $35, %rcx cmovbq %rdx, %rax sarq $28, %rax popq %rbp retq
x86_64	36	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return subu<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $68719476735, %rax ## imm = 0xFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	37	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return subs<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $9, %rdi andl $134217728, %edi ## imm = 0x8000000 movabsq $9223372036720558080, %rdx ## imm = 0x7FFFFFFFF8000000 addq %rdi, %rdx shlq $27, %rax btq $36, %rcx cmovbq %rdx, %rax sarq $27, %rax popq %rbp retq
x86_64	37	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return subu<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $137438953471, %rax ## imm = 0x1FFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	38	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return subs<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $11, %rdi andl $67108864, %edi ## imm = 0x4000000 movabsq $9223372036787666944, %rdx ## imm = 0x7FFFFFFFFC000000 addq %rdi, %rdx shlq $26, %rax btq $37, %rcx cmovbq %rdx, %rax sarq $26, %rax popq %rbp retq
x86_64	38	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return subu<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $274877906943, %rax ## imm = 0x3FFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	39	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return subs<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $13, %rdi andl $33554432, %edi ## imm = 0x2000000 movabsq $9223372036821221376, %rdx ## imm = 0x7FFFFFFFFE000000 addq %rdi, %rdx shlq $25, %rax btq $38, %rcx cmovbq %rdx, %rax sarq $25, %rax popq %rbp retq
x86_64	39	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return subu<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $549755813887, %rax ## imm = 0x7FFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	40	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return subs<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $15, %rdi andl $16777216, %edi ## imm = 0x1000000 movabsq $9223372036837998592, %rdx ## imm = 0x7FFFFFFFFF000000 addq %rdi, %rdx shlq $24, %rax btq $39, %rcx cmovbq %rdx, %rax sarq $24, %rax popq %rbp retq
x86_64	40	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return subu<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $1099511627775, %rax ## imm = 0xFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	41	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return subs<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $17, %rdi andl $8388608, %edi ## imm = 0x800000 movabsq $9223372036846387200, %rdx ## imm = 0x7FFFFFFFFF800000 addq %rdi, %rdx shlq $23, %rax btq $40, %rcx cmovbq %rdx, %rax sarq $23, %rax popq %rbp retq
x86_64	41	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return subu<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $2199023255551, %rax ## imm = 0x1FFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	42	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return subs<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $19, %rdi andl $4194304, %edi ## imm = 0x400000 movabsq $9223372036850581504, %rdx ## imm = 0x7FFFFFFFFFC00000 addq %rdi, %rdx shlq $22, %rax btq $41, %rcx cmovbq %rdx, %rax sarq $22, %rax popq %rbp retq
x86_64	42	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return subu<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $4398046511103, %rax ## imm = 0x3FFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	43	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return subs<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $21, %rdi andl $2097152, %edi ## imm = 0x200000 movabsq $9223372036852678656, %rdx ## imm = 0x7FFFFFFFFFE00000 addq %rdi, %rdx shlq $21, %rax btq $42, %rcx cmovbq %rdx, %rax sarq $21, %rax popq %rbp retq
x86_64	43	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return subu<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $8796093022207, %rax ## imm = 0x7FFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	44	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return subs<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $23, %rdi andl $1048576, %edi ## imm = 0x100000 movabsq $9223372036853727232, %rdx ## imm = 0x7FFFFFFFFFF00000 addq %rdi, %rdx shlq $20, %rax btq $43, %rcx cmovbq %rdx, %rax sarq $20, %rax popq %rbp retq
x86_64	44	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return subu<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $17592186044415, %rax ## imm = 0xFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	45	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return subs<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $25, %rdi andl $524288, %edi ## imm = 0x80000 movabsq $9223372036854251520, %rdx ## imm = 0x7FFFFFFFFFF80000 addq %rdi, %rdx shlq $19, %rax btq $44, %rcx cmovbq %rdx, %rax sarq $19, %rax popq %rbp retq
x86_64	45	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return subu<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $35184372088831, %rax ## imm = 0x1FFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	46	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return subs<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $27, %rdi andl $262144, %edi ## imm = 0x40000 movabsq $9223372036854513664, %rdx ## imm = 0x7FFFFFFFFFFC0000 addq %rdi, %rdx shlq $18, %rax btq $45, %rcx cmovbq %rdx, %rax sarq $18, %rax popq %rbp retq
x86_64	46	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return subu<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $70368744177663, %rax ## imm = 0x3FFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	47	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return subs<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $29, %rdi andl $131072, %edi ## imm = 0x20000 movabsq $9223372036854644736, %rdx ## imm = 0x7FFFFFFFFFFE0000 addq %rdi, %rdx shlq $17, %rax btq $46, %rcx cmovbq %rdx, %rax sarq $17, %rax popq %rbp retq
x86_64	47	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return subu<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $140737488355327, %rax ## imm = 0x7FFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	48	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return subs<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $31, %rdi andl $65536, %edi ## imm = 0x10000 movabsq $9223372036854710272, %rdx ## imm = 0x7FFFFFFFFFFF0000 addq %rdi, %rdx shlq $16, %rax btq $47, %rcx cmovbq %rdx, %rax sarq $16, %rax popq %rbp retq
x86_64	48	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return subu<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $281474976710655, %rax ## imm = 0xFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	49	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return subs<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $33, %rdi andl $32768, %edi ## imm = 0x8000 movabsq $9223372036854743040, %rdx ## imm = 0x7FFFFFFFFFFF8000 addq %rdi, %rdx shlq $15, %rax btq $48, %rcx cmovbq %rdx, %rax sarq $15, %rax popq %rbp retq
x86_64	49	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return subu<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $562949953421311, %rax ## imm = 0x1FFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	50	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return subs<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $35, %rdi andl $16384, %edi ## imm = 0x4000 movabsq $9223372036854759424, %rdx ## imm = 0x7FFFFFFFFFFFC000 addq %rdi, %rdx shlq $14, %rax btq $49, %rcx cmovbq %rdx, %rax sarq $14, %rax popq %rbp retq
x86_64	50	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return subu<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $1125899906842623, %rax ## imm = 0x3FFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	51	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return subs<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $37, %rdi andl $8192, %edi ## imm = 0x2000 movabsq $9223372036854767616, %rdx ## imm = 0x7FFFFFFFFFFFE000 addq %rdi, %rdx shlq $13, %rax btq $50, %rcx cmovbq %rdx, %rax sarq $13, %rax popq %rbp retq
x86_64	51	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return subu<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $2251799813685247, %rax ## imm = 0x7FFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	52	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return subs<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $39, %rdi andl $4096, %edi ## imm = 0x1000 movabsq $9223372036854771712, %rdx ## imm = 0x7FFFFFFFFFFFF000 addq %rdi, %rdx shlq $12, %rax btq $51, %rcx cmovbq %rdx, %rax sarq $12, %rax popq %rbp retq
x86_64	52	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return subu<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $4503599627370495, %rax ## imm = 0xFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	53	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return subs<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $41, %rdi andl $2048, %edi ## imm = 0x800 movabsq $9223372036854773760, %rdx ## imm = 0x7FFFFFFFFFFFF800 addq %rdi, %rdx shlq $11, %rax btq $52, %rcx cmovbq %rdx, %rax sarq $11, %rax popq %rbp retq
x86_64	53	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return subu<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $9007199254740991, %rax ## imm = 0x1FFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	54	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return subs<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $43, %rdi andl $1024, %edi ## imm = 0x400 movabsq $9223372036854774784, %rdx ## imm = 0x7FFFFFFFFFFFFC00 addq %rdi, %rdx shlq $10, %rax btq $53, %rcx cmovbq %rdx, %rax sarq $10, %rax popq %rbp retq
x86_64	54	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return subu<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $18014398509481983, %rax ## imm = 0x3FFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	55	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return subs<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $45, %rdi andl $512, %edi ## imm = 0x200 movabsq $9223372036854775296, %rdx ## imm = 0x7FFFFFFFFFFFFE00 addq %rdi, %rdx shlq $9, %rax btq $54, %rcx cmovbq %rdx, %rax sarq $9, %rax popq %rbp retq
x86_64	55	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return subu<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $36028797018963967, %rax ## imm = 0x7FFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	56	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return subs<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx andq %rsi, %rcx shrq $47, %rdi andl $256, %edi ## imm = 0x100 movabsq $9223372036854775552, %rdx ## imm = 0x7FFFFFFFFFFFFF00 addq %rdi, %rdx shlq $8, %rax btq $55, %rcx cmovbq %rdx, %rax sarq $8, %rax popq %rbp retq
x86_64	56	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return subu<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $72057594037927935, %rax ## imm = 0xFFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	57	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return subs<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rcx subq %rsi, %rcx xorq %rdi, %rsi movq %rcx, %r8 xorq %rdi, %r8 movabsq $72057594037927935, %rax ## imm = 0xFFFFFFFFFFFFFF leaq 1(%rax), %rdx andq %rsi, %rdx shrq $56, %rdi andl $1, %edi addq %rdi, %rax testq %r8, %rdx cmoveq %rcx, %rax shlq $7, %rax sarq $7, %rax popq %rbp retq
x86_64	57	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return subu<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $144115188075855871, %rax ## imm = 0x1FFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	58	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return subs<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rcx subq %rsi, %rcx xorq %rdi, %rsi movq %rcx, %r8 xorq %rdi, %r8 movabsq $144115188075855871, %rax ## imm = 0x1FFFFFFFFFFFFFF leaq 1(%rax), %rdx andq %rsi, %rdx shrq $57, %rdi andl $1, %edi addq %rdi, %rax testq %r8, %rdx cmoveq %rcx, %rax shlq $6, %rax sarq $6, %rax popq %rbp retq
x86_64	58	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return subu<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $288230376151711743, %rax ## imm = 0x3FFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	59	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return subs<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rcx subq %rsi, %rcx xorq %rdi, %rsi movq %rcx, %r8 xorq %rdi, %r8 movabsq $288230376151711743, %rax ## imm = 0x3FFFFFFFFFFFFFF leaq 1(%rax), %rdx andq %rsi, %rdx shrq $58, %rdi andl $1, %edi addq %rdi, %rax testq %r8, %rdx cmoveq %rcx, %rax shlq $5, %rax sarq $5, %rax popq %rbp retq
x86_64	59	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return subu<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $576460752303423487, %rax ## imm = 0x7FFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	60	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return subs<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rcx subq %rsi, %rcx xorq %rdi, %rsi movq %rcx, %r8 xorq %rdi, %r8 movabsq $576460752303423487, %rax ## imm = 0x7FFFFFFFFFFFFFF leaq 1(%rax), %rdx andq %rsi, %rdx shrq $59, %rdi andl $1, %edi addq %rdi, %rax testq %r8, %rdx cmoveq %rcx, %rax shlq $4, %rax sarq $4, %rax popq %rbp retq
x86_64	60	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return subu<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $1152921504606846975, %rax ## imm = 0xFFFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	61	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return subs<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rcx subq %rsi, %rcx xorq %rdi, %rsi movq %rcx, %r8 xorq %rdi, %r8 movabsq $1152921504606846975, %rax ## imm = 0xFFFFFFFFFFFFFFF leaq 1(%rax), %rdx andq %rsi, %rdx shrq $60, %rdi andl $1, %edi addq %rdi, %rax testq %r8, %rdx cmoveq %rcx, %rax shlq $3, %rax sarq $3, %rax popq %rbp retq
x86_64	61	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return subu<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $2305843009213693951, %rax ## imm = 0x1FFFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	62	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return subs<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rcx subq %rsi, %rcx xorq %rdi, %rsi movq %rcx, %r8 xorq %rdi, %r8 movabsq $2305843009213693951, %rax ## imm = 0x1FFFFFFFFFFFFFFF leaq 1(%rax), %rdx andq %rsi, %rdx shrq $61, %rdi andl $1, %edi addq %rdi, %rax testq %r8, %rdx cmoveq %rcx, %rax shlq $2, %rax sarq $2, %rax popq %rbp retq
x86_64	62	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return subu<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $4611686018427387903, %rax ## imm = 0x3FFFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	63	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return subs<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax subq %rsi, %rax xorq %rdi, %rsi movq %rax, %rcx xorq %rdi, %rcx movabsq $4611686018427387903, %r8 ## imm = 0x3FFFFFFFFFFFFFFF leaq 1(%r8), %rdx andq %rsi, %rdx shrq $62, %rdi andl $1, %edi addq %r8, %rdi testq %rcx, %rdx cmoveq %rax, %rdi leaq (%rdi,%rdi), %rax sarq %rax popq %rbp retq
x86_64	63	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return subu<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp xorl %ecx, %ecx subq %rsi, %rdi cmovaeq %rdi, %rcx movabsq $9223372036854775807, %rax ## imm = 0x7FFFFFFFFFFFFFFF andq %rcx, %rax popq %rbp retq
x86_64	64	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return subs<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rcx subq %rsi, %rcx xorq %rdi, %rsi movq %rcx, %rdx xorq %rdi, %rdx shrq $63, %rdi movabsq $9223372036854775807, %rax ## imm = 0x7FFFFFFFFFFFFFFF addq %rdi, %rax testq %rsi, %rdx cmovnsq %rcx, %rax popq %rbp retq
x86_64	64	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return subu<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax xorl %ecx, %ecx subq %rsi, %rax cmovbq %rcx, %rax popq %rbp retq
x86_64	4	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return muls<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $4, %ecx movl %eax, %edx sarb $3, %dl cmpb %cl, %dl je LBB0_2 xorb %sil, %dil addb %dil, %dil andb $16, %dil addb $112, %dil sarb $4, %dil movl %edi, %eax LBB0_2: movsbl %al, %eax popq %rbp retq
x86_64	4	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return mulu<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %eax andb $15, %al testl $4080, %edi ## imm = 0xFF0 movzbl %al, %eax movl $15, %ecx cmovel %eax, %ecx movzbl %cl, %eax popq %rbp retq
x86_64	5	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return muls<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $5, %ecx movl %eax, %edx sarb $4, %dl cmpb %cl, %dl je LBB0_2 xorb %sil, %dil shrb %dil andb $8, %dil addb $120, %dil sarb $3, %dil movl %edi, %eax LBB0_2: movsbl %al, %eax popq %rbp retq
x86_64	5	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return mulu<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %eax andb $31, %al testl $8160, %edi ## imm = 0x1FE0 movzbl %al, %eax movl $31, %ecx cmovel %eax, %ecx movzbl %cl, %eax popq %rbp retq
x86_64	6	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return muls<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $6, %ecx movl %eax, %edx sarb $5, %dl cmpb %cl, %dl je LBB0_2 xorb %sil, %dil shrb $3, %dil andb $4, %dil addb $124, %dil sarb $2, %dil movl %edi, %eax LBB0_2: movsbl %al, %eax popq %rbp retq
x86_64	6	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return mulu<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %eax andb $63, %al testl $16320, %edi ## imm = 0x3FC0 movzbl %al, %eax movl $63, %ecx cmovel %eax, %ecx movzbl %cl, %eax popq %rbp retq
x86_64	7	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return muls<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $7, %ecx movl %eax, %edx sarb $6, %dl cmpb %cl, %dl je LBB0_2 xorb %sil, %dil shrb $5, %dil andb $2, %dil addb $126, %dil sarb %dil movl %edi, %eax LBB0_2: movsbl %al, %eax popq %rbp retq
x86_64	7	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return mulu<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %eax andb $127, %al testl $32640, %edi ## imm = 0x7F80 movzbl %al, %eax movl $127, %ecx cmovel %eax, %ecx movzbl %cl, %eax popq %rbp retq
x86_64	8	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return muls<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax rolw $8, %ax cwtl movzwl %ax, %ecx shrl $8, %ecx movl %eax, %edx shrl $15, %edx xorl %edi, %esi shrb $7, %sil addb $127, %sil cmpb %al, %dl movzbl %sil, %eax cmovel %ecx, %eax movsbl %al, %eax popq %rbp retq
x86_64	8	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return mulu<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax mulb %sil sbbb %cl, %cl orb %cl, %al movzbl %al, %eax popq %rbp retq
x86_64	9	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return muls<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $9, %ecx movswl %ax, %edx shrl $8, %edx cmpw %cx, %dx je LBB0_2 xorl %edi, %esi shrl %esi andl $128, %esi addl $32640, %esi ## imm = 0x7F80 movswl %si, %eax shrl $7, %eax LBB0_2: cwtl popq %rbp retq
x86_64	9	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return mulu<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %ecx andl $511, %ecx ## imm = 0x1FF testl $33553920, %edi ## imm = 0x1FFFE00 movl $511, %eax ## imm = 0x1FF cmovel %ecx, %eax popq %rbp retq
x86_64	10	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return muls<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $10, %ecx movswl %ax, %edx shrl $9, %edx cmpw %cx, %dx je LBB0_2 xorl %edi, %esi shrl $3, %esi andl $64, %esi addl $32704, %esi ## imm = 0x7FC0 movswl %si, %eax shrl $6, %eax LBB0_2: cwtl popq %rbp retq
x86_64	10	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return mulu<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %ecx andl $1023, %ecx ## imm = 0x3FF testl $67107840, %edi ## imm = 0x3FFFC00 movl $1023, %eax ## imm = 0x3FF cmovel %ecx, %eax popq %rbp retq
x86_64	11	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return muls<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $11, %ecx movswl %ax, %edx shrl $10, %edx cmpw %cx, %dx je LBB0_2 xorl %edi, %esi shrl $5, %esi andl $32, %esi addl $32736, %esi ## imm = 0x7FE0 movswl %si, %eax shrl $5, %eax LBB0_2: cwtl popq %rbp retq
x86_64	11	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return mulu<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %ecx andl $2047, %ecx ## imm = 0x7FF testl $134215680, %edi ## imm = 0x7FFF800 movl $2047, %eax ## imm = 0x7FF cmovel %ecx, %eax popq %rbp retq
x86_64	12	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return muls<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $12, %ecx movswl %ax, %edx shrl $11, %edx cmpw %cx, %dx je LBB0_2 xorl %edi, %esi shrl $7, %esi andl $16, %esi addl $32752, %esi ## imm = 0x7FF0 movswl %si, %eax shrl $4, %eax LBB0_2: cwtl popq %rbp retq
x86_64	12	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return mulu<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %ecx andl $4095, %ecx ## imm = 0xFFF testl $268431360, %edi ## imm = 0xFFFF000 movl $4095, %eax ## imm = 0xFFF cmovel %ecx, %eax popq %rbp retq
x86_64	13	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return muls<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $13, %ecx movswl %ax, %edx shrl $12, %edx cmpw %cx, %dx je LBB0_2 xorl %edi, %esi shrl $9, %esi andl $8, %esi addl $32760, %esi ## imm = 0x7FF8 movswl %si, %eax shrl $3, %eax LBB0_2: cwtl popq %rbp retq
x86_64	13	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return mulu<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %ecx andl $8191, %ecx ## imm = 0x1FFF testl $536862720, %edi ## imm = 0x1FFFE000 movl $8191, %eax ## imm = 0x1FFF cmovel %ecx, %eax popq %rbp retq
x86_64	14	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return muls<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $14, %ecx movswl %ax, %edx shrl $13, %edx cmpw %cx, %dx je LBB0_2 xorl %edi, %esi shrl $11, %esi andl $4, %esi addl $32764, %esi ## imm = 0x7FFC movswl %si, %eax shrl $2, %eax LBB0_2: cwtl popq %rbp retq
x86_64	14	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return mulu<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %ecx andl $16383, %ecx ## imm = 0x3FFF testl $1073725440, %edi ## imm = 0x3FFFC000 movl $16383, %eax ## imm = 0x3FFF cmovel %ecx, %eax popq %rbp retq
x86_64	15	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return muls<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax imull %edi, %eax movl %eax, %ecx shrl $15, %ecx movswl %ax, %edx shrl $14, %edx cmpw %cx, %dx je LBB0_2 xorl %edi, %esi shrl $13, %esi andl $2, %esi addl $32766, %esi ## imm = 0x7FFE movswl %si, %eax shrl %eax LBB0_2: cwtl popq %rbp retq
x86_64	15	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return mulu<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp imull %esi, %edi movl %edi, %ecx andl $32767, %ecx ## imm = 0x7FFF testl $2147450880, %edi ## imm = 0x7FFF8000 movl $32767, %eax ## imm = 0x7FFF cmovel %ecx, %eax popq %rbp retq
x86_64	16	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return muls<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %esi, %eax xorl %edi, %eax movzwl %ax, %eax shrl $15, %eax addl $32767, %eax ## imm = 0x7FFF imulw %si, %di cmovbw %ax, %di movswl %di, %eax popq %rbp retq
x86_64	16	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return mulu<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax mulw %si sbbw %cx, %cx orw %cx, %ax movzwl %ax, %eax popq %rbp retq
x86_64	17	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return muls<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $17, %rcx movl %eax, %edx sarl $16, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl %esi andl $32768, %esi ## imm = 0x8000 addl $2147450880, %esi ## imm = 0x7FFF8000 sarl $15, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	17	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return mulu<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $131071, %edx ## imm = 0x1FFFF movabsq $562949953290240, %rax ## imm = 0x1FFFFFFFE0000 testq %rax, %rcx movl $131071, %eax ## imm = 0x1FFFF cmovel %edx, %eax popq %rbp retq
x86_64	18	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return muls<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $18, %rcx movl %eax, %edx sarl $17, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $3, %esi andl $16384, %esi ## imm = 0x4000 addl $2147467264, %esi ## imm = 0x7FFFC000 sarl $14, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	18	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return mulu<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $262143, %edx ## imm = 0x3FFFF movabsq $1125899906580480, %rax ## imm = 0x3FFFFFFFC0000 testq %rax, %rcx movl $262143, %eax ## imm = 0x3FFFF cmovel %edx, %eax popq %rbp retq
x86_64	19	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return muls<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $19, %rcx movl %eax, %edx sarl $18, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $5, %esi andl $8192, %esi ## imm = 0x2000 addl $2147475456, %esi ## imm = 0x7FFFE000 sarl $13, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	19	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return mulu<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $524287, %edx ## imm = 0x7FFFF movabsq $2251799813160960, %rax ## imm = 0x7FFFFFFF80000 testq %rax, %rcx movl $524287, %eax ## imm = 0x7FFFF cmovel %edx, %eax popq %rbp retq
x86_64	20	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return muls<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $20, %rcx movl %eax, %edx sarl $19, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $7, %esi andl $4096, %esi ## imm = 0x1000 addl $2147479552, %esi ## imm = 0x7FFFF000 sarl $12, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	20	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return mulu<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $1048575, %edx ## imm = 0xFFFFF movabsq $4503599626321920, %rax ## imm = 0xFFFFFFFF00000 testq %rax, %rcx movl $1048575, %eax ## imm = 0xFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	21	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return muls<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $21, %rcx movl %eax, %edx sarl $20, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $9, %esi andl $2048, %esi ## imm = 0x800 addl $2147481600, %esi ## imm = 0x7FFFF800 sarl $11, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	21	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return mulu<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $2097151, %edx ## imm = 0x1FFFFF movabsq $9007199252643840, %rax ## imm = 0x1FFFFFFFE00000 testq %rax, %rcx movl $2097151, %eax ## imm = 0x1FFFFF cmovel %edx, %eax popq %rbp retq
x86_64	22	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return muls<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $22, %rcx movl %eax, %edx sarl $21, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $11, %esi andl $1024, %esi ## imm = 0x400 addl $2147482624, %esi ## imm = 0x7FFFFC00 sarl $10, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	22	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return mulu<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $4194303, %edx ## imm = 0x3FFFFF movabsq $18014398505287680, %rax ## imm = 0x3FFFFFFFC00000 testq %rax, %rcx movl $4194303, %eax ## imm = 0x3FFFFF cmovel %edx, %eax popq %rbp retq
x86_64	23	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return muls<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $23, %rcx movl %eax, %edx sarl $22, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $13, %esi andl $512, %esi ## imm = 0x200 addl $2147483136, %esi ## imm = 0x7FFFFE00 sarl $9, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	23	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return mulu<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $8388607, %edx ## imm = 0x7FFFFF movabsq $36028797010575360, %rax ## imm = 0x7FFFFFFF800000 testq %rax, %rcx movl $8388607, %eax ## imm = 0x7FFFFF cmovel %edx, %eax popq %rbp retq
x86_64	24	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return muls<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $24, %rcx movl %eax, %edx sarl $23, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $15, %esi andl $256, %esi ## imm = 0x100 addl $2147483392, %esi ## imm = 0x7FFFFF00 sarl $8, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	24	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return mulu<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $16777215, %edx ## imm = 0xFFFFFF movabsq $72057594021150720, %rax ## imm = 0xFFFFFFFF000000 testq %rax, %rcx movl $16777215, %eax ## imm = 0xFFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	25	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return muls<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $25, %rcx movl %eax, %edx sarl $24, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $17, %esi andl $128, %esi addl $2147483520, %esi ## imm = 0x7FFFFF80 sarl $7, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	25	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return mulu<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $33554431, %edx ## imm = 0x1FFFFFF movabsq $144115188042301440, %rax ## imm = 0x1FFFFFFFE000000 testq %rax, %rcx movl $33554431, %eax ## imm = 0x1FFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	26	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return muls<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $26, %rcx movl %eax, %edx sarl $25, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $19, %esi andl $64, %esi addl $2147483584, %esi ## imm = 0x7FFFFFC0 sarl $6, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	26	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return mulu<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $67108863, %edx ## imm = 0x3FFFFFF movabsq $288230376084602880, %rax ## imm = 0x3FFFFFFFC000000 testq %rax, %rcx movl $67108863, %eax ## imm = 0x3FFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	27	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return muls<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $27, %rcx movl %eax, %edx sarl $26, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $21, %esi andl $32, %esi addl $2147483616, %esi ## imm = 0x7FFFFFE0 sarl $5, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	27	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return mulu<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $134217727, %edx ## imm = 0x7FFFFFF movabsq $576460752169205760, %rax ## imm = 0x7FFFFFFF8000000 testq %rax, %rcx movl $134217727, %eax ## imm = 0x7FFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	28	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return muls<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $28, %rcx movl %eax, %edx sarl $27, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $23, %esi andl $16, %esi addl $2147483632, %esi ## imm = 0x7FFFFFF0 sarl $4, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	28	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return mulu<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $268435455, %edx ## imm = 0xFFFFFFF movabsq $1152921504338411520, %rax ## imm = 0xFFFFFFFF0000000 testq %rax, %rcx movl $268435455, %eax ## imm = 0xFFFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	29	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return muls<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $29, %rcx movl %eax, %edx sarl $28, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $25, %esi andl $8, %esi addl $2147483640, %esi ## imm = 0x7FFFFFF8 sarl $3, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	29	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return mulu<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $536870911, %edx ## imm = 0x1FFFFFFF movabsq $2305843008676823040, %rax ## imm = 0x1FFFFFFFE0000000 testq %rax, %rcx movl $536870911, %eax ## imm = 0x1FFFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	30	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return muls<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $30, %rcx movl %eax, %edx sarl $29, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $27, %esi andl $4, %esi addl $2147483644, %esi ## imm = 0x7FFFFFFC sarl $2, %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	30	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return mulu<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $1073741823, %edx ## imm = 0x3FFFFFFF movabsq $4611686017353646080, %rax ## imm = 0x3FFFFFFFC0000000 testq %rax, %rcx movl $1073741823, %eax ## imm = 0x3FFFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	31	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return muls<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movslq %edi, %rcx movslq %esi, %rax imulq %rcx, %rax movq %rax, %rcx shrq $31, %rcx movl %eax, %edx sarl $30, %edx cmpl %ecx, %edx je LBB0_2 xorl %edi, %esi shrl $29, %esi andl $2, %esi addl $2147483646, %esi ## imm = 0x7FFFFFFE sarl %esi movl %esi, %eax LBB0_2: popq %rbp retq
x86_64	31	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return mulu<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx imulq %rax, %rcx movl %ecx, %edx andl $2147483647, %edx ## imm = 0x7FFFFFFF movabsq $9223372034707292160, %rax ## imm = 0x7FFFFFFF80000000 testq %rax, %rcx movl $2147483647, %eax ## imm = 0x7FFFFFFF cmovel %edx, %eax popq %rbp retq
x86_64	32	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return muls<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax movl %esi, %ecx xorl %edi, %ecx shrl $31, %ecx addl $2147483647, %ecx ## imm = 0x7FFFFFFF imull %esi, %eax cmovbl %ecx, %eax popq %rbp retq
x86_64	32	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return mulu<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax mull %esi sbbl %ecx, %ecx orl %ecx, %eax popq %rbp retq
x86_64	33	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return muls<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $33, %rax, %r9 shlq $31, %rcx movq %rcx, %rdx sarq $63, %rdx shrq %rsi andl $-2147483648, %esi ## imm = 0x80000000 movabsq $9223372034707292160, %rax ## imm = 0x7FFFFFFF80000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $31, %rax popq %rbp retq
x86_64	33	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return mulu<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $31, %rax, %rsi movabsq $4294967296, %rcx ## imm = 0x100000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $8589934591, %rax ## imm = 0x1FFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	34	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return muls<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $34, %rax, %r9 shlq $30, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $3, %rsi andl $1073741824, %esi ## imm = 0x40000000 movabsq $9223372035781033984, %rax ## imm = 0x7FFFFFFFC0000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $30, %rax popq %rbp retq
x86_64	34	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return mulu<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $30, %rax, %rsi movabsq $12884901888, %rcx ## imm = 0x300000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $17179869183, %rax ## imm = 0x3FFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	35	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return muls<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $35, %rax, %r9 shlq $29, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $5, %rsi andl $536870912, %esi ## imm = 0x20000000 movabsq $9223372036317904896, %rax ## imm = 0x7FFFFFFFE0000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $29, %rax popq %rbp retq
x86_64	35	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return mulu<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $29, %rax, %rsi movabsq $30064771072, %rcx ## imm = 0x700000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $34359738367, %rax ## imm = 0x7FFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	36	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return muls<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $36, %rax, %r9 shlq $28, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $7, %rsi andl $268435456, %esi ## imm = 0x10000000 movabsq $9223372036586340352, %rax ## imm = 0x7FFFFFFFF0000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $28, %rax popq %rbp retq
x86_64	36	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return mulu<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $28, %rax, %rsi movabsq $64424509440, %rcx ## imm = 0xF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $68719476735, %rax ## imm = 0xFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	37	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return muls<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $37, %rax, %r9 shlq $27, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $9, %rsi andl $134217728, %esi ## imm = 0x8000000 movabsq $9223372036720558080, %rax ## imm = 0x7FFFFFFFF8000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $27, %rax popq %rbp retq
x86_64	37	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return mulu<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $27, %rax, %rsi movabsq $133143986176, %rcx ## imm = 0x1F00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $137438953471, %rax ## imm = 0x1FFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	38	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return muls<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $38, %rax, %r9 shlq $26, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $11, %rsi andl $67108864, %esi ## imm = 0x4000000 movabsq $9223372036787666944, %rax ## imm = 0x7FFFFFFFFC000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $26, %rax popq %rbp retq
x86_64	38	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return mulu<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $26, %rax, %rsi movabsq $270582939648, %rcx ## imm = 0x3F00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $274877906943, %rax ## imm = 0x3FFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	39	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return muls<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $39, %rax, %r9 shlq $25, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $13, %rsi andl $33554432, %esi ## imm = 0x2000000 movabsq $9223372036821221376, %rax ## imm = 0x7FFFFFFFFE000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $25, %rax popq %rbp retq
x86_64	39	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return mulu<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $25, %rax, %rsi movabsq $545460846592, %rcx ## imm = 0x7F00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $549755813887, %rax ## imm = 0x7FFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	40	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return muls<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $40, %rax, %r9 shlq $24, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $15, %rsi andl $16777216, %esi ## imm = 0x1000000 movabsq $9223372036837998592, %rax ## imm = 0x7FFFFFFFFF000000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $24, %rax popq %rbp retq
x86_64	40	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return mulu<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $24, %rax, %rsi movabsq $1095216660480, %rcx ## imm = 0xFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $1099511627775, %rax ## imm = 0xFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	41	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return muls<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $41, %rax, %r9 shlq $23, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $17, %rsi andl $8388608, %esi ## imm = 0x800000 movabsq $9223372036846387200, %rax ## imm = 0x7FFFFFFFFF800000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $23, %rax popq %rbp retq
x86_64	41	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return mulu<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $23, %rax, %rsi movabsq $2194728288256, %rcx ## imm = 0x1FF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $2199023255551, %rax ## imm = 0x1FFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	42	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return muls<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $42, %rax, %r9 shlq $22, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $19, %rsi andl $4194304, %esi ## imm = 0x400000 movabsq $9223372036850581504, %rax ## imm = 0x7FFFFFFFFFC00000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $22, %rax popq %rbp retq
x86_64	42	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return mulu<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $22, %rax, %rsi movabsq $4393751543808, %rcx ## imm = 0x3FF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $4398046511103, %rax ## imm = 0x3FFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	43	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return muls<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $43, %rax, %r9 shlq $21, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $21, %rsi andl $2097152, %esi ## imm = 0x200000 movabsq $9223372036852678656, %rax ## imm = 0x7FFFFFFFFFE00000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $21, %rax popq %rbp retq
x86_64	43	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return mulu<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $21, %rax, %rsi movabsq $8791798054912, %rcx ## imm = 0x7FF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $8796093022207, %rax ## imm = 0x7FFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	44	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return muls<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $44, %rax, %r9 shlq $20, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $23, %rsi andl $1048576, %esi ## imm = 0x100000 movabsq $9223372036853727232, %rax ## imm = 0x7FFFFFFFFFF00000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $20, %rax popq %rbp retq
x86_64	44	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return mulu<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $20, %rax, %rsi movabsq $17587891077120, %rcx ## imm = 0xFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $17592186044415, %rax ## imm = 0xFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	45	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return muls<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $45, %rax, %r9 shlq $19, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $25, %rsi andl $524288, %esi ## imm = 0x80000 movabsq $9223372036854251520, %rax ## imm = 0x7FFFFFFFFFF80000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $19, %rax popq %rbp retq
x86_64	45	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return mulu<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $19, %rax, %rsi movabsq $35180077121536, %rcx ## imm = 0x1FFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $35184372088831, %rax ## imm = 0x1FFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	46	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return muls<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $46, %rax, %r9 shlq $18, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $27, %rsi andl $262144, %esi ## imm = 0x40000 movabsq $9223372036854513664, %rax ## imm = 0x7FFFFFFFFFFC0000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $18, %rax popq %rbp retq
x86_64	46	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return mulu<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $18, %rax, %rsi movabsq $70364449210368, %rcx ## imm = 0x3FFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $70368744177663, %rax ## imm = 0x3FFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	47	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return muls<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $47, %rax, %r9 shlq $17, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $29, %rsi andl $131072, %esi ## imm = 0x20000 movabsq $9223372036854644736, %rax ## imm = 0x7FFFFFFFFFFE0000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $17, %rax popq %rbp retq
x86_64	47	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return mulu<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $17, %rax, %rsi movabsq $140733193388032, %rcx ## imm = 0x7FFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $140737488355327, %rax ## imm = 0x7FFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	48	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return muls<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $48, %rax, %r9 shlq $16, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $31, %rsi andl $65536, %esi ## imm = 0x10000 movabsq $9223372036854710272, %rax ## imm = 0x7FFFFFFFFFFF0000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $16, %rax popq %rbp retq
x86_64	48	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return mulu<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $16, %rax, %rsi movabsq $281470681743360, %rcx ## imm = 0xFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $281474976710655, %rax ## imm = 0xFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	49	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return muls<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $49, %rax, %r9 shlq $15, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $33, %rsi andl $32768, %esi ## imm = 0x8000 movabsq $9223372036854743040, %rax ## imm = 0x7FFFFFFFFFFF8000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $15, %rax popq %rbp retq
x86_64	49	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return mulu<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $15, %rax, %rsi movabsq $562945658454016, %rcx ## imm = 0x1FFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $562949953421311, %rax ## imm = 0x1FFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	50	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return muls<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $50, %rax, %r9 shlq $14, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $35, %rsi andl $16384, %esi ## imm = 0x4000 movabsq $9223372036854759424, %rax ## imm = 0x7FFFFFFFFFFFC000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $14, %rax popq %rbp retq
x86_64	50	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return mulu<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $14, %rax, %rsi movabsq $1125895611875328, %rcx ## imm = 0x3FFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $1125899906842623, %rax ## imm = 0x3FFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	51	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return muls<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $51, %rax, %r9 shlq $13, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $37, %rsi andl $8192, %esi ## imm = 0x2000 movabsq $9223372036854767616, %rax ## imm = 0x7FFFFFFFFFFFE000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $13, %rax popq %rbp retq
x86_64	51	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return mulu<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $13, %rax, %rsi movabsq $2251795518717952, %rcx ## imm = 0x7FFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $2251799813685247, %rax ## imm = 0x7FFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	52	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return muls<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $52, %rax, %r9 shlq $12, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $39, %rsi andl $4096, %esi ## imm = 0x1000 movabsq $9223372036854771712, %rax ## imm = 0x7FFFFFFFFFFFF000 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $12, %rax popq %rbp retq
x86_64	52	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return mulu<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $12, %rax, %rsi movabsq $4503595332403200, %rcx ## imm = 0xFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $4503599627370495, %rax ## imm = 0xFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	53	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return muls<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $53, %rax, %r9 shlq $11, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $41, %rsi andl $2048, %esi ## imm = 0x800 movabsq $9223372036854773760, %rax ## imm = 0x7FFFFFFFFFFFF800 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $11, %rax popq %rbp retq
x86_64	53	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return mulu<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $11, %rax, %rsi movabsq $9007194959773696, %rcx ## imm = 0x1FFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $9007199254740991, %rax ## imm = 0x1FFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	54	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return muls<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $54, %rax, %r9 shlq $10, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $43, %rsi andl $1024, %esi ## imm = 0x400 movabsq $9223372036854774784, %rax ## imm = 0x7FFFFFFFFFFFFC00 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $10, %rax popq %rbp retq
x86_64	54	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return mulu<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $10, %rax, %rsi movabsq $18014394214514688, %rcx ## imm = 0x3FFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $18014398509481983, %rax ## imm = 0x3FFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	55	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return muls<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $55, %rax, %r9 shlq $9, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $45, %rsi andl $512, %esi ## imm = 0x200 movabsq $9223372036854775296, %rax ## imm = 0x7FFFFFFFFFFFFE00 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $9, %rax popq %rbp retq
x86_64	55	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return mulu<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $9, %rax, %rsi movabsq $36028792723996672, %rcx ## imm = 0x7FFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $36028797018963967, %rax ## imm = 0x7FFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	56	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return muls<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $56, %rax, %r9 shlq $8, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $47, %rsi andl $256, %esi ## imm = 0x100 movabsq $9223372036854775552, %rax ## imm = 0x7FFFFFFFFFFFFF00 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $8, %rax popq %rbp retq
x86_64	56	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return mulu<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $8, %rax, %rsi movabsq $72057589742960640, %rcx ## imm = 0xFFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $72057594037927935, %rax ## imm = 0xFFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	57	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return muls<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $57, %rax, %r9 shlq $7, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $49, %rsi andl $128, %esi movabsq $9223372036854775680, %rax ## imm = 0x7FFFFFFFFFFFFF80 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $7, %rax popq %rbp retq
x86_64	57	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return mulu<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $7, %rax, %rsi movabsq $144115183780888576, %rcx ## imm = 0x1FFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $144115188075855871, %rax ## imm = 0x1FFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	58	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return muls<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $58, %rax, %r9 shlq $6, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $51, %rsi andl $64, %esi movabsq $9223372036854775744, %rax ## imm = 0x7FFFFFFFFFFFFFC0 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $6, %rax popq %rbp retq
x86_64	58	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return mulu<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $6, %rax, %rsi movabsq $288230371856744448, %rcx ## imm = 0x3FFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $288230376151711743, %rax ## imm = 0x3FFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	59	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return muls<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $59, %rax, %r9 shlq $5, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $53, %rsi andl $32, %esi movabsq $9223372036854775776, %rax ## imm = 0x7FFFFFFFFFFFFFE0 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $5, %rax popq %rbp retq
x86_64	59	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return mulu<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $5, %rax, %rsi movabsq $576460748008456192, %rcx ## imm = 0x7FFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $576460752303423487, %rax ## imm = 0x7FFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	60	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return muls<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $60, %rax, %r9 shlq $4, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $55, %rsi andl $16, %esi movabsq $9223372036854775792, %rax ## imm = 0x7FFFFFFFFFFFFFF0 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $4, %rax popq %rbp retq
x86_64	60	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return mulu<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $4, %rax, %rsi movabsq $1152921500311879680, %rcx ## imm = 0xFFFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $1152921504606846975, %rax ## imm = 0xFFFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	61	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return muls<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $61, %rax, %r9 shlq $3, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $57, %rsi andl $8, %esi movabsq $9223372036854775800, %rax ## imm = 0x7FFFFFFFFFFFFFF8 addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $3, %rax popq %rbp retq
x86_64	61	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return mulu<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $3, %rax, %rsi movabsq $2305843004918726656, %rcx ## imm = 0x1FFFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $2305843009213693951, %rax ## imm = 0x1FFFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	62	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return muls<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $62, %rax, %r9 shlq $2, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $59, %rsi andl $4, %esi movabsq $9223372036854775804, %rax ## imm = 0x7FFFFFFFFFFFFFFC addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq $2, %rax popq %rbp retq
x86_64	62	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return mulu<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $2, %rax, %rsi movabsq $4611686014132420608, %rcx ## imm = 0x3FFFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $4611686018427387903, %rax ## imm = 0x3FFFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	63	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return muls<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %r9d movq %rsi, %rax movl %esi, %r8d xorq %rdi, %rsi sarq $32, %rdi sarq $32, %rax movq %r8, %rdx imulq %r9, %rdx movl %edx, %ecx shrq $32, %rdx imulq %rdi, %r8 addq %rdx, %r8 movl %r8d, %edx sarq $32, %r8 imulq %rax, %r9 addq %rdx, %r9 movq %r9, %rdx sarq $32, %rdx imulq %rdi, %rax addq %r8, %rax addq %rdx, %rax shlq $32, %r9 orq %r9, %rcx shrdq $63, %rax, %r9 addq %rcx, %rcx movq %rcx, %rdx sarq $63, %rdx shrq $61, %rsi andl $2, %esi movabsq $9223372036854775806, %rax ## imm = 0x7FFFFFFFFFFFFFFE addq %rsi, %rax cmpq %rdx, %r9 cmoveq %rcx, %rax sarq %rax popq %rbp retq
x86_64	63	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return mulu<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax shrq $32, %rdi movl %esi, %ecx shrq $32, %rsi movq %rcx, %rdx imulq %rax, %rdx movl %edx, %r8d shrq $32, %rdx imulq %rdi, %rcx addq %rdx, %rcx movl %ecx, %edx shrq $32, %rcx imulq %rsi, %rax addq %rdx, %rax movq %rax, %rdx shrq $32, %rdx imulq %rdi, %rsi addq %rcx, %rsi addq %rdx, %rsi shlq $32, %rax shldq $1, %rax, %rsi movabsq $9223372032559808512, %rcx ## imm = 0x7FFFFFFF00000000 andq %rax, %rcx orq %r8, %rcx testq %rsi, %rsi movabsq $9223372036854775807, %rax ## imm = 0x7FFFFFFFFFFFFFFF cmoveq %rcx, %rax popq %rbp retq
x86_64	64	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return muls<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rsi, %rcx xorq %rdi, %rcx shrq $63, %rcx movabsq $9223372036854775807, %rdx ## imm = 0x7FFFFFFFFFFFFFFF addq %rcx, %rdx imulq %rsi, %rax cmovbq %rdx, %rax popq %rbp retq
x86_64	64	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return mulu<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax mulq %rsi sbbq %rcx, %rcx orq %rcx, %rax popq %rbp retq
x86_64	4	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return divs<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 8(%rax), %edx orb %cl, %dl andb $15, %dl cmpb $1, %dl adcw $0, %ax cwtd idivw %si movsbl %al, %eax popq %rbp retq
x86_64	4	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return divu<4>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movzbl %dil, %eax divb %sil movzbl %al, %eax popq %rbp retq
x86_64	5	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return divs<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 16(%rax), %edx orb %cl, %dl andb $31, %dl cmpb $1, %dl adcw $0, %ax cwtd idivw %si movsbl %al, %eax popq %rbp retq
x86_64	5	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return divu<5>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movzbl %dil, %eax divb %sil movzbl %al, %eax popq %rbp retq
x86_64	6	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return divs<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 32(%rax), %edx orb %cl, %dl andb $63, %dl cmpb $1, %dl adcw $0, %ax cwtd idivw %si movsbl %al, %eax popq %rbp retq
x86_64	6	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return divu<6>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movzbl %dil, %eax divb %sil movzbl %al, %eax popq %rbp retq
x86_64	7	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return divs<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 64(%rax), %edx orb %cl, %dl andb $127, %dl cmpb $1, %dl adcw $0, %ax cwtd idivw %si movsbl %al, %eax popq %rbp retq
x86_64	7	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return divu<7>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movzbl %dil, %eax divb %sil movzbl %al, %eax popq %rbp retq
x86_64	8	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return divs<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal 1(%rsi), %ecx movl %edi, %edx xorb $-128, %dl xorl %eax, %eax orb %cl, %dl sete %al addl %edi, %eax cwtd idivw %si movsbl %al, %eax popq %rbp retq
x86_64	8	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return divu<8>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movzbl %dil, %eax divb %sil movzbl %al, %eax popq %rbp retq
x86_64	9	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return divs<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 256(%rax), %edx orl %ecx, %edx andl $511, %edx ## imm = 0x1FF cmpw $1, %dx adcl $0, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	9	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return divu<9>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	10	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return divs<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 512(%rax), %edx orl %ecx, %edx andl $1023, %edx ## imm = 0x3FF cmpw $1, %dx adcl $0, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	10	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return divu<10>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	11	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return divs<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 1024(%rax), %edx orl %ecx, %edx andl $2047, %edx ## imm = 0x7FF cmpw $1, %dx adcl $0, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	11	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return divu<11>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	12	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return divs<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 2048(%rax), %edx orl %ecx, %edx andl $4095, %edx ## imm = 0xFFF cmpw $1, %dx adcl $0, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	12	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return divu<12>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	13	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return divs<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 4096(%rax), %edx orl %ecx, %edx andl $8191, %edx ## imm = 0x1FFF cmpw $1, %dx adcl $0, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	13	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return divu<13>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	14	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return divs<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 8192(%rax), %edx orl %ecx, %edx andl $16383, %edx ## imm = 0x3FFF cmpw $1, %dx adcl $0, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	14	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return divu<14>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	15	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return divs<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 16384(%rax), %edx orl %ecx, %edx andl $32767, %edx ## imm = 0x7FFF cmpw $1, %dx adcl $0, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	15	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return divu<15>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	16	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return divs<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal 1(%rsi), %ecx movl %edi, %edx xorl $32768, %edx ## imm = 0x8000 xorl %eax, %eax orw %cx, %dx sete %al addl %edi, %eax cltd idivl %esi cwtl popq %rbp retq
x86_64	16	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return divu<16>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divw %si movzwl %ax, %eax popq %rbp retq
x86_64	17	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return divs<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 65536(%rax), %edx orl %ecx, %edx andl $131071, %edx ## imm = 0x1FFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	17	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return divu<17>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	18	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return divs<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 131072(%rax), %edx orl %ecx, %edx andl $262143, %edx ## imm = 0x3FFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	18	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return divu<18>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	19	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return divs<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 262144(%rax), %edx orl %ecx, %edx andl $524287, %edx ## imm = 0x7FFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	19	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return divu<19>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	20	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return divs<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 524288(%rax), %edx orl %ecx, %edx andl $1048575, %edx ## imm = 0xFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	20	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return divu<20>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	21	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return divs<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 1048576(%rax), %edx orl %ecx, %edx andl $2097151, %edx ## imm = 0x1FFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	21	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return divu<21>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	22	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return divs<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 2097152(%rax), %edx orl %ecx, %edx andl $4194303, %edx ## imm = 0x3FFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	22	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return divu<22>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	23	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return divs<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 4194304(%rax), %edx orl %ecx, %edx andl $8388607, %edx ## imm = 0x7FFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	23	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return divu<23>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	24	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return divs<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 8388608(%rax), %edx orl %ecx, %edx andl $16777215, %edx ## imm = 0xFFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	24	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return divu<24>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	25	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return divs<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 16777216(%rax), %edx orl %ecx, %edx andl $33554431, %edx ## imm = 0x1FFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	25	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return divu<25>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	26	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return divs<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 33554432(%rax), %edx orl %ecx, %edx andl $67108863, %edx ## imm = 0x3FFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	26	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return divu<26>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	27	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return divs<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 67108864(%rax), %edx orl %ecx, %edx andl $134217727, %edx ## imm = 0x7FFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	27	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return divu<27>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	28	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return divs<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 134217728(%rax), %edx orl %ecx, %edx andl $268435455, %edx ## imm = 0xFFFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	28	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return divu<28>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	29	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return divs<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 268435456(%rax), %edx orl %ecx, %edx andl $536870911, %edx ## imm = 0x1FFFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	29	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return divu<29>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	30	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return divs<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 536870912(%rax), %edx orl %ecx, %edx andl $1073741823, %edx ## imm = 0x3FFFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	30	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return divu<30>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	31	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return divs<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax leal 1(%rsi), %ecx leal 1073741824(%rax), %edx orl %ecx, %edx andl $2147483647, %edx ## imm = 0x7FFFFFFF cmpl $1, %edx adcl $0, %eax cltd idivl %esi popq %rbp retq
x86_64	31	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return divu<31>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	32	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return divs<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leal 1(%rsi), %ecx movl %edi, %edx xorl $-2147483648, %edx ## imm = 0x80000000 xorl %eax, %eax orl %ecx, %edx sete %al addl %edi, %eax cltd idivl %esi popq %rbp retq
x86_64	32	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return divu<32>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movl %edi, %eax xorl %edx, %edx divl %esi popq %rbp retq
x86_64	33	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return divs<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $4294967296, %rdx ## imm = 0x100000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $8589934591, %rcx ## imm = 0x1FFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	33	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return divu<33>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	34	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return divs<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $8589934592, %rdx ## imm = 0x200000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $17179869183, %rcx ## imm = 0x3FFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	34	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return divu<34>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	35	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return divs<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $17179869184, %rdx ## imm = 0x400000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $34359738367, %rcx ## imm = 0x7FFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	35	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return divu<35>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	36	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return divs<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $34359738368, %rdx ## imm = 0x800000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $68719476735, %rcx ## imm = 0xFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	36	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return divu<36>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	37	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return divs<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $68719476736, %rdx ## imm = 0x1000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $137438953471, %rcx ## imm = 0x1FFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	37	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return divu<37>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	38	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return divs<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $137438953472, %rdx ## imm = 0x2000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $274877906943, %rcx ## imm = 0x3FFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	38	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return divu<38>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	39	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return divs<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $274877906944, %rdx ## imm = 0x4000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $549755813887, %rcx ## imm = 0x7FFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	39	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return divu<39>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	40	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return divs<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $549755813888, %rdx ## imm = 0x8000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $1099511627775, %rcx ## imm = 0xFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	40	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return divu<40>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	41	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return divs<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $1099511627776, %rdx ## imm = 0x10000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $2199023255551, %rcx ## imm = 0x1FFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	41	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return divu<41>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	42	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return divs<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $2199023255552, %rdx ## imm = 0x20000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $4398046511103, %rcx ## imm = 0x3FFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	42	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return divu<42>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	43	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return divs<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $4398046511104, %rdx ## imm = 0x40000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $8796093022207, %rcx ## imm = 0x7FFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	43	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return divu<43>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	44	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return divs<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $8796093022208, %rdx ## imm = 0x80000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $17592186044415, %rcx ## imm = 0xFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	44	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return divu<44>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	45	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return divs<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $17592186044416, %rdx ## imm = 0x100000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $35184372088831, %rcx ## imm = 0x1FFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	45	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return divu<45>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	46	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return divs<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $35184372088832, %rdx ## imm = 0x200000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $70368744177663, %rcx ## imm = 0x3FFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	46	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return divu<46>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	47	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return divs<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $70368744177664, %rdx ## imm = 0x400000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $140737488355327, %rcx ## imm = 0x7FFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	47	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return divu<47>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	48	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return divs<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $140737488355328, %rdx ## imm = 0x800000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $281474976710655, %rcx ## imm = 0xFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	48	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return divu<48>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	49	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return divs<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $281474976710656, %rdx ## imm = 0x1000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $562949953421311, %rcx ## imm = 0x1FFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	49	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return divu<49>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	50	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return divs<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $562949953421312, %rdx ## imm = 0x2000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $1125899906842623, %rcx ## imm = 0x3FFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	50	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return divu<50>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	51	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return divs<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $1125899906842624, %rdx ## imm = 0x4000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $2251799813685247, %rcx ## imm = 0x7FFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	51	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return divu<51>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	52	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return divs<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $2251799813685248, %rdx ## imm = 0x8000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $4503599627370495, %rcx ## imm = 0xFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	52	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return divu<52>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	53	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return divs<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $4503599627370496, %rdx ## imm = 0x10000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $9007199254740991, %rcx ## imm = 0x1FFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	53	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return divu<53>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	54	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return divs<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $9007199254740992, %rdx ## imm = 0x20000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $18014398509481983, %rcx ## imm = 0x3FFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	54	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return divu<54>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	55	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return divs<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $18014398509481984, %rdx ## imm = 0x40000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $36028797018963967, %rcx ## imm = 0x7FFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	55	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return divu<55>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	56	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return divs<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $36028797018963968, %rdx ## imm = 0x80000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $72057594037927935, %rcx ## imm = 0xFFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	56	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return divu<56>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	57	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return divs<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $72057594037927936, %rdx ## imm = 0x100000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $144115188075855871, %rcx ## imm = 0x1FFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	57	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return divu<57>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	58	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return divs<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $144115188075855872, %rdx ## imm = 0x200000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $288230376151711743, %rcx ## imm = 0x3FFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	58	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return divu<58>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	59	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return divs<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $288230376151711744, %rdx ## imm = 0x400000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $576460752303423487, %rcx ## imm = 0x7FFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	59	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return divu<59>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	60	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return divs<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $576460752303423488, %rdx ## imm = 0x800000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $1152921504606846975, %rcx ## imm = 0xFFFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	60	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return divu<60>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	61	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return divs<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $1152921504606846976, %rdx ## imm = 0x1000000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $2305843009213693951, %rcx ## imm = 0x1FFFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	61	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return divu<61>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	62	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return divs<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $2305843009213693952, %rdx ## imm = 0x2000000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $4611686018427387903, %rcx ## imm = 0x3FFFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	62	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return divu<62>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	63	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return divs<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax leaq 1(%rsi), %rcx movabsq $4611686018427387904, %rdx ## imm = 0x4000000000000000 addq %rdi, %rdx orq %rcx, %rdx movabsq $9223372036854775807, %rcx ## imm = 0x7FFFFFFFFFFFFFFF andq %rdx, %rcx cmpq $1, %rcx adcq $0, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	63	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return divu<63>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	64	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return divs<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp leaq 1(%rsi), %rcx movabsq $-9223372036854775808, %rdx ## imm = 0x8000000000000000 xorq %rdi, %rdx xorl %eax, %eax orq %rcx, %rdx sete %al addq %rdi, %rax movq %rax, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 cqto idivq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
x86_64	64	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return divu<64>(a, b); }	_f: ## @f pushq %rbp movq %rsp, %rbp movq %rdi, %rax movq %rdi, %rcx orq %rsi, %rcx shrq $32, %rcx je LBB0_1 xorl %edx, %edx divq %rsi popq %rbp retq LBB0_1: xorl %edx, %edx divl %esi popq %rbp retq
arm	4	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return adds<4>(a, b); }	_f: mov r2, #16 and r2, r2, r0, lsl #1 add r0, r1, r0 add r2, r2, #112 lsl r2, r2, #24 eor r3, r1, r2, asr #28 eor r1, r0, r1 lsl r0, r0, #28 mvn r1, r1 asr r0, r0, #28 orr r1, r3, r1 tst r1, #8 asreq r0, r2, #28 bx lr
arm	4	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return addu<4>(a, b); }	_f: add r1, r1, r0 and r2, r1, #255 and r0, r1, #15 cmp r2, #15 movhi r0, #15 cmp r2, r1 movne r0, #15 bx lr
arm	5	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return adds<5>(a, b); }	_f: mov r2, #8 and r2, r2, r0, lsr #1 add r0, r1, r0 add r2, r2, #120 lsl r2, r2, #24 eor r3, r1, r2, asr #27 eor r1, r0, r1 lsl r0, r0, #27 mvn r1, r1 asr r0, r0, #27 orr r1, r3, r1 tst r1, #16 asreq r0, r2, #27 bx lr
arm	5	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return addu<5>(a, b); }	_f: add r1, r1, r0 and r2, r1, #255 and r0, r1, #31 cmp r2, #31 movhi r0, #31 cmp r2, r1 movne r0, #31 bx lr
arm	6	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return adds<6>(a, b); }	_f: mov r2, #4 and r2, r2, r0, lsr #3 add r0, r1, r0 add r2, r2, #124 lsl r2, r2, #24 eor r3, r1, r2, asr #26 eor r1, r0, r1 lsl r0, r0, #26 mvn r1, r1 asr r0, r0, #26 orr r1, r3, r1 tst r1, #32 asreq r0, r2, #26 bx lr
arm	6	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return addu<6>(a, b); }	_f: add r1, r1, r0 and r2, r1, #255 and r0, r1, #63 cmp r2, #63 movhi r0, #63 cmp r2, r1 movne r0, #63 bx lr
arm	7	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return adds<7>(a, b); }	_f: mov r2, #2 and r2, r2, r0, lsr #5 add r0, r1, r0 add r2, r2, #126 lsl r2, r2, #24 eor r3, r1, r2, asr #25 eor r1, r0, r1 lsl r0, r0, #25 mvn r1, r1 asr r0, r0, #25 orr r1, r3, r1 tst r1, #64 asreq r0, r2, #25 bx lr
arm	7	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return addu<7>(a, b); }	_f: add r0, r1, r0 and r1, r0, #255 subs r2, r1, r0 movne r2, #1 orr r1, r2, r1, lsr #7 rsb r1, r1, #0 orr r0, r0, r1 and r0, r0, #127 bx lr
arm	8	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return adds<8>(a, b); }	_f: and r2, r0, #255 mov r3, #127 add r0, r1, r0 add r2, r3, r2, lsr #7 eor r3, r2, r1 eor r1, r0, r1 mvn r1, r1 orr r1, r3, r1 lsl r1, r1, #24 asr r1, r1, #24 cmn r1, #1 movgt r0, r2 lsl r0, r0, #24 asr r0, r0, #24 bx lr
arm	8	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return addu<8>(a, b); }	_f: add r0, r0, r1 cmp r0, #255 movhs r0, #255 bx lr
arm	9	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return adds<9>(a, b); }	_f: mov r2, #128 and r2, r2, r0, lsr #1 add r0, r1, r0 add r2, r2, #16256 add r2, r2, #16384 lsl r2, r2, #16 eor r3, r1, r2, asr #23 eor r1, r0, r1 lsl r0, r0, #23 mvn r1, r1 asr r0, r0, #23 orr r1, r3, r1 tst r1, #256 asreq r0, r2, #23 bx lr
arm	9	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return addu<9>(a, b); }	_f: add r1, r1, r0 mov r0, #255 mov r3, #255 orr r0, r0, #65280 orr r3, r3, #256 and r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #9 mov r0, r3 andeq r0, r1, r0 cmp r2, r1 movne r0, r3 bx lr
arm	10	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return adds<10>(a, b); }	_f: mov r2, #64 and r2, r2, r0, lsr #3 add r0, r1, r0 add r2, r2, #16320 add r2, r2, #16384 lsl r2, r2, #16 eor r3, r1, r2, asr #22 eor r1, r0, r1 lsl r0, r0, #22 mvn r1, r1 asr r0, r0, #22 orr r1, r3, r1 tst r1, #512 asreq r0, r2, #22 bx lr
arm	10	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return addu<10>(a, b); }	_f: add r1, r1, r0 mov r0, #255 mov r3, #255 orr r0, r0, #65280 orr r3, r3, #768 and r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #10 mov r0, r3 andeq r0, r1, r0 cmp r2, r1 movne r0, r3 bx lr
arm	11	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return adds<11>(a, b); }	_f: mov r2, #32 and r2, r2, r0, lsr #5 add r0, r1, r0 add r2, r2, #4064 add r2, r2, #28672 lsl r2, r2, #16 eor r3, r1, r2, asr #21 eor r1, r0, r1 lsl r0, r0, #21 mvn r1, r1 asr r0, r0, #21 orr r1, r3, r1 tst r1, #1024 asreq r0, r2, #21 bx lr
arm	11	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return addu<11>(a, b); }	_f: add r1, r1, r0 mov r0, #255 mov r3, #255 orr r0, r0, #65280 orr r3, r3, #1792 and r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #11 mov r0, r3 andeq r0, r1, r0 cmp r2, r1 movne r0, r3 bx lr
arm	12	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return adds<12>(a, b); }	_f: mov r2, #16 and r2, r2, r0, lsr #7 add r0, r1, r0 add r2, r2, #4080 add r2, r2, #28672 lsl r2, r2, #16 eor r3, r1, r2, asr #20 eor r1, r0, r1 lsl r0, r0, #20 mvn r1, r1 asr r0, r0, #20 orr r1, r3, r1 tst r1, #2048 asreq r0, r2, #20 bx lr
arm	12	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return addu<12>(a, b); }	_f: add r1, r1, r0 mov r0, #255 mov r3, #255 orr r0, r0, #65280 orr r3, r3, #3840 and r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #12 mov r0, r3 andeq r0, r1, r0 cmp r2, r1 movne r0, r3 bx lr
arm	13	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return adds<13>(a, b); }	_f: mov r2, #8 and r2, r2, r0, lsr #9 add r0, r1, r0 add r2, r2, #1016 add r2, r2, #31744 lsl r2, r2, #16 eor r3, r1, r2, asr #19 eor r1, r0, r1 lsl r0, r0, #19 mvn r1, r1 asr r0, r0, #19 orr r1, r3, r1 tst r1, #4096 asreq r0, r2, #19 bx lr
arm	13	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return addu<13>(a, b); }	_f: add r1, r1, r0 mov r0, #255 mov r3, #255 orr r0, r0, #65280 orr r3, r3, #7936 and r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #13 mov r0, r3 andeq r0, r1, r0 cmp r2, r1 movne r0, r3 bx lr
arm	14	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return adds<14>(a, b); }	_f: mov r2, #4 and r2, r2, r0, lsr #11 add r0, r1, r0 add r2, r2, #1020 add r2, r2, #31744 lsl r2, r2, #16 eor r3, r1, r2, asr #18 eor r1, r0, r1 lsl r0, r0, #18 mvn r1, r1 asr r0, r0, #18 orr r1, r3, r1 tst r1, #8192 asreq r0, r2, #18 bx lr
arm	14	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return addu<14>(a, b); }	_f: add r1, r1, r0 mov r0, #255 mov r3, #255 orr r0, r0, #65280 orr r3, r3, #16128 and r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #14 mov r0, r3 andeq r0, r1, r0 cmp r2, r1 movne r0, r3 bx lr
arm	15	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return adds<15>(a, b); }	_f: mov r2, #2 and r2, r2, r0, lsr #13 add r0, r1, r0 add r2, r2, #254 add r2, r2, #32512 lsl r2, r2, #16 eor r3, r1, r2, asr #17 eor r1, r0, r1 lsl r0, r0, #17 mvn r1, r1 asr r0, r0, #17 orr r1, r3, r1 tst r1, #16384 asreq r0, r2, #17 bx lr
arm	15	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return addu<15>(a, b); }	_f: add r0, r1, r0 mov r1, #255 orr r1, r1, #65280 and r1, r0, r1 subs r2, r1, r0 movne r2, #1 orr r1, r2, r1, lsr #15 rsb r1, r1, #0 orr r0, r0, r1 mov r1, #255 orr r1, r1, #32512 and r0, r0, r1 bx lr
arm	16	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return adds<16>(a, b); }	_f: mov r2, #255 mov r3, #255 orr r2, r2, #65280 orr r3, r3, #32512 and r2, r0, r2 add r0, r1, r0 add r2, r3, r2, lsr #15 eor r3, r2, r1 eor r1, r0, r1 mvn r1, r1 orr r1, r3, r1 lsl r1, r1, #16 asr r1, r1, #16 cmn r1, #1 movgt r0, r2 lsl r0, r0, #16 asr r0, r0, #16 bx lr
arm	16	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return addu<16>(a, b); }	_f: add r1, r0, r1 mov r0, #255 orr r0, r0, #65280 cmp r1, r0 movlo r0, r1 bx lr
arm	17	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return adds<17>(a, b); }	_f: ldr r3, LCPI0_0 mov r2, #32768 and r2, r2, r0, lsr #1 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #15 eor r1, r0, r1 lsl r0, r0, #15 mvn r1, r1 asr r0, r0, #15 orr r1, r3, r1 tst r1, #65536 asreq r0, r2, #15 bx lr LCPI0_0:
arm	17	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return addu<17>(a, b); }	_f: ldr r3, LCPI0_0 add r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #17 mov r0, r3 andeq r0, r2, r0 cmp r2, r1 movlo r0, r3 bx lr LCPI0_0:
arm	18	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return adds<18>(a, b); }	_f: ldr r3, LCPI0_0 mov r2, #16384 and r2, r2, r0, lsr #3 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #14 eor r1, r0, r1 lsl r0, r0, #14 mvn r1, r1 asr r0, r0, #14 orr r1, r3, r1 tst r1, #131072 asreq r0, r2, #14 bx lr LCPI0_0:
arm	18	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return addu<18>(a, b); }	_f: ldr r3, LCPI0_0 add r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #18 mov r0, r3 andeq r0, r2, r0 cmp r2, r1 movlo r0, r3 bx lr LCPI0_0:
arm	19	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return adds<19>(a, b); }	_f: ldr r3, LCPI0_0 mov r2, #8192 and r2, r2, r0, lsr #5 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #13 eor r1, r0, r1 lsl r0, r0, #13 mvn r1, r1 asr r0, r0, #13 orr r1, r3, r1 tst r1, #262144 asreq r0, r2, #13 bx lr LCPI0_0:
arm	19	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return addu<19>(a, b); }	_f: ldr r3, LCPI0_0 add r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #19 mov r0, r3 andeq r0, r2, r0 cmp r2, r1 movlo r0, r3 bx lr LCPI0_0:
arm	20	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return adds<20>(a, b); }	_f: ldr r3, LCPI0_0 mov r2, #4096 and r2, r2, r0, lsr #7 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #12 eor r1, r0, r1 lsl r0, r0, #12 mvn r1, r1 asr r0, r0, #12 orr r1, r3, r1 tst r1, #524288 asreq r0, r2, #12 bx lr LCPI0_0:
arm	20	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return addu<20>(a, b); }	_f: ldr r3, LCPI0_0 add r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #20 mov r0, r3 andeq r0, r2, r0 cmp r2, r1 movlo r0, r3 bx lr LCPI0_0:
arm	21	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return adds<21>(a, b); }	_f: ldr r3, LCPI0_0 mov r2, #2048 and r2, r2, r0, lsr #9 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #11 eor r1, r0, r1 lsl r0, r0, #11 mvn r1, r1 asr r0, r0, #11 orr r1, r3, r1 tst r1, #1048576 asreq r0, r2, #11 bx lr LCPI0_0:
arm	21	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return addu<21>(a, b); }	_f: ldr r3, LCPI0_0 add r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #21 mov r0, r3 andeq r0, r2, r0 cmp r2, r1 movlo r0, r3 bx lr LCPI0_0:
arm	22	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return adds<22>(a, b); }	_f: ldr r3, LCPI0_0 mov r2, #1024 and r2, r2, r0, lsr #11 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #10 eor r1, r0, r1 lsl r0, r0, #10 mvn r1, r1 asr r0, r0, #10 orr r1, r3, r1 tst r1, #2097152 asreq r0, r2, #10 bx lr LCPI0_0:
arm	22	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return addu<22>(a, b); }	_f: ldr r3, LCPI0_0 add r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #22 mov r0, r3 andeq r0, r2, r0 cmp r2, r1 movlo r0, r3 bx lr LCPI0_0:
arm	23	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return adds<23>(a, b); }	_f: ldr r3, LCPI0_0 mov r2, #512 and r2, r2, r0, lsr #13 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #9 eor r1, r0, r1 lsl r0, r0, #9 mvn r1, r1 asr r0, r0, #9 orr r1, r3, r1 tst r1, #4194304 asreq r0, r2, #9 bx lr LCPI0_0:
arm	23	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return addu<23>(a, b); }	_f: ldr r3, LCPI0_0 add r2, r1, r0 mov r0, #0 cmp r0, r2, lsr #23 mov r0, r3 andeq r0, r2, r0 cmp r2, r1 movlo r0, r3 bx lr LCPI0_0:
arm	24	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return adds<24>(a, b); }	_f: mov r2, #256 and r2, r2, r0, lsr #15 add r0, r1, r0 sub r2, r2, #256 sub r2, r2, #-2147483648 eor r3, r1, r2, asr #8 eor r1, r0, r1 lsl r0, r0, #8 mvn r1, r1 asr r0, r0, #8 orr r1, r3, r1 tst r1, #8388608 asreq r0, r2, #8 bx lr
arm	24	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return addu<24>(a, b); }	_f: add r2, r1, r0 mov r3, #0 bic r0, r2, #-16777216 cmp r3, r2, lsr #24 mvnne r0, #-16777216 cmp r2, r1 mvnlo r0, #-16777216 bx lr
arm	25	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return adds<25>(a, b); }	_f: mov r2, #128 and r2, r2, r0, lsr #17 add r0, r1, r0 sub r2, r2, #128 sub r2, r2, #-2147483648 eor r3, r1, r2, asr #7 eor r1, r0, r1 lsl r0, r0, #7 mvn r1, r1 asr r0, r0, #7 orr r1, r3, r1 tst r1, #16777216 asreq r0, r2, #7 bx lr
arm	25	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return addu<25>(a, b); }	_f: add r2, r1, r0 mov r3, #0 bic r0, r2, #-33554432 cmp r3, r2, lsr #25 mvnne r0, #-33554432 cmp r2, r1 mvnlo r0, #-33554432 bx lr
arm	26	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return adds<26>(a, b); }	_f: mov r2, #64 mvn r3, #-2147483585 and r2, r2, r0, lsr #19 add r0, r1, r0 add r2, r2, r3 eor r3, r1, r2, asr #6 eor r1, r0, r1 lsl r0, r0, #6 mvn r1, r1 asr r0, r0, #6 orr r1, r3, r1 tst r1, #33554432 asreq r0, r2, #6 bx lr
arm	26	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return addu<26>(a, b); }	_f: add r2, r1, r0 bic r0, r2, #-67108864 cmn r2, #-67108863 mvnhi r0, #-67108864 cmp r2, r1 mvnlo r0, #-67108864 bx lr
arm	27	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return adds<27>(a, b); }	_f: mov r2, #32 and r2, r2, r0, lsr #21 add r0, r1, r0 sub r2, r2, #-2147483616 eor r3, r1, r2, asr #5 eor r1, r0, r1 lsl r0, r0, #5 mvn r1, r1 asr r0, r0, #5 orr r1, r3, r1 tst r1, #67108864 asreq r0, r2, #5 bx lr
arm	27	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return addu<27>(a, b); }	_f: add r2, r1, r0 bic r0, r2, #-134217728 cmn r2, #-134217727 mvnhi r0, #-134217728 cmp r2, r1 mvnlo r0, #-134217728 bx lr
arm	28	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return adds<28>(a, b); }	_f: mov r2, #16 and r2, r2, r0, lsr #23 add r0, r1, r0 sub r2, r2, #-2147483632 eor r3, r1, r2, asr #4 eor r1, r0, r1 lsl r0, r0, #4 mvn r1, r1 asr r0, r0, #4 orr r1, r3, r1 tst r1, #134217728 asreq r0, r2, #4 bx lr
arm	28	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return addu<28>(a, b); }	_f: add r2, r1, r0 bic r0, r2, #-268435456 cmn r2, #-268435455 mvnhi r0, #-268435456 cmp r2, r1 mvnlo r0, #-268435456 bx lr
arm	29	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return adds<29>(a, b); }	_f: mov r2, #8 and r2, r2, r0, lsr #25 add r0, r1, r0 sub r2, r2, #-2147483640 eor r3, r1, r2, asr #3 eor r1, r0, r1 lsl r0, r0, #3 mvn r1, r1 asr r0, r0, #3 orr r1, r3, r1 tst r1, #268435456 asreq r0, r2, #3 bx lr
arm	29	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return addu<29>(a, b); }	_f: add r2, r1, r0 bic r0, r2, #-536870912 cmn r2, #-536870911 mvnhi r0, #-536870912 cmp r2, r1 mvnlo r0, #-536870912 bx lr
arm	30	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return adds<30>(a, b); }	_f: mov r2, #4 and r2, r2, r0, lsr #27 add r0, r1, r0 sub r2, r2, #-2147483644 eor r3, r1, r2, asr #2 eor r1, r0, r1 lsl r0, r0, #2 mvn r1, r1 asr r0, r0, #2 orr r1, r3, r1 tst r1, #536870912 asreq r0, r2, #2 bx lr
arm	30	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return addu<30>(a, b); }	_f: add r2, r1, r0 bic r0, r2, #-1073741824 cmn r2, #-1073741823 mvnhi r0, #-1073741824 cmp r2, r1 mvnlo r0, #-1073741824 bx lr
arm	31	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return adds<31>(a, b); }	_f: mov r2, #2 and r2, r2, r0, lsr #29 add r0, r1, r0 sub r2, r2, #-2147483646 eor r3, r1, r2, asr #1 eor r1, r0, r1 lsl r0, r0, #1 mvn r1, r1 asr r0, r0, #1 orr r1, r3, r1 tst r1, #1073741824 asreq r0, r2, #1 bx lr
arm	31	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return addu<31>(a, b); }	_f: mov r2, #0 adds r0, r1, r0 adc r1, r2, #0 orr r1, r1, r0, lsr #31 rsb r1, r1, #0 orr r0, r0, r1 bic r0, r0, #-2147483648 bx lr
arm	32	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return adds<32>(a, b); }	_f: mvn r2, #-2147483648 add r2, r2, r0, lsr #31 add r0, r1, r0 eor r3, r2, r1 eor r1, r0, r1 mvn r1, r1 orr r1, r3, r1 cmn r1, #1 movgt r0, r2 bx lr
arm	32	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return addu<32>(a, b); }	_f: adds r0, r0, r1 mvnhs r0, #0 bx lr
arm	33	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return adds<33>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #255 mov lr, #0 and r12, r12, r1, lsl #7 subs r12, r12, #128 adc lr, lr, #127 adds r0, r2, r0 lsr r12, r12, #7 adc r1, r3, r1 lsl lr, lr, #24 eor r2, r1, r3 eor r5, r3, lr, asr #31 and r1, r1, #1 asr r4, lr, #24 mvn r2, r2 rsb r1, r1, #0 orr r2, r5, r2 ands r2, r2, #1 orreq r0, r12, r4, lsl #25 asreq r1, lr, #31 pop {r4, r5, r7, lr} bx lr
arm	33	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return addu<33>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #1 and r1, r1, #1 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #1 bx lr
arm	34	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return adds<34>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #64 mov lr, #0 and r12, r12, r1, lsl #5 subs r12, r12, #64 adc lr, lr, #127 adds r0, r2, r0 lsr r12, r12, #6 adc r1, r3, r1 lsl lr, lr, #24 eor r2, r1, r3 eor r5, r3, lr, asr #30 lsl r1, r1, #30 asr r4, lr, #24 mvn r2, r2 asr r1, r1, #30 orr r2, r5, r2 ands r2, r2, #2 orreq r0, r12, r4, lsl #26 asreq r1, lr, #30 pop {r4, r5, r7, lr} bx lr
arm	34	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return addu<34>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #3 and r1, r1, #3 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #3 bx lr
arm	35	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return adds<35>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #32 mov lr, #0 and r12, r12, r1, lsl #3 subs r12, r12, #32 adc lr, lr, #127 adds r0, r2, r0 lsr r12, r12, #5 adc r1, r3, r1 lsl lr, lr, #24 eor r2, r1, r3 eor r5, r3, lr, asr #29 lsl r1, r1, #29 asr r4, lr, #24 mvn r2, r2 asr r1, r1, #29 orr r2, r5, r2 ands r2, r2, #4 orreq r0, r12, r4, lsl #27 asreq r1, lr, #29 pop {r4, r5, r7, lr} bx lr
arm	35	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return addu<35>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #7 and r1, r1, #7 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #7 bx lr
arm	36	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return adds<36>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #16 mov lr, #0 and r12, r12, r1, lsl #1 subs r12, r12, #16 adc lr, lr, #127 adds r0, r2, r0 lsr r12, r12, #4 adc r1, r3, r1 lsl lr, lr, #24 eor r2, r1, r3 eor r5, r3, lr, asr #28 lsl r1, r1, #28 asr r4, lr, #24 mvn r2, r2 asr r1, r1, #28 orr r2, r5, r2 ands r2, r2, #8 orreq r0, r12, r4, lsl #28 asreq r1, lr, #28 pop {r4, r5, r7, lr} bx lr
arm	36	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return addu<36>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #15 and r1, r1, #15 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #15 bx lr
arm	37	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return adds<37>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #8 mov lr, #0 and r12, r12, r1, lsr #1 subs r12, r12, #8 adc lr, lr, #127 adds r0, r2, r0 lsr r12, r12, #3 adc r1, r3, r1 lsl lr, lr, #24 eor r2, r1, r3 eor r5, r3, lr, asr #27 lsl r1, r1, #27 asr r4, lr, #24 mvn r2, r2 asr r1, r1, #27 orr r2, r5, r2 ands r2, r2, #16 orreq r0, r12, r4, lsl #29 asreq r1, lr, #27 pop {r4, r5, r7, lr} bx lr
arm	37	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return addu<37>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #31 and r1, r1, #31 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #31 bx lr
arm	38	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return adds<38>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #4 mov lr, #0 and r12, r12, r1, lsr #3 subs r12, r12, #4 adc lr, lr, #127 adds r0, r2, r0 lsr r12, r12, #2 adc r1, r3, r1 lsl lr, lr, #24 eor r2, r1, r3 eor r5, r3, lr, asr #26 lsl r1, r1, #26 asr r4, lr, #24 mvn r2, r2 asr r1, r1, #26 orr r2, r5, r2 ands r2, r2, #32 orreq r0, r12, r4, lsl #30 asreq r1, lr, #26 pop {r4, r5, r7, lr} bx lr
arm	38	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return addu<38>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #63 and r1, r1, #63 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #63 bx lr
arm	39	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return adds<39>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mov r12, #2 mov lr, #0 and r12, r12, r1, lsr #5 subs r12, r12, #2 adc lr, lr, #127 lsl lr, lr, #24 asr lr, lr, #24 asrs lr, lr, #1 rrx r12, r12 adds r0, r2, r0 eor r4, lr, r3 adc r1, r3, r1 eor r2, r1, r3 lsl r1, r1, #25 mvn r2, r2 orr r2, r4, r2 ands r2, r2, #64 asrne lr, r1, #25 moveq r0, r12 lsl r1, lr, #24 asr r1, r1, #24 pop {r4, r7, lr} bx lr
arm	39	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return addu<39>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #127 and r1, r1, #127 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #127 bx lr
arm	40	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return adds<40>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 and r12, r1, #255 mvn r4, #0 mov lr, #0 adds r12, r4, r12, lsr #7 adc r4, lr, #127 adds r0, r2, r0 adc r1, r3, r1 eor lr, r4, r3 eor r2, r1, r3 mvn r2, r2 orr r2, lr, r2 lsl r2, r2, #24 asr r2, r2, #24 cmn r2, #1 movgt r1, r4 movgt r0, r12 lsl r1, r1, #24 asr r1, r1, #24 pop {r4, r7, lr} bx lr
arm	40	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return addu<40>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmp r1, #255 and r1, r1, #255 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 movne r1, #255 bx lr
arm	41	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return adds<41>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #128 mov lr, #255 mov r4, #0 and r12, r12, r1, lsr #1 orr lr, lr, #32512 subs r12, r12, #128 adc r4, r4, lr adds r0, r2, r0 lsr r12, r12, #7 adc r1, r3, r1 lsl r4, r4, #16 eor r2, r1, r3 eor r5, r3, r4, asr #23 lsl r1, r1, #23 asr lr, r4, #16 mvn r2, r2 asr r1, r1, #23 orr r2, r5, r2 ands r2, r2, #256 orreq r0, r12, lr, lsl #25 asreq r1, r4, #23 pop {r4, r5, r7, lr} bx lr
arm	41	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return addu<41>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #9 cmp r12, r2, lsr #9 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #256 andeq r1, r2, r1 bx lr
arm	42	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return adds<42>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #64 mov lr, #255 mov r4, #0 and r12, r12, r1, lsr #3 orr lr, lr, #32512 subs r12, r12, #64 adc r4, r4, lr adds r0, r2, r0 lsr r12, r12, #6 adc r1, r3, r1 lsl r4, r4, #16 eor r2, r1, r3 eor r5, r3, r4, asr #22 lsl r1, r1, #22 asr lr, r4, #16 mvn r2, r2 asr r1, r1, #22 orr r2, r5, r2 ands r2, r2, #512 orreq r0, r12, lr, lsl #26 asreq r1, r4, #22 pop {r4, r5, r7, lr} bx lr
arm	42	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return addu<42>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #10 cmp r12, r2, lsr #10 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #768 andeq r1, r2, r1 bx lr
arm	43	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return adds<43>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #32 mov lr, #255 mov r4, #0 and r12, r12, r1, lsr #5 orr lr, lr, #32512 subs r12, r12, #32 adc r4, r4, lr adds r0, r2, r0 lsr r12, r12, #5 adc r1, r3, r1 lsl r4, r4, #16 eor r2, r1, r3 eor r5, r3, r4, asr #21 lsl r1, r1, #21 asr lr, r4, #16 mvn r2, r2 asr r1, r1, #21 orr r2, r5, r2 ands r2, r2, #1024 orreq r0, r12, lr, lsl #27 asreq r1, r4, #21 pop {r4, r5, r7, lr} bx lr
arm	43	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return addu<43>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #11 cmp r12, r2, lsr #11 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #1792 andeq r1, r2, r1 bx lr
arm	44	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return adds<44>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #16 mov lr, #255 mov r4, #0 and r12, r12, r1, lsr #7 orr lr, lr, #32512 subs r12, r12, #16 adc r4, r4, lr adds r0, r2, r0 lsr r12, r12, #4 adc r1, r3, r1 lsl r4, r4, #16 eor r2, r1, r3 eor r5, r3, r4, asr #20 lsl r1, r1, #20 asr lr, r4, #16 mvn r2, r2 asr r1, r1, #20 orr r2, r5, r2 ands r2, r2, #2048 orreq r0, r12, lr, lsl #28 asreq r1, r4, #20 pop {r4, r5, r7, lr} bx lr
arm	44	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return addu<44>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #12 cmp r12, r2, lsr #12 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #3840 andeq r1, r2, r1 bx lr
arm	45	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return adds<45>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #8 mov lr, #255 mov r4, #0 and r12, r12, r1, lsr #9 orr lr, lr, #32512 subs r12, r12, #8 adc r4, r4, lr adds r0, r2, r0 lsr r12, r12, #3 adc r1, r3, r1 lsl r4, r4, #16 eor r2, r1, r3 eor r5, r3, r4, asr #19 lsl r1, r1, #19 asr lr, r4, #16 mvn r2, r2 asr r1, r1, #19 orr r2, r5, r2 ands r2, r2, #4096 orreq r0, r12, lr, lsl #29 asreq r1, r4, #19 pop {r4, r5, r7, lr} bx lr
arm	45	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return addu<45>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #13 cmp r12, r2, lsr #13 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #7936 andeq r1, r2, r1 bx lr
arm	46	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return adds<46>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #4 mov lr, #255 mov r4, #0 and r12, r12, r1, lsr #11 orr lr, lr, #32512 subs r12, r12, #4 adc r4, r4, lr adds r0, r2, r0 lsr r12, r12, #2 adc r1, r3, r1 lsl r4, r4, #16 eor r2, r1, r3 eor r5, r3, r4, asr #18 lsl r1, r1, #18 asr lr, r4, #16 mvn r2, r2 asr r1, r1, #18 orr r2, r5, r2 ands r2, r2, #8192 orreq r0, r12, lr, lsl #30 asreq r1, r4, #18 pop {r4, r5, r7, lr} bx lr
arm	46	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return addu<46>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #14 cmp r12, r2, lsr #14 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #16128 andeq r1, r2, r1 bx lr
arm	47	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return adds<47>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #2 mov lr, #255 mov r5, #0 and r12, r12, r1, lsr #13 orr lr, lr, #32512 subs r4, r12, #2 adc r5, r5, lr lsl r5, r5, #16 asr r5, r5, #16 asrs r5, r5, #1 rrx r12, r4 adds r0, r2, r0 eor r4, r5, r3 adc r1, r3, r1 eor r2, r1, r3 lsl r1, r1, #17 mvn r2, r2 orr r2, r4, r2 ands r2, r2, #16384 asrne r5, r1, #17 moveq r0, r12 lsl r1, r5, #16 asr r1, r1, #16 pop {r4, r5, r7, lr} bx lr
arm	47	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return addu<47>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #15 cmp r12, r2, lsr #15 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #32512 andeq r1, r2, r1 bx lr
arm	48	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return adds<48>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #255 mov lr, #255 mvn r5, #0 mov r4, #0 orr r12, r12, #65280 orr lr, lr, #32512 and r12, r1, r12 adds r12, r5, r12, lsr #15 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 eor r5, r4, r3 eor r2, r1, r3 mvn r2, r2 orr r2, r5, r2 lsl r2, r2, #16 asr r2, r2, #16 cmn r2, #1 movgt r1, r4 movgt r0, r12 lsl r1, r1, #16 asr r1, r1, #16 pop {r4, r5, r7, lr} bx lr
arm	48	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return addu<48>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #16 cmp r12, r2, lsr #16 movne r3, #1 orrs r1, r1, r3 mov r1, #255 mvnne r0, #0 orr r1, r1, #65280 andeq r1, r2, r1 bx lr
arm	49	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return adds<49>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 mov r12, #128 mov r4, #0 and r12, r12, r1, lsr #9 subs r12, r12, #128 lsr r12, r12, #7 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 lsl r4, r4, #8 eor r2, r1, r3 eor r5, r3, r4, asr #15 lsl r1, r1, #15 asr lr, r4, #8 mvn r2, r2 asr r1, r1, #15 orr r2, r5, r2 ands r2, r2, #65536 orreq r0, r12, lr, lsl #25 asreq r1, r4, #15 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	49	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return addu<49>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #17 cmp r12, r2, lsr #17 movne r3, #1 orrs r1, r1, r3 ldr r1, LCPI0_0 mvnne r0, #0 andeq r1, r2, r1 bx lr LCPI0_0:
arm	50	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return adds<50>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 mov r12, #64 mov r4, #0 and r12, r12, r1, lsr #11 subs r12, r12, #64 lsr r12, r12, #6 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 lsl r4, r4, #8 eor r2, r1, r3 eor r5, r3, r4, asr #14 lsl r1, r1, #14 asr lr, r4, #8 mvn r2, r2 asr r1, r1, #14 orr r2, r5, r2 ands r2, r2, #131072 orreq r0, r12, lr, lsl #26 asreq r1, r4, #14 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	50	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return addu<50>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #18 cmp r12, r2, lsr #18 movne r3, #1 orrs r1, r1, r3 ldr r1, LCPI0_0 mvnne r0, #0 andeq r1, r2, r1 bx lr LCPI0_0:
arm	51	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return adds<51>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 mov r12, #32 mov r4, #0 and r12, r12, r1, lsr #13 subs r12, r12, #32 lsr r12, r12, #5 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 lsl r4, r4, #8 eor r2, r1, r3 eor r5, r3, r4, asr #13 lsl r1, r1, #13 asr lr, r4, #8 mvn r2, r2 asr r1, r1, #13 orr r2, r5, r2 ands r2, r2, #262144 orreq r0, r12, lr, lsl #27 asreq r1, r4, #13 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	51	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return addu<51>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #19 cmp r12, r2, lsr #19 movne r3, #1 orrs r1, r1, r3 ldr r1, LCPI0_0 mvnne r0, #0 andeq r1, r2, r1 bx lr LCPI0_0:
arm	52	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return adds<52>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 mov r12, #16 mov r4, #0 and r12, r12, r1, lsr #15 subs r12, r12, #16 lsr r12, r12, #4 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 lsl r4, r4, #8 eor r2, r1, r3 eor r5, r3, r4, asr #12 lsl r1, r1, #12 asr lr, r4, #8 mvn r2, r2 asr r1, r1, #12 orr r2, r5, r2 ands r2, r2, #524288 orreq r0, r12, lr, lsl #28 asreq r1, r4, #12 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	52	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return addu<52>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #20 cmp r12, r2, lsr #20 movne r3, #1 orrs r1, r1, r3 ldr r1, LCPI0_0 mvnne r0, #0 andeq r1, r2, r1 bx lr LCPI0_0:
arm	53	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return adds<53>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 mov r12, #8 mov r4, #0 and r12, r12, r1, lsr #17 subs r12, r12, #8 lsr r12, r12, #3 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 lsl r4, r4, #8 eor r2, r1, r3 eor r5, r3, r4, asr #11 lsl r1, r1, #11 asr lr, r4, #8 mvn r2, r2 asr r1, r1, #11 orr r2, r5, r2 ands r2, r2, #1048576 orreq r0, r12, lr, lsl #29 asreq r1, r4, #11 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	53	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return addu<53>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #21 cmp r12, r2, lsr #21 movne r3, #1 orrs r1, r1, r3 ldr r1, LCPI0_0 mvnne r0, #0 andeq r1, r2, r1 bx lr LCPI0_0:
arm	54	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return adds<54>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 mov r12, #4 mov r4, #0 and r12, r12, r1, lsr #19 subs r12, r12, #4 lsr r12, r12, #2 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 lsl r4, r4, #8 eor r2, r1, r3 eor r5, r3, r4, asr #10 lsl r1, r1, #10 asr lr, r4, #8 mvn r2, r2 asr r1, r1, #10 orr r2, r5, r2 ands r2, r2, #2097152 orreq r0, r12, lr, lsl #30 asreq r1, r4, #10 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	54	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return addu<54>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #22 cmp r12, r2, lsr #22 movne r3, #1 orrs r1, r1, r3 ldr r1, LCPI0_0 mvnne r0, #0 andeq r1, r2, r1 bx lr LCPI0_0:
arm	55	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return adds<55>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 mov r12, #2 mov r5, #0 and r12, r12, r1, lsr #21 subs r4, r12, #2 adc r5, r5, lr lsl r5, r5, #8 asr r5, r5, #8 asrs r5, r5, #1 rrx r12, r4 adds r0, r2, r0 eor r4, r5, r3 adc r1, r3, r1 eor r2, r1, r3 lsl r1, r1, #9 mvn r2, r2 orr r2, r4, r2 ands r2, r2, #4194304 asrne r5, r1, #9 moveq r0, r12 lsl r1, r5, #8 asr r1, r1, #8 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	55	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return addu<55>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r2, r3, r1 adc r1, r12, #0 lsr r3, r2, #23 cmp r12, r2, lsr #23 movne r3, #1 orrs r1, r1, r3 ldr r1, LCPI0_0 mvnne r0, #0 andeq r1, r2, r1 bx lr LCPI0_0:
arm	56	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return adds<56>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 ldr lr, LCPI0_0 and r12, r1, #8388608 mvn r5, #0 mov r4, #0 adds r12, r5, r12, lsr #23 adc r4, r4, lr adds r0, r2, r0 adc r1, r3, r1 eor r5, r4, r3 eor r2, r1, r3 mvn r2, r2 orr r2, r5, r2 lsl r2, r2, #8 asr r2, r2, #8 cmn r2, #1 movgt r1, r4 movgt r0, r12 lsl r1, r1, #8 asr r1, r1, #8 pop {r4, r5, r7, lr} bx lr LCPI0_0:
arm	56	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return addu<56>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 lsr r3, r1, #24 cmp r12, r1, lsr #24 bic r1, r1, #-16777216 movne r3, #1 orrs r2, r2, r3 mvnne r0, #0 mvnne r1, #-16777216 bx lr
arm	57	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return adds<57>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mov r12, #128 mov lr, #0 and r12, r12, r1, lsr #17 subs r12, r12, #128 sbc lr, lr, #-2147483648 adds r0, r2, r0 lsr r12, r12, #7 adc r1, r3, r1 eor r4, r3, lr, asr #7 eor r2, r1, r3 lsl r1, r1, #7 mvn r2, r2 asr r1, r1, #7 orr r2, r4, r2 ands r2, r2, #16777216 orreq r0, r12, lr, lsl #25 asreq r1, lr, #7 pop {r4, r7, lr} bx lr
arm	57	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return addu<57>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 lsr r3, r1, #25 cmp r12, r1, lsr #25 bic r1, r1, #-33554432 movne r3, #1 orrs r2, r2, r3 mvnne r0, #0 mvnne r1, #-33554432 bx lr
arm	58	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return adds<58>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mov r12, #64 mov lr, #0 and r12, r12, r1, lsr #19 subs r12, r12, #64 sbc lr, lr, #-2147483648 adds r0, r2, r0 lsr r12, r12, #6 adc r1, r3, r1 eor r4, r3, lr, asr #6 eor r2, r1, r3 lsl r1, r1, #6 mvn r2, r2 asr r1, r1, #6 orr r2, r4, r2 ands r2, r2, #33554432 orreq r0, r12, lr, lsl #26 asreq r1, lr, #6 pop {r4, r7, lr} bx lr
arm	58	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return addu<58>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmn r1, #-67108863 bic r1, r1, #-67108864 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 mvnne r1, #-67108864 bx lr
arm	59	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return adds<59>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mov r12, #32 mov lr, #0 and r12, r12, r1, lsr #21 subs r12, r12, #32 sbc lr, lr, #-2147483648 adds r0, r2, r0 lsr r12, r12, #5 adc r1, r3, r1 eor r4, r3, lr, asr #5 eor r2, r1, r3 lsl r1, r1, #5 mvn r2, r2 asr r1, r1, #5 orr r2, r4, r2 ands r2, r2, #67108864 orreq r0, r12, lr, lsl #27 asreq r1, lr, #5 pop {r4, r7, lr} bx lr
arm	59	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return addu<59>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmn r1, #-134217727 bic r1, r1, #-134217728 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 mvnne r1, #-134217728 bx lr
arm	60	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return adds<60>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mov r12, #16 mov lr, #0 and r12, r12, r1, lsr #23 subs r12, r12, #16 sbc lr, lr, #-2147483648 adds r0, r2, r0 lsr r12, r12, #4 adc r1, r3, r1 eor r4, r3, lr, asr #4 eor r2, r1, r3 lsl r1, r1, #4 mvn r2, r2 asr r1, r1, #4 orr r2, r4, r2 ands r2, r2, #134217728 orreq r0, r12, lr, lsl #28 asreq r1, lr, #4 pop {r4, r7, lr} bx lr
arm	60	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return addu<60>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmn r1, #-268435455 bic r1, r1, #-268435456 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 mvnne r1, #-268435456 bx lr
arm	61	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return adds<61>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mov r12, #8 mov lr, #0 and r12, r12, r1, lsr #25 subs r12, r12, #8 sbc lr, lr, #-2147483648 adds r0, r2, r0 lsr r12, r12, #3 adc r1, r3, r1 eor r4, r3, lr, asr #3 eor r2, r1, r3 lsl r1, r1, #3 mvn r2, r2 asr r1, r1, #3 orr r2, r4, r2 ands r2, r2, #268435456 orreq r0, r12, lr, lsl #29 asreq r1, lr, #3 pop {r4, r7, lr} bx lr
arm	61	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return addu<61>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmn r1, #-536870911 bic r1, r1, #-536870912 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 mvnne r1, #-536870912 bx lr
arm	62	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return adds<62>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mov r12, #4 mov lr, #0 and r12, r12, r1, lsr #27 subs r12, r12, #4 sbc lr, lr, #-2147483648 adds r0, r2, r0 lsr r12, r12, #2 adc r1, r3, r1 eor r4, r3, lr, asr #2 eor r2, r1, r3 lsl r1, r1, #2 mvn r2, r2 asr r1, r1, #2 orr r2, r4, r2 ands r2, r2, #536870912 orreq r0, r12, lr, lsl #30 asreq r1, lr, #2 pop {r4, r7, lr} bx lr
arm	62	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return addu<62>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 cmn r1, #-1073741823 bic r1, r1, #-1073741824 movhi r12, #1 orrs r2, r2, r12 mvnne r0, #0 mvnne r1, #-1073741824 bx lr
arm	63	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return adds<63>(a, b); }	_f: push {r4, r5, r7, lr} add r7, sp, #8 mov r12, #2 mov lr, #0 and r12, r12, r1, lsr #29 subs r5, r12, #2 sbc r4, lr, #-2147483648 asrs r12, r4, #1 rrx r5, r5 adds r0, r2, r0 eor r4, r12, r3 adc r1, r3, r1 eor r2, r1, r3 lsl r1, r1, #1 mvn r2, r2 orr r2, r4, r2 ands r2, r2, #1073741824 asrne r12, r1, #1 moveq r0, r5 mov r1, r12 pop {r4, r5, r7, lr} bx lr
arm	63	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return addu<63>(a, b); }	_f: adds r0, r2, r0 mov r12, #0 adcs r1, r3, r1 adc r2, r12, #0 orr r2, r2, r1, lsr #31 rsb r2, r2, #0 orr r1, r1, r2 orr r0, r0, r2 bic r1, r1, #-2147483648 bx lr
arm	64	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return adds<64>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 mvn lr, #0 mov r12, #0 adds lr, lr, r1, lsr #31 sbc r12, r12, #-2147483648 adds r0, r2, r0 adc r1, r3, r1 eor r4, r12, r3 eor r2, r1, r3 mvn r2, r2 orr r2, r4, r2 cmn r2, #1 movgt r0, lr movgt r1, r12 pop {r4, r7, lr} bx lr
arm	64	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return addu<64>(a, b); }	_f: adds r0, r0, r2 mov r12, #0 adcs r1, r1, r3 adcs r2, r12, #0 mvnne r0, #0 mvnne r1, #0 bx lr
arm	4	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return subs<4>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #3 tst r2, #8 addne r1, r0, #7 lsl r0, r1, #28 asr r0, r0, #28 bx lr
arm	4	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return subu<4>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 and r0, r0, #15 bx lr
arm	5	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return subs<5>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #4 tst r2, #16 addne r1, r0, #15 lsl r0, r1, #27 asr r0, r0, #27 bx lr
arm	5	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return subu<5>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 and r0, r0, #31 bx lr
arm	6	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return subs<6>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #5 tst r2, #32 addne r1, r0, #31 lsl r0, r1, #26 asr r0, r0, #26 bx lr
arm	6	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return subu<6>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 and r0, r0, #63 bx lr
arm	7	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return subs<7>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #6 tst r2, #64 addne r1, r0, #63 lsl r0, r1, #25 asr r0, r0, #25 bx lr
arm	7	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return subu<7>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 and r0, r0, #127 bx lr
arm	8	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return subs<8>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r0, r0, #255 and r2, r3, r2 mov r3, #127 lsl r2, r2, #24 asr r2, r2, #24 cmp r2, #0 addmi r1, r3, r0, lsr #7 lsl r0, r1, #24 asr r0, r0, #24 bx lr
arm	8	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return subu<8>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bx lr
arm	9	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return subs<9>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #8 tst r2, #256 addne r1, r0, #255 lsl r0, r1, #23 asr r0, r0, #23 bx lr
arm	9	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return subu<9>(a, b); }	_f: subs r0, r0, r1 mov r1, #255 movlo r0, #0 orr r1, r1, #256 and r0, r0, r1 bx lr
arm	10	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return subs<10>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #9 tst r2, #512 add r0, r0, #255 addne r1, r0, #256 lsl r0, r1, #22 asr r0, r0, #22 bx lr
arm	10	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return subu<10>(a, b); }	_f: subs r0, r0, r1 mov r1, #255 movlo r0, #0 orr r1, r1, #768 and r0, r0, r1 bx lr
arm	11	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return subs<11>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #10 tst r2, #1024 add r0, r0, #255 addne r1, r0, #768 lsl r0, r1, #21 asr r0, r0, #21 bx lr
arm	11	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return subu<11>(a, b); }	_f: subs r0, r0, r1 mov r1, #255 movlo r0, #0 orr r1, r1, #1792 and r0, r0, r1 bx lr
arm	12	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return subs<12>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #11 tst r2, #2048 add r0, r0, #255 addne r1, r0, #1792 lsl r0, r1, #20 asr r0, r0, #20 bx lr
arm	12	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return subu<12>(a, b); }	_f: subs r0, r0, r1 mov r1, #255 movlo r0, #0 orr r1, r1, #3840 and r0, r0, r1 bx lr
arm	13	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return subs<13>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #12 tst r2, #4096 add r0, r0, #255 addne r1, r0, #3840 lsl r0, r1, #19 asr r0, r0, #19 bx lr
arm	13	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return subu<13>(a, b); }	_f: subs r0, r0, r1 mov r1, #255 movlo r0, #0 orr r1, r1, #7936 and r0, r0, r1 bx lr
arm	14	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return subs<14>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #13 tst r2, #8192 add r0, r0, #255 addne r1, r0, #7936 lsl r0, r1, #18 asr r0, r0, #18 bx lr
arm	14	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return subu<14>(a, b); }	_f: subs r0, r0, r1 mov r1, #255 movlo r0, #0 orr r1, r1, #16128 and r0, r0, r1 bx lr
arm	15	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return subs<15>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #14 tst r2, #16384 add r0, r0, #255 addne r1, r0, #16128 lsl r0, r1, #17 asr r0, r0, #17 bx lr
arm	15	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return subu<15>(a, b); }	_f: subs r0, r0, r1 mov r1, #255 movlo r0, #0 orr r1, r1, #32512 and r0, r0, r1 bx lr
arm	16	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return subs<16>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r3, r2 mov r3, #255 lsl r2, r2, #16 orr r3, r3, #65280 asr r2, r2, #16 and r0, r0, r3 mov r3, #255 orr r3, r3, #32512 cmp r2, #0 addmi r1, r3, r0, lsr #15 lsl r0, r1, #16 asr r0, r0, #16 bx lr
arm	16	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return subu<16>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bx lr
arm	17	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return subs<17>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #32768 and r0, r3, r0, lsr #1 ldr r3, LCPI0_0 tst r2, #65536 add r0, r0, r3 lsleq r0, r1, #15 asr r0, r0, #15 bx lr LCPI0_0:
arm	17	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return subu<17>(a, b); }	_f: subs r0, r0, r1 ldr r1, LCPI0_0 movlo r0, #0 and r0, r0, r1 bx lr LCPI0_0:
arm	18	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return subs<18>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #16384 and r0, r3, r0, lsr #3 ldr r3, LCPI0_0 tst r2, #131072 add r0, r0, r3 lsleq r0, r1, #14 asr r0, r0, #14 bx lr LCPI0_0:
arm	18	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return subu<18>(a, b); }	_f: subs r0, r0, r1 ldr r1, LCPI0_0 movlo r0, #0 and r0, r0, r1 bx lr LCPI0_0:
arm	19	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return subs<19>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #8192 and r0, r3, r0, lsr #5 ldr r3, LCPI0_0 tst r2, #262144 add r0, r0, r3 lsleq r0, r1, #13 asr r0, r0, #13 bx lr LCPI0_0:
arm	19	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return subu<19>(a, b); }	_f: subs r0, r0, r1 ldr r1, LCPI0_0 movlo r0, #0 and r0, r0, r1 bx lr LCPI0_0:
arm	20	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return subs<20>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #4096 and r0, r3, r0, lsr #7 ldr r3, LCPI0_0 tst r2, #524288 add r0, r0, r3 lsleq r0, r1, #12 asr r0, r0, #12 bx lr LCPI0_0:
arm	20	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return subu<20>(a, b); }	_f: subs r0, r0, r1 ldr r1, LCPI0_0 movlo r0, #0 and r0, r0, r1 bx lr LCPI0_0:
arm	21	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return subs<21>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #2048 and r0, r3, r0, lsr #9 ldr r3, LCPI0_0 tst r2, #1048576 add r0, r0, r3 lsleq r0, r1, #11 asr r0, r0, #11 bx lr LCPI0_0:
arm	21	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return subu<21>(a, b); }	_f: subs r0, r0, r1 ldr r1, LCPI0_0 movlo r0, #0 and r0, r0, r1 bx lr LCPI0_0:
arm	22	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return subs<22>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1024 and r0, r3, r0, lsr #11 ldr r3, LCPI0_0 tst r2, #2097152 add r0, r0, r3 lsleq r0, r1, #10 asr r0, r0, #10 bx lr LCPI0_0:
arm	22	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return subu<22>(a, b); }	_f: subs r0, r0, r1 ldr r1, LCPI0_0 movlo r0, #0 and r0, r0, r1 bx lr LCPI0_0:
arm	23	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return subs<23>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #512 and r0, r3, r0, lsr #13 ldr r3, LCPI0_0 tst r2, #4194304 add r0, r0, r3 lsleq r0, r1, #9 asr r0, r0, #9 bx lr LCPI0_0:
arm	23	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return subu<23>(a, b); }	_f: subs r0, r0, r1 ldr r1, LCPI0_0 movlo r0, #0 and r0, r0, r1 bx lr LCPI0_0:
arm	24	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return subs<24>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #256 and r0, r3, r0, lsr #15 tst r2, #8388608 sub r0, r0, #256 sub r0, r0, #-2147483648 lsleq r0, r1, #8 asr r0, r0, #8 bx lr
arm	24	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return subu<24>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-16777216 bx lr
arm	25	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return subs<25>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #24 mvn r3, #-16777216 tst r2, #16777216 addne r1, r0, r3 lsl r0, r1, #7 asr r0, r0, #7 bx lr
arm	25	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return subu<25>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-33554432 bx lr
arm	26	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return subs<26>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #25 mvn r3, #-33554432 tst r2, #33554432 addne r1, r0, r3 lsl r0, r1, #6 asr r0, r0, #6 bx lr
arm	26	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return subu<26>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-67108864 bx lr
arm	27	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return subs<27>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #26 tst r2, #67108864 subne r1, r0, #-67108863 lsl r0, r1, #5 asr r0, r0, #5 bx lr
arm	27	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return subu<27>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-134217728 bx lr
arm	28	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return subs<28>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #27 tst r2, #134217728 subne r1, r0, #-134217727 lsl r0, r1, #4 asr r0, r0, #4 bx lr
arm	28	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return subu<28>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-268435456 bx lr
arm	29	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return subs<29>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #28 tst r2, #268435456 subne r1, r0, #-268435455 lsl r0, r1, #3 asr r0, r0, #3 bx lr
arm	29	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return subu<29>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-536870912 bx lr
arm	30	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return subs<30>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #29 tst r2, #536870912 subne r1, r0, #-536870911 lsl r0, r1, #2 asr r0, r0, #2 bx lr
arm	30	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return subu<30>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-1073741824 bx lr
arm	31	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return subs<31>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 and r2, r2, r3 mov r3, #1 and r0, r3, r0, lsr #30 tst r2, #1073741824 subne r1, r0, #-1073741823 lsl r0, r1, #1 asr r0, r0, #1 bx lr
arm	31	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return subu<31>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bic r0, r0, #-2147483648 bx lr
arm	32	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return subs<32>(a, b); }	_f: eor r2, r1, r0 sub r1, r0, r1 eor r3, r1, r0 ands r2, r3, r2 mvn r2, #-2147483648 addmi r1, r2, r0, lsr #31 mov r0, r1 bx lr
arm	32	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return subu<32>(a, b); }	_f: subs r0, r0, r1 movlo r0, #0 bx lr
arm	33	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return subs<33>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #1 and r0, r1, #1 mov r1, #0 subs r0, r0, #1 adc r1, r1, #0 cmp r2, #0 moveq r1, r3 moveq r0, lr and r1, r1, #1 rsb r1, r1, #0 pop {r7, lr} bx lr
arm	33	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return subu<33>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #1 bx lr
arm	34	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return subs<34>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #2 mov r0, #1 and r0, r0, r1, lsr #1 mov r1, #0 subs r0, r0, #1 adc r1, r1, #1 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #30 asr r1, r1, #30 pop {r7, lr} bx lr
arm	34	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return subu<34>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #3 bx lr
arm	35	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return subs<35>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #4 mov r0, #1 and r0, r0, r1, lsr #2 mov r1, #0 subs r0, r0, #1 adc r1, r1, #3 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #29 asr r1, r1, #29 pop {r7, lr} bx lr
arm	35	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return subu<35>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #7 bx lr
arm	36	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return subs<36>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #8 mov r0, #1 and r0, r0, r1, lsr #3 mov r1, #0 subs r0, r0, #1 adc r1, r1, #7 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #28 asr r1, r1, #28 pop {r7, lr} bx lr
arm	36	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return subu<36>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #15 bx lr
arm	37	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return subs<37>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #16 mov r0, #1 and r0, r0, r1, lsr #4 mov r1, #0 subs r0, r0, #1 adc r1, r1, #15 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #27 asr r1, r1, #27 pop {r7, lr} bx lr
arm	37	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return subu<37>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #31 bx lr
arm	38	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return subs<38>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #32 mov r0, #1 and r0, r0, r1, lsr #5 mov r1, #0 subs r0, r0, #1 adc r1, r1, #31 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #26 asr r1, r1, #26 pop {r7, lr} bx lr
arm	38	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return subu<38>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #63 bx lr
arm	39	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return subs<39>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #64 mov r0, #1 and r0, r0, r1, lsr #6 mov r1, #0 subs r0, r0, #1 adc r1, r1, #63 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #25 asr r1, r1, #25 pop {r7, lr} bx lr
arm	39	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return subu<39>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #127 bx lr
arm	40	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return subs<40>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r0, r12 mov r12, #0 lsl r0, r0, #24 asr r2, r0, #24 and r0, r1, #255 mvn r1, #0 adds r0, r1, r0, lsr #7 adc r1, r12, #127 cmp r2, #0 movpl r1, r3 movpl r0, lr lsl r1, r1, #24 asr r1, r1, #24 pop {r7, lr} bx lr
arm	40	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return subu<40>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 and r1, r1, #255 bx lr
arm	41	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return subs<41>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #256 mov r0, #1 and r0, r0, r1, lsr #8 mov r1, #0 subs r0, r0, #1 adc r1, r1, #255 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #23 asr r1, r1, #23 pop {r7, lr} bx lr
arm	41	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return subu<41>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #256 and r1, r1, r2 bx lr
arm	42	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return subs<42>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 mov r12, #255 and r2, r0, #512 mov r0, #1 orr r12, r12, #256 and r0, r0, r1, lsr #9 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #22 asr r1, r1, #22 pop {r7, lr} bx lr
arm	42	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return subu<42>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #768 and r1, r1, r2 bx lr
arm	43	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return subs<43>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 mov r12, #255 and r2, r0, #1024 mov r0, #1 orr r12, r12, #768 and r0, r0, r1, lsr #10 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #21 asr r1, r1, #21 pop {r7, lr} bx lr
arm	43	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return subu<43>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #1792 and r1, r1, r2 bx lr
arm	44	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return subs<44>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 mov r12, #255 and r2, r0, #2048 mov r0, #1 orr r12, r12, #1792 and r0, r0, r1, lsr #11 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #20 asr r1, r1, #20 pop {r7, lr} bx lr
arm	44	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return subu<44>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #3840 and r1, r1, r2 bx lr
arm	45	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return subs<45>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 mov r12, #255 and r2, r0, #4096 mov r0, #1 orr r12, r12, #3840 and r0, r0, r1, lsr #12 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #19 asr r1, r1, #19 pop {r7, lr} bx lr
arm	45	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return subu<45>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #7936 and r1, r1, r2 bx lr
arm	46	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return subs<46>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 mov r12, #255 and r2, r0, #8192 mov r0, #1 orr r12, r12, #7936 and r0, r0, r1, lsr #13 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #18 asr r1, r1, #18 pop {r7, lr} bx lr
arm	46	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return subu<46>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #16128 and r1, r1, r2 bx lr
arm	47	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return subs<47>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 mov r12, #255 and r2, r0, #16384 mov r0, #1 orr r12, r12, #16128 and r0, r0, r1, lsr #14 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #17 asr r1, r1, #17 pop {r7, lr} bx lr
arm	47	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return subu<47>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #32512 and r1, r1, r2 bx lr
arm	48	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return subs<48>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 subs lr, r0, r2 eor r12, r3, r1 mvn r4, #0 sbc r3, r1, r3 eor r0, r3, r1 and r0, r0, r12 mov r12, #255 lsl r0, r0, #16 orr r12, r12, #32512 asr r2, r0, #16 mov r0, #255 orr r0, r0, #65280 and r0, r1, r0 mov r1, #0 adds r0, r4, r0, lsr #15 adc r1, r1, r12 cmp r2, #0 movpl r1, r3 movpl r0, lr lsl r1, r1, #16 asr r1, r1, #16 pop {r4, r7, lr} bx lr
arm	48	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return subu<48>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 mov r2, #255 movne r1, #0 movne r0, #0 orr r2, r2, #65280 and r1, r1, r2 bx lr
arm	49	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return subs<49>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 mov r12, #255 and r2, r0, #65536 mov r0, #1 orr r12, r12, #65280 and r0, r0, r1, lsr #16 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #15 asr r1, r1, #15 pop {r7, lr} bx lr
arm	49	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return subu<49>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 ldr r2, LCPI0_0 movne r1, #0 movne r0, #0 and r1, r1, r2 bx lr LCPI0_0:
arm	50	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return subs<50>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 ldr r12, LCPI0_0 and r2, r0, #131072 mov r0, #1 and r0, r0, r1, lsr #17 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #14 asr r1, r1, #14 pop {r7, lr} bx lr LCPI0_0:
arm	50	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return subu<50>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 ldr r2, LCPI0_0 movne r1, #0 movne r0, #0 and r1, r1, r2 bx lr LCPI0_0:
arm	51	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return subs<51>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 ldr r12, LCPI0_0 and r2, r0, #262144 mov r0, #1 and r0, r0, r1, lsr #18 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #13 asr r1, r1, #13 pop {r7, lr} bx lr LCPI0_0:
arm	51	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return subu<51>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 ldr r2, LCPI0_0 movne r1, #0 movne r0, #0 and r1, r1, r2 bx lr LCPI0_0:
arm	52	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return subs<52>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 ldr r12, LCPI0_0 and r2, r0, #524288 mov r0, #1 and r0, r0, r1, lsr #19 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #12 asr r1, r1, #12 pop {r7, lr} bx lr LCPI0_0:
arm	52	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return subu<52>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 ldr r2, LCPI0_0 movne r1, #0 movne r0, #0 and r1, r1, r2 bx lr LCPI0_0:
arm	53	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return subs<53>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 ldr r12, LCPI0_0 and r2, r0, #1048576 mov r0, #1 and r0, r0, r1, lsr #20 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #11 asr r1, r1, #11 pop {r7, lr} bx lr LCPI0_0:
arm	53	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return subu<53>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 ldr r2, LCPI0_0 movne r1, #0 movne r0, #0 and r1, r1, r2 bx lr LCPI0_0:
arm	54	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return subs<54>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 ldr r12, LCPI0_0 and r2, r0, #2097152 mov r0, #1 and r0, r0, r1, lsr #21 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #10 asr r1, r1, #10 pop {r7, lr} bx lr LCPI0_0:
arm	54	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return subu<54>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 ldr r2, LCPI0_0 movne r1, #0 movne r0, #0 and r1, r1, r2 bx lr LCPI0_0:
arm	55	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return subs<55>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 ldr r12, LCPI0_0 and r2, r0, #4194304 mov r0, #1 and r0, r0, r1, lsr #22 mov r1, #0 subs r0, r0, #1 adc r1, r1, r12 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #9 asr r1, r1, #9 pop {r7, lr} bx lr LCPI0_0:
arm	55	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return subu<55>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 ldr r2, LCPI0_0 movne r1, #0 movne r0, #0 and r1, r1, r2 bx lr LCPI0_0:
arm	56	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return subs<56>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 subs lr, r0, r2 eor r12, r3, r1 mvn r4, #0 sbc r3, r1, r3 eor r0, r3, r1 and r0, r0, r12 ldr r12, LCPI0_0 lsl r0, r0, #8 asr r2, r0, #8 and r0, r1, #8388608 mov r1, #0 adds r0, r4, r0, lsr #23 adc r1, r1, r12 cmp r2, #0 movpl r1, r3 movpl r0, lr lsl r1, r1, #8 asr r1, r1, #8 pop {r4, r7, lr} bx lr LCPI0_0:
arm	56	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return subu<56>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-16777216 bx lr
arm	57	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return subs<57>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #16777216 mov r0, #1 and r0, r0, r1, lsr #24 mov r1, #0 subs r0, r0, #1 sbc r1, r1, #-16777216 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #7 asr r1, r1, #7 pop {r7, lr} bx lr
arm	57	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return subu<57>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-33554432 bx lr
arm	58	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return subs<58>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #33554432 mov r0, #1 and r0, r0, r1, lsr #25 mov r1, #0 subs r0, r0, #1 sbc r1, r1, #-33554432 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #6 asr r1, r1, #6 pop {r7, lr} bx lr
arm	58	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return subu<58>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-67108864 bx lr
arm	59	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return subs<59>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #67108864 mov r0, #1 and r0, r0, r1, lsr #26 mov r1, #0 subs r0, r0, #1 sbc r1, r1, #-67108864 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #5 asr r1, r1, #5 pop {r7, lr} bx lr
arm	59	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return subu<59>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-134217728 bx lr
arm	60	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return subs<60>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #134217728 mov r0, #1 and r0, r0, r1, lsr #27 mov r1, #0 subs r0, r0, #1 sbc r1, r1, #-134217728 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #4 asr r1, r1, #4 pop {r7, lr} bx lr
arm	60	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return subu<60>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-268435456 bx lr
arm	61	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return subs<61>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #268435456 mov r0, #1 and r0, r0, r1, lsr #28 mov r1, #0 subs r0, r0, #1 sbc r1, r1, #-268435456 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #3 asr r1, r1, #3 pop {r7, lr} bx lr
arm	61	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return subu<61>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-536870912 bx lr
arm	62	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return subs<62>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #536870912 mov r0, #1 and r0, r0, r1, lsr #29 mov r1, #0 subs r0, r0, #1 sbc r1, r1, #-536870912 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #2 asr r1, r1, #2 pop {r7, lr} bx lr
arm	62	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return subu<62>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-1073741824 bx lr
arm	63	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return subs<63>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r0, r12, r0 and r2, r0, #1073741824 mov r0, #1 and r0, r0, r1, lsr #30 mov r1, #0 subs r0, r0, #1 sbc r1, r1, #-1073741824 cmp r2, #0 moveq r1, r3 moveq r0, lr lsl r1, r1, #1 asr r1, r1, #1 pop {r7, lr} bx lr
arm	63	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return subu<63>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r1, #0 movne r0, #0 bic r1, r1, #-2147483648 bx lr
arm	64	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return subs<64>(a, b); }	_f: push {r7, lr} mov r7, sp subs lr, r0, r2 eor r12, r3, r1 sbc r3, r1, r3 eor r0, r3, r1 and r2, r0, r12 mvn r0, #0 mov r12, #0 adds r0, r0, r1, lsr #31 sbc r1, r12, #-2147483648 cmp r2, #0 movpl r0, lr movpl r1, r3 pop {r7, lr} bx lr
arm	64	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return subu<64>(a, b); }	_f: subs r0, r0, r2 mov r12, #0 sbcs r1, r1, r3 adc r2, r12, #0 rsbs r2, r2, #1 movne r0, #0 movne r1, #0 bx lr
arm	4	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return muls<4>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #16 mov r12, #255 lsl r3, r2, #24 and r0, r1, r0, lsl #1 and lr, r12, r2, lsr #4 asr r3, r3, #24 add r0, r0, #112 lsl r0, r0, #24 and r3, r12, r3, lsr #3 asr r0, r0, #24 cmp r3, lr lsrne r2, r0, #4 lsl r0, r2, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	4	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return mulu<4>(a, b); }	_f: mul r2, r1, r0 mov r0, #15 tst r2, #4080 andeq r0, r2, #15 bx lr
arm	5	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return muls<5>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #8 mov r12, #255 lsl r3, r2, #24 and r0, r1, r0, lsr #1 and lr, r12, r2, lsr #5 asr r3, r3, #24 add r0, r0, #120 lsl r0, r0, #24 and r3, r12, r3, lsr #4 asr r0, r0, #24 cmp r3, lr lsrne r2, r0, #3 lsl r0, r2, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	5	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return mulu<5>(a, b); }	_f: mul r2, r1, r0 mov r1, #4064 mov r0, #31 orr r1, r1, #4096 tst r2, r1 andeq r0, r2, #31 bx lr
arm	6	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return muls<6>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #4 mov r12, #255 lsl r3, r2, #24 and r0, r1, r0, lsr #3 and lr, r12, r2, lsr #6 asr r3, r3, #24 add r0, r0, #124 lsl r0, r0, #24 and r3, r12, r3, lsr #5 asr r0, r0, #24 cmp r3, lr lsrne r2, r0, #2 lsl r0, r2, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	6	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return mulu<6>(a, b); }	_f: mul r2, r1, r0 mov r0, #63 tst r2, #16320 andeq r0, r2, #63 bx lr
arm	7	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return muls<7>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #2 mov r12, #255 lsl r3, r2, #24 and r0, r1, r0, lsr #5 and lr, r12, r2, lsr #7 asr r3, r3, #24 add r0, r0, #126 lsl r0, r0, #24 and r3, r12, r3, lsr #6 asr r0, r0, #24 cmp r3, lr lsrne r2, r0, #1 lsl r0, r2, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	7	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return mulu<7>(a, b); }	_f: mul r2, r1, r0 mov r1, #16256 mov r0, #127 orr r1, r1, #16384 tst r2, r1 andeq r0, r2, #127 bx lr
arm	8	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return muls<8>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r12, #255 mov lr, #127 lsl r1, r2, #24 and r3, r12, r2, lsr #8 and r0, r0, #255 asr r1, r1, #24 and r1, r12, r1, lsr #7 cmp r1, r3 addne r2, lr, r0, lsr #7 lsl r0, r2, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	8	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return mulu<8>(a, b); }	_f: mul r2, r1, r0 mov r1, #0 and r0, r2, #255 cmp r1, r2, lsr #8 movne r0, #255 bx lr
arm	9	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return muls<9>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #128 mov r12, #255 and r0, r1, r0, lsr #1 lsl r3, r2, #16 orr r12, r12, #65280 add r0, r0, #16256 asr r3, r3, #16 and lr, r12, r2, lsr #9 add r0, r0, #16384 and r3, r12, r3, lsr #8 lsl r0, r0, #16 cmp r3, lr asr r0, r0, #16 lsrne r2, r0, #7 lsl r0, r2, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	9	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return mulu<9>(a, b); }	_f: mul r2, r1, r0 ldr r1, LCPI0_0 mov r0, #255 orr r0, r0, #256 tst r2, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	10	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return muls<10>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #64 mov r12, #255 and r0, r1, r0, lsr #3 lsl r3, r2, #16 orr r12, r12, #65280 add r0, r0, #16320 asr r3, r3, #16 and lr, r12, r2, lsr #10 add r0, r0, #16384 and r3, r12, r3, lsr #9 lsl r0, r0, #16 cmp r3, lr asr r0, r0, #16 lsrne r2, r0, #6 lsl r0, r2, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	10	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return mulu<10>(a, b); }	_f: mul r2, r1, r0 mov r1, #261120 mov r0, #255 orr r1, r1, #66846720 orr r0, r0, #768 tst r2, r1 andeq r0, r2, r0 bx lr
arm	11	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return muls<11>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #32 mov r12, #255 and r0, r1, r0, lsr #5 lsl r3, r2, #16 orr r12, r12, #65280 add r0, r0, #4064 asr r3, r3, #16 and lr, r12, r2, lsr #11 add r0, r0, #28672 and r3, r12, r3, lsr #10 lsl r0, r0, #16 cmp r3, lr asr r0, r0, #16 lsrne r2, r0, #5 lsl r0, r2, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	11	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return mulu<11>(a, b); }	_f: mul r2, r1, r0 ldr r1, LCPI0_0 mov r0, #255 orr r0, r0, #1792 tst r2, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	12	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return muls<12>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #16 mov r12, #255 and r0, r1, r0, lsr #7 lsl r3, r2, #16 orr r12, r12, #65280 add r0, r0, #4080 asr r3, r3, #16 and lr, r12, r2, lsr #12 add r0, r0, #28672 and r3, r12, r3, lsr #11 lsl r0, r0, #16 cmp r3, lr asr r0, r0, #16 lsrne r2, r0, #4 lsl r0, r2, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	12	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return mulu<12>(a, b); }	_f: mul r2, r1, r0 mov r1, #1044480 mov r0, #255 orr r1, r1, #267386880 orr r0, r0, #3840 tst r2, r1 andeq r0, r2, r0 bx lr
arm	13	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return muls<13>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #8 mov r12, #255 and r0, r1, r0, lsr #9 lsl r3, r2, #16 orr r12, r12, #65280 add r0, r0, #1016 asr r3, r3, #16 and lr, r12, r2, lsr #13 add r0, r0, #31744 and r3, r12, r3, lsr #12 lsl r0, r0, #16 cmp r3, lr asr r0, r0, #16 lsrne r2, r0, #3 lsl r0, r2, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	13	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return mulu<13>(a, b); }	_f: mul r2, r1, r0 ldr r1, LCPI0_0 mov r0, #255 orr r0, r0, #7936 tst r2, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	14	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return muls<14>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #4 mov r12, #255 and r0, r1, r0, lsr #11 lsl r3, r2, #16 orr r12, r12, #65280 add r0, r0, #1020 asr r3, r3, #16 and lr, r12, r2, lsr #14 add r0, r0, #31744 and r3, r12, r3, lsr #13 lsl r0, r0, #16 cmp r3, lr asr r0, r0, #16 lsrne r2, r0, #2 lsl r0, r2, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	14	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return mulu<14>(a, b); }	_f: mul r2, r1, r0 mov r1, #4177920 mov r0, #255 orr r1, r1, #1069547520 orr r0, r0, #16128 tst r2, r1 andeq r0, r2, r0 bx lr
arm	15	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return muls<15>(a, b); }	_f: push {r7, lr} mov r7, sp mul r2, r1, r0 eor r0, r1, r0 mov r1, #2 mov r12, #255 and r0, r1, r0, lsr #13 lsl r3, r2, #16 orr r12, r12, #65280 add r0, r0, #254 asr r3, r3, #16 and lr, r12, r2, lsr #15 add r0, r0, #32512 and r3, r12, r3, lsr #14 lsl r0, r0, #16 cmp r3, lr asr r0, r0, #16 lsrne r2, r0, #1 lsl r0, r2, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	15	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return mulu<15>(a, b); }	_f: mul r2, r1, r0 ldr r1, LCPI0_0 mov r0, #255 orr r0, r0, #32512 tst r2, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	16	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return muls<16>(a, b); }	_f: push {r7, lr} mov r7, sp mul r3, r1, r0 mov lr, #255 eor r2, r1, r0 mov r12, #255 lsl r0, r3, #16 orr lr, lr, #65280 orr r12, r12, #32512 asr r0, r0, #16 and r2, r2, lr and r0, lr, r0, lsr #15 cmp r0, r3, lsr #16 addne r3, r12, r2, lsr #15 lsl r0, r3, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	16	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return mulu<16>(a, b); }	_f: mul r2, r1, r0 mov r0, #255 mov r1, #0 orr r0, r0, #65280 cmp r1, r2, lsr #16 andeq r0, r2, r0 bx lr
arm	17	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return muls<17>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #32768 and r0, r1, r0, lsr #1 ldr r1, LCPI0_0 lsr r3, r2, #17 orr r3, r3, r12, lsl #15 cmp r3, r2, asr #16 add r0, r0, r1 asrne r2, r0, #15 mov r0, r2 bx lr LCPI0_0:
arm	17	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return mulu<17>(a, b); }	_f: umull r2, r3, r1, r0 ldr r0, LCPI0_0 and r1, r3, r0 mov r3, #16646144 orr r3, r3, #-16777216 and r3, r2, r3 orrs r1, r3, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	18	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return muls<18>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #16384 and r0, r1, r0, lsr #3 ldr r1, LCPI0_0 lsr r3, r2, #18 orr r3, r3, r12, lsl #14 cmp r3, r2, asr #17 add r0, r0, r1 asrne r2, r0, #14 mov r0, r2 bx lr LCPI0_0:
arm	18	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return mulu<18>(a, b); }	_f: umull r2, r3, r1, r0 ldr r0, LCPI0_0 and r1, r3, r0 mov r3, #66846720 orr r3, r3, #-67108864 and r3, r2, r3 orrs r1, r3, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	19	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return muls<19>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #8192 and r0, r1, r0, lsr #5 ldr r1, LCPI0_0 lsr r3, r2, #19 orr r3, r3, r12, lsl #13 cmp r3, r2, asr #18 add r0, r0, r1 asrne r2, r0, #13 mov r0, r2 bx lr LCPI0_0:
arm	19	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return mulu<19>(a, b); }	_f: umull r2, r3, r1, r0 ldr r0, LCPI0_0 and r1, r3, r0 mov r3, #66584576 orr r3, r3, #-67108864 and r3, r2, r3 orrs r1, r3, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	20	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return muls<20>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #4096 and r0, r1, r0, lsr #7 ldr r1, LCPI0_0 lsr r3, r2, #20 orr r3, r3, r12, lsl #12 cmp r3, r2, asr #19 add r0, r0, r1 asrne r2, r0, #12 mov r0, r2 bx lr LCPI0_0:
arm	20	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return mulu<20>(a, b); }	_f: umull r2, r3, r1, r0 ldr r0, LCPI0_0 and r1, r3, r0 mov r3, #267386880 orr r3, r3, #-268435456 and r3, r2, r3 orrs r1, r3, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	21	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return muls<21>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #2048 and r0, r1, r0, lsr #9 ldr r1, LCPI0_0 lsr r3, r2, #21 orr r3, r3, r12, lsl #11 cmp r3, r2, asr #20 add r0, r0, r1 asrne r2, r0, #11 mov r0, r2 bx lr LCPI0_0:
arm	21	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return mulu<21>(a, b); }	_f: umull r2, r3, r1, r0 ldr r0, LCPI0_0 and r1, r3, r0 mov r3, #266338304 orr r3, r3, #-268435456 and r3, r2, r3 orrs r1, r3, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	22	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return muls<22>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #1024 and r0, r1, r0, lsr #11 ldr r1, LCPI0_0 lsr r3, r2, #22 orr r3, r3, r12, lsl #10 cmp r3, r2, asr #21 add r0, r0, r1 asrne r2, r0, #10 mov r0, r2 bx lr LCPI0_0:
arm	22	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return mulu<22>(a, b); }	_f: umull r2, r3, r1, r0 ldr r0, LCPI0_0 and r1, r3, r0 mov r3, #1069547520 orr r3, r3, #-1073741824 and r3, r2, r3 orrs r1, r3, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	23	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return muls<23>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #512 and r0, r1, r0, lsr #13 ldr r1, LCPI0_0 lsr r3, r2, #23 orr r3, r3, r12, lsl #9 cmp r3, r2, asr #22 add r0, r0, r1 asrne r2, r0, #9 mov r0, r2 bx lr LCPI0_0:
arm	23	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return mulu<23>(a, b); }	_f: umull r2, r3, r1, r0 ldr r0, LCPI0_0 and r1, r3, r0 mov r3, #1065353216 orr r3, r3, #-1073741824 and r3, r2, r3 orrs r1, r3, r1 andeq r0, r2, r0 bx lr LCPI0_0:
arm	24	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return muls<24>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #256 lsr r3, r2, #24 and r0, r1, r0, lsr #15 sub r0, r0, #256 orr r3, r3, r12, lsl #8 sub r0, r0, #-2147483648 cmp r3, r2, asr #23 asrne r2, r0, #8 mov r0, r2 bx lr
arm	24	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return mulu<24>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-16777216 and r1, r2, #-16777216 orrs r0, r1, r0 mvn r0, #-16777216 biceq r0, r2, #-16777216 bx lr
arm	25	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return muls<25>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #128 lsr r3, r2, #25 and r0, r1, r0, lsr #17 sub r0, r0, #128 orr r3, r3, r12, lsl #7 sub r0, r0, #-2147483648 cmp r3, r2, asr #24 asrne r2, r0, #7 mov r0, r2 bx lr
arm	25	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return mulu<25>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-33554432 and r1, r2, #-33554432 orrs r0, r1, r0 mvn r0, #-33554432 biceq r0, r2, #-33554432 bx lr
arm	26	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return muls<26>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #64 lsr r3, r2, #26 and r0, r1, r0, lsr #19 mvn r1, #-2147483585 orr r3, r3, r12, lsl #6 add r0, r0, r1 cmp r3, r2, asr #25 asrne r2, r0, #6 mov r0, r2 bx lr
arm	26	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return mulu<26>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-67108864 and r1, r2, #-67108864 orrs r0, r1, r0 mvn r0, #-67108864 biceq r0, r2, #-67108864 bx lr
arm	27	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return muls<27>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #32 lsr r3, r2, #27 and r0, r1, r0, lsr #21 orr r3, r3, r12, lsl #5 sub r0, r0, #-2147483616 cmp r3, r2, asr #26 asrne r2, r0, #5 mov r0, r2 bx lr
arm	27	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return mulu<27>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-134217728 and r1, r2, #-134217728 orrs r0, r1, r0 mvn r0, #-134217728 biceq r0, r2, #-134217728 bx lr
arm	28	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return muls<28>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #16 lsr r3, r2, #28 and r0, r1, r0, lsr #23 orr r3, r3, r12, lsl #4 sub r0, r0, #-2147483632 cmp r3, r2, asr #27 asrne r2, r0, #4 mov r0, r2 bx lr
arm	28	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return mulu<28>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-268435456 and r1, r2, #-268435456 orrs r0, r1, r0 mvn r0, #-268435456 biceq r0, r2, #-268435456 bx lr
arm	29	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return muls<29>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #8 lsr r3, r2, #29 and r0, r1, r0, lsr #25 orr r3, r3, r12, lsl #3 sub r0, r0, #-2147483640 cmp r3, r2, asr #28 asrne r2, r0, #3 mov r0, r2 bx lr
arm	29	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return mulu<29>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-536870912 and r1, r2, #-536870912 orrs r0, r1, r0 mvn r0, #-536870912 biceq r0, r2, #-536870912 bx lr
arm	30	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return muls<30>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #4 lsr r3, r2, #30 and r0, r1, r0, lsr #27 orr r3, r3, r12, lsl #2 sub r0, r0, #-2147483644 cmp r3, r2, asr #29 asrne r2, r0, #2 mov r0, r2 bx lr
arm	30	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return mulu<30>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-1073741824 and r1, r2, #-1073741824 orrs r0, r1, r0 mvn r0, #-1073741824 biceq r0, r2, #-1073741824 bx lr
arm	31	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return muls<31>(a, b); }	_f: smull r2, r12, r1, r0 eor r0, r1, r0 mov r1, #2 lsr r3, r2, #31 and r0, r1, r0, lsr #29 orr r3, r3, r12, lsl #1 sub r0, r0, #-2147483646 cmp r3, r2, asr #30 asrne r2, r0, #1 mov r0, r2 bx lr
arm	31	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return mulu<31>(a, b); }	_f: umull r2, r3, r1, r0 bic r0, r3, #-2147483648 and r1, r2, #-2147483648 orrs r0, r1, r0 mvn r0, #-2147483648 biceq r0, r2, #-2147483648 bx lr
arm	32	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return muls<32>(a, b); }	_f: smull r2, r3, r1, r0 eor r0, r1, r0 mvn r1, #-2147483648 cmp r3, r2, asr #31 addne r2, r1, r0, lsr #31 mov r0, r2 bx lr
arm	32	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return mulu<32>(a, b); }	_f: umull r2, r3, r1, r0 cmp r3, #0 movne r3, #1 cmp r3, #0 mvnne r2, #0 mov r0, r2 bx lr
arm	33	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return muls<33>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #31 orr r6, r2, r5, lsr #1 and r2, lr, #1 lsl r5, r5, #31 rsb r2, r2, #0 orr r5, r5, lr, lsr #1 eor r6, r6, r2 eor r5, r5, r2 orrs r6, r5, r6 beq LBB0_2 eor r0, r3, r1 mov r1, #255 and r0, r1, r0, lsl #7 mov r1, #0 subs r0, r0, #128 adc r1, r1, #127 lsr r0, r0, #7 lsl r1, r1, #24 asr r2, r1, #24 orr r0, r0, r2, lsl #25 asr r2, r1, #31 LBB0_2: mov r1, r2 pop {r4, r5, r6, r7, lr} bx lr
arm	33	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return mulu<33>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #31 orr lr, r4, r6, lsr #1 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #1 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #31 orr r0, r0, r2, lsr #1 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	34	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return muls<34>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #30 orr r6, r2, r5, lsr #2 lsl r5, r5, #30 lsl r2, lr, #30 orr r5, r5, lr, lsr #2 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #30 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #64 and r0, r1, r0, lsl #5 mov r1, #0 subs r0, r0, #64 adc r1, r1, #127 lsr r0, r0, #6 lsl r1, r1, #24 asr r2, r1, #24 asr r1, r1, #30 orr r0, r0, r2, lsl #26 pop {r4, r5, r6, r7, lr} bx lr
arm	34	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return mulu<34>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #30 orr lr, r4, r6, lsr #2 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #3 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #30 orr r0, r0, r2, lsr #2 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #3 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	35	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return muls<35>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #29 orr r6, r2, r5, lsr #3 lsl r5, r5, #29 lsl r2, lr, #29 orr r5, r5, lr, lsr #3 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #29 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #32 and r0, r1, r0, lsl #3 mov r1, #0 subs r0, r0, #32 adc r1, r1, #127 lsr r0, r0, #5 lsl r1, r1, #24 asr r2, r1, #24 asr r1, r1, #29 orr r0, r0, r2, lsl #27 pop {r4, r5, r6, r7, lr} bx lr
arm	35	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return mulu<35>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #29 orr lr, r4, r6, lsr #3 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #7 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #29 orr r0, r0, r2, lsr #3 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #7 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	36	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return muls<36>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #28 orr r6, r2, r5, lsr #4 lsl r5, r5, #28 lsl r2, lr, #28 orr r5, r5, lr, lsr #4 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #28 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #16 and r0, r1, r0, lsl #1 mov r1, #0 subs r0, r0, #16 adc r1, r1, #127 lsr r0, r0, #4 lsl r1, r1, #24 asr r2, r1, #24 asr r1, r1, #28 orr r0, r0, r2, lsl #28 pop {r4, r5, r6, r7, lr} bx lr
arm	36	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return mulu<36>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #28 orr lr, r4, r6, lsr #4 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #15 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #28 orr r0, r0, r2, lsr #4 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #15 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	37	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return muls<37>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #27 orr r6, r2, r5, lsr #5 lsl r5, r5, #27 lsl r2, lr, #27 orr r5, r5, lr, lsr #5 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #27 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #8 and r0, r1, r0, lsr #1 mov r1, #0 subs r0, r0, #8 adc r1, r1, #127 lsr r0, r0, #3 lsl r1, r1, #24 asr r2, r1, #24 asr r1, r1, #27 orr r0, r0, r2, lsl #29 pop {r4, r5, r6, r7, lr} bx lr
arm	37	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return mulu<37>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #27 orr lr, r4, r6, lsr #5 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #31 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #27 orr r0, r0, r2, lsr #5 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #31 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	38	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return muls<38>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #26 orr r6, r2, r5, lsr #6 lsl r5, r5, #26 lsl r2, lr, #26 orr r5, r5, lr, lsr #6 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #26 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #4 and r0, r1, r0, lsr #3 mov r1, #0 subs r0, r0, #4 adc r1, r1, #127 lsr r0, r0, #2 lsl r1, r1, #24 asr r2, r1, #24 asr r1, r1, #26 orr r0, r0, r2, lsl #30 pop {r4, r5, r6, r7, lr} bx lr
arm	38	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return mulu<38>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #26 orr lr, r4, r6, lsr #6 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #63 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #26 orr r0, r0, r2, lsr #6 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #63 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	39	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return muls<39>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #25 orr r6, r2, r5, lsr #7 lsl r5, r5, #25 lsl r2, lr, #25 orr r5, r5, lr, lsr #7 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #25 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #2 and r0, r1, r0, lsr #5 mov r1, #0 subs r0, r0, #2 adc r1, r1, #127 lsl r1, r1, #24 asr r1, r1, #24 asrs r1, r1, #1 rrx r0, r0 lsl r1, r1, #24 asr r1, r1, #24 pop {r4, r5, r6, r7, lr} bx lr
arm	39	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return mulu<39>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #25 orr lr, r4, r6, lsr #7 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #127 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #25 orr r0, r0, r2, lsr #7 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #127 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	40	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return muls<40>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #24 orr r6, r2, r5, lsr #8 lsl r5, r5, #24 lsl r2, lr, #24 orr r5, r5, lr, lsr #8 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #24 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mvn r2, #0 mov r1, #0 and r0, r0, #255 adds r0, r2, r0, lsr #7 adc r1, r1, #127 lsl r1, r1, #24 asr r1, r1, #24 pop {r4, r5, r6, r7, lr} bx lr
arm	40	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return mulu<40>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #24 orr lr, r4, r6, lsr #8 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #24 orr r0, r0, r2, lsr #8 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, #255 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	41	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return muls<41>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #23 orr r6, r2, r5, lsr #9 lsl r5, r5, #23 lsl r2, lr, #23 orr r5, r5, lr, lsr #9 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #23 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #128 mov r2, #0 and r0, r1, r0, lsr #1 mov r1, #255 subs r0, r0, #128 orr r1, r1, #32512 adc r1, r2, r1 lsr r0, r0, #7 lsl r1, r1, #16 asr r2, r1, #16 asr r1, r1, #23 orr r0, r0, r2, lsl #25 pop {r4, r5, r6, r7, lr} bx lr
arm	41	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return mulu<41>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #23 orr lr, r4, r6, lsr #9 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #256 adc r0, r8, #0 lsl r0, r0, #23 orr r0, r0, r2, lsr #9 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	42	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return muls<42>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #22 orr r6, r2, r5, lsr #10 lsl r5, r5, #22 lsl r2, lr, #22 orr r5, r5, lr, lsr #10 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #22 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #64 mov r2, #0 and r0, r1, r0, lsr #3 mov r1, #255 subs r0, r0, #64 orr r1, r1, #32512 adc r1, r2, r1 lsr r0, r0, #6 lsl r1, r1, #16 asr r2, r1, #16 asr r1, r1, #22 orr r0, r0, r2, lsl #26 pop {r4, r5, r6, r7, lr} bx lr
arm	42	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return mulu<42>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #22 orr lr, r4, r6, lsr #10 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #768 adc r0, r8, #0 lsl r0, r0, #22 orr r0, r0, r2, lsr #10 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	43	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return muls<43>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #21 orr r6, r2, r5, lsr #11 lsl r5, r5, #21 lsl r2, lr, #21 orr r5, r5, lr, lsr #11 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #21 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #32 mov r2, #0 and r0, r1, r0, lsr #5 mov r1, #255 subs r0, r0, #32 orr r1, r1, #32512 adc r1, r2, r1 lsr r0, r0, #5 lsl r1, r1, #16 asr r2, r1, #16 asr r1, r1, #21 orr r0, r0, r2, lsl #27 pop {r4, r5, r6, r7, lr} bx lr
arm	43	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return mulu<43>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #21 orr lr, r4, r6, lsr #11 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #1792 adc r0, r8, #0 lsl r0, r0, #21 orr r0, r0, r2, lsr #11 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	44	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return muls<44>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #20 orr r6, r2, r5, lsr #12 lsl r5, r5, #20 lsl r2, lr, #20 orr r5, r5, lr, lsr #12 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #20 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #16 mov r2, #0 and r0, r1, r0, lsr #7 mov r1, #255 subs r0, r0, #16 orr r1, r1, #32512 adc r1, r2, r1 lsr r0, r0, #4 lsl r1, r1, #16 asr r2, r1, #16 asr r1, r1, #20 orr r0, r0, r2, lsl #28 pop {r4, r5, r6, r7, lr} bx lr
arm	44	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return mulu<44>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #20 orr lr, r4, r6, lsr #12 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #3840 adc r0, r8, #0 lsl r0, r0, #20 orr r0, r0, r2, lsr #12 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	45	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return muls<45>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #19 orr r6, r2, r5, lsr #13 lsl r5, r5, #19 lsl r2, lr, #19 orr r5, r5, lr, lsr #13 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #19 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #8 mov r2, #0 and r0, r1, r0, lsr #9 mov r1, #255 subs r0, r0, #8 orr r1, r1, #32512 adc r1, r2, r1 lsr r0, r0, #3 lsl r1, r1, #16 asr r2, r1, #16 asr r1, r1, #19 orr r0, r0, r2, lsl #29 pop {r4, r5, r6, r7, lr} bx lr
arm	45	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return mulu<45>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #19 orr lr, r4, r6, lsr #13 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #7936 adc r0, r8, #0 lsl r0, r0, #19 orr r0, r0, r2, lsr #13 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	46	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return muls<46>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #18 orr r6, r2, r5, lsr #14 lsl r5, r5, #18 lsl r2, lr, #18 orr r5, r5, lr, lsr #14 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #18 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #4 mov r2, #0 and r0, r1, r0, lsr #11 mov r1, #255 subs r0, r0, #4 orr r1, r1, #32512 adc r1, r2, r1 lsr r0, r0, #2 lsl r1, r1, #16 asr r2, r1, #16 asr r1, r1, #18 orr r0, r0, r2, lsl #30 pop {r4, r5, r6, r7, lr} bx lr
arm	46	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return mulu<46>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #18 orr lr, r4, r6, lsr #14 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #16128 adc r0, r8, #0 lsl r0, r0, #18 orr r0, r0, r2, lsr #14 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	47	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return muls<47>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #17 orr r6, r2, r5, lsr #15 lsl r5, r5, #17 lsl r2, lr, #17 orr r5, r5, lr, lsr #15 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #17 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #2 mov r2, #0 and r0, r1, r0, lsr #13 mov r1, #255 orr r1, r1, #32512 subs r0, r0, #2 adc r1, r2, r1 lsl r1, r1, #16 asr r1, r1, #16 asrs r1, r1, #1 rrx r0, r0 lsl r1, r1, #16 asr r1, r1, #16 pop {r4, r5, r6, r7, lr} bx lr
arm	47	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return mulu<47>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #17 orr lr, r4, r6, lsr #15 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #32512 adc r0, r8, #0 lsl r0, r0, #17 orr r0, r0, r2, lsr #15 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	48	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return muls<48>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #16 orr r6, r2, r5, lsr #16 lsl r5, r5, #16 lsl r2, lr, #16 orr r5, r5, lr, lsr #16 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #16 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #255 mvn r3, #0 mov r2, #0 orr r1, r1, #65280 and r0, r0, r1 mov r1, #255 orr r1, r1, #32512 adds r0, r3, r0, lsr #15 adc r1, r2, r1 lsl r1, r1, #16 asr r1, r1, #16 pop {r4, r5, r6, r7, lr} bx lr
arm	48	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return mulu<48>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #16 orr lr, r4, r6, lsr #16 umull r4, r10, r3, r0 adds r0, r1, r4 mov r1, #255 adcs r0, r5, r10 orr r1, r1, #65280 adc r0, r8, #0 lsl r0, r0, #16 orr r0, r0, r2, lsr #16 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	49	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return muls<49>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #15 orr r6, r2, r5, lsr #17 lsl r5, r5, #15 lsl r2, lr, #15 orr r5, r5, lr, lsr #17 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #15 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #128 mov r2, #0 and r0, r1, r0, lsr #9 ldr r1, LCPI0_0 subs r0, r0, #128 lsr r0, r0, #7 adc r1, r2, r1 lsl r1, r1, #8 asr r2, r1, #8 asr r1, r1, #15 orr r0, r0, r2, lsl #25 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	49	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return mulu<49>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #15 orr lr, r4, r6, lsr #17 umull r4, r10, r3, r0 adds r0, r1, r4 ldr r1, LCPI0_0 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #15 orr r0, r0, r2, lsr #17 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	50	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return muls<50>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #14 orr r6, r2, r5, lsr #18 lsl r5, r5, #14 lsl r2, lr, #14 orr r5, r5, lr, lsr #18 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #14 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #64 mov r2, #0 and r0, r1, r0, lsr #11 ldr r1, LCPI0_0 subs r0, r0, #64 lsr r0, r0, #6 adc r1, r2, r1 lsl r1, r1, #8 asr r2, r1, #8 asr r1, r1, #14 orr r0, r0, r2, lsl #26 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	50	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return mulu<50>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #14 orr lr, r4, r6, lsr #18 umull r4, r10, r3, r0 adds r0, r1, r4 ldr r1, LCPI0_0 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #14 orr r0, r0, r2, lsr #18 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	51	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return muls<51>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #13 orr r6, r2, r5, lsr #19 lsl r5, r5, #13 lsl r2, lr, #13 orr r5, r5, lr, lsr #19 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #13 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #32 mov r2, #0 and r0, r1, r0, lsr #13 ldr r1, LCPI0_0 subs r0, r0, #32 lsr r0, r0, #5 adc r1, r2, r1 lsl r1, r1, #8 asr r2, r1, #8 asr r1, r1, #13 orr r0, r0, r2, lsl #27 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	51	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return mulu<51>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #13 orr lr, r4, r6, lsr #19 umull r4, r10, r3, r0 adds r0, r1, r4 ldr r1, LCPI0_0 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #13 orr r0, r0, r2, lsr #19 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	52	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return muls<52>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #12 orr r6, r2, r5, lsr #20 lsl r5, r5, #12 lsl r2, lr, #12 orr r5, r5, lr, lsr #20 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #12 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #16 mov r2, #0 and r0, r1, r0, lsr #15 ldr r1, LCPI0_0 subs r0, r0, #16 lsr r0, r0, #4 adc r1, r2, r1 lsl r1, r1, #8 asr r2, r1, #8 asr r1, r1, #12 orr r0, r0, r2, lsl #28 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	52	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return mulu<52>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #12 orr lr, r4, r6, lsr #20 umull r4, r10, r3, r0 adds r0, r1, r4 ldr r1, LCPI0_0 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #12 orr r0, r0, r2, lsr #20 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	53	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return muls<53>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #11 orr r6, r2, r5, lsr #21 lsl r5, r5, #11 lsl r2, lr, #11 orr r5, r5, lr, lsr #21 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #11 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #8 mov r2, #0 and r0, r1, r0, lsr #17 ldr r1, LCPI0_0 subs r0, r0, #8 lsr r0, r0, #3 adc r1, r2, r1 lsl r1, r1, #8 asr r2, r1, #8 asr r1, r1, #11 orr r0, r0, r2, lsl #29 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	53	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return mulu<53>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #11 orr lr, r4, r6, lsr #21 umull r4, r10, r3, r0 adds r0, r1, r4 ldr r1, LCPI0_0 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #11 orr r0, r0, r2, lsr #21 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	54	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return muls<54>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #10 orr r6, r2, r5, lsr #22 lsl r5, r5, #10 lsl r2, lr, #10 orr r5, r5, lr, lsr #22 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #10 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #4 mov r2, #0 and r0, r1, r0, lsr #19 ldr r1, LCPI0_0 subs r0, r0, #4 lsr r0, r0, #2 adc r1, r2, r1 lsl r1, r1, #8 asr r2, r1, #8 asr r1, r1, #10 orr r0, r0, r2, lsl #30 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	54	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return mulu<54>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #10 orr lr, r4, r6, lsr #22 umull r4, r10, r3, r0 adds r0, r1, r4 ldr r1, LCPI0_0 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #10 orr r0, r0, r2, lsr #22 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	55	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return muls<55>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #9 orr r6, r2, r5, lsr #23 lsl r5, r5, #9 lsl r2, lr, #9 orr r5, r5, lr, lsr #23 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #9 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 mov r1, #2 mov r2, #0 and r0, r1, r0, lsr #21 ldr r1, LCPI0_0 subs r0, r0, #2 adc r1, r2, r1 lsl r1, r1, #8 asr r1, r1, #8 asrs r1, r1, #1 rrx r0, r0 lsl r1, r1, #8 asr r1, r1, #8 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	55	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return mulu<55>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #9 orr lr, r4, r6, lsr #23 umull r4, r10, r3, r0 adds r0, r1, r4 ldr r1, LCPI0_0 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #9 orr r0, r0, r2, lsr #23 orrs r0, lr, r0 mvnne r12, #0 andeq r1, r6, r1 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	56	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return muls<56>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 mov r12, r0 asr r4, r1, #31 mul r5, r2, r4 umull r0, lr, r2, r12 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r12 asr r2, r5, #31 umlal lr, r6, r3, r12 smlal r5, r2, r3, r1 adds r5, r5, r6 adc r2, r2, r6, asr #31 lsl r2, r2, #8 orr r6, r2, r5, lsr #24 lsl r5, r5, #8 lsl r2, lr, #8 orr r5, r5, lr, lsr #24 eor r6, r6, r2, asr #31 eor r5, r5, r2, asr #31 orrs r6, r5, r6 asreq r1, r2, #8 popeq {r4, r5, r6, r7, lr} bxeq lr LBB0_1: eor r0, r3, r1 ldr r1, LCPI0_0 mvn r3, #0 mov r2, #0 and r0, r0, #8388608 adds r0, r3, r0, lsr #23 adc r1, r2, r1 lsl r1, r1, #8 asr r1, r1, #8 pop {r4, r5, r6, r7, lr} bx lr LCPI0_0:
arm	56	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return mulu<56>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #8 orr lr, r4, r6, lsr #24 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-16777216 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #8 orr r0, r0, r2, lsr #24 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-16777216 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	57	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return muls<57>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull r12, lr, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal lr, r6, r3, r0 smlal r5, r2, r3, r1 adds r4, r5, r6 adc r0, r2, r6, asr #31 lsl r0, r0, #7 orr r2, r0, r4, lsr #25 lsl r4, r4, #7 lsl r0, lr, #7 orr r6, r4, lr, lsr #25 eor r2, r2, r0, asr #31 eor r6, r6, r0, asr #31 orrs r2, r6, r2 bne LBB0_2 orr r1, r0, r12, lsr #25 lsl r0, r12, #7 b LBB0_3 LBB0_2: eor r0, r3, r1 mov r1, #128 and r0, r1, r0, lsr #17 mov r1, #0 subs r0, r0, #128 sbc r1, r1, #-2147483648 LBB0_3: lsr r0, r0, #7 orr r0, r0, r1, lsl #25 asr r1, r1, #7 pop {r4, r5, r6, r7, lr} bx lr
arm	57	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return mulu<57>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #7 orr lr, r4, r6, lsr #25 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-33554432 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #7 orr r0, r0, r2, lsr #25 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-33554432 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	58	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return muls<58>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull r12, lr, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal lr, r6, r3, r0 smlal r5, r2, r3, r1 adds r4, r5, r6 adc r0, r2, r6, asr #31 lsl r0, r0, #6 orr r2, r0, r4, lsr #26 lsl r4, r4, #6 lsl r0, lr, #6 orr r6, r4, lr, lsr #26 eor r2, r2, r0, asr #31 eor r6, r6, r0, asr #31 orrs r2, r6, r2 bne LBB0_2 orr r1, r0, r12, lsr #26 lsl r0, r12, #6 b LBB0_3 LBB0_2: eor r0, r3, r1 mov r1, #64 and r0, r1, r0, lsr #19 mov r1, #0 subs r0, r0, #64 sbc r1, r1, #-2147483648 LBB0_3: lsr r0, r0, #6 orr r0, r0, r1, lsl #26 asr r1, r1, #6 pop {r4, r5, r6, r7, lr} bx lr
arm	58	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return mulu<58>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #6 orr lr, r4, r6, lsr #26 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-67108864 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #6 orr r0, r0, r2, lsr #26 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-67108864 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	59	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return muls<59>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull r12, lr, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal lr, r6, r3, r0 smlal r5, r2, r3, r1 adds r4, r5, r6 adc r0, r2, r6, asr #31 lsl r0, r0, #5 orr r2, r0, r4, lsr #27 lsl r4, r4, #5 lsl r0, lr, #5 orr r6, r4, lr, lsr #27 eor r2, r2, r0, asr #31 eor r6, r6, r0, asr #31 orrs r2, r6, r2 bne LBB0_2 orr r1, r0, r12, lsr #27 lsl r0, r12, #5 b LBB0_3 LBB0_2: eor r0, r3, r1 mov r1, #32 and r0, r1, r0, lsr #21 mov r1, #0 subs r0, r0, #32 sbc r1, r1, #-2147483648 LBB0_3: lsr r0, r0, #5 orr r0, r0, r1, lsl #27 asr r1, r1, #5 pop {r4, r5, r6, r7, lr} bx lr
arm	59	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return mulu<59>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #5 orr lr, r4, r6, lsr #27 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-134217728 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #5 orr r0, r0, r2, lsr #27 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-134217728 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	60	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return muls<60>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull r12, lr, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal lr, r6, r3, r0 smlal r5, r2, r3, r1 adds r4, r5, r6 adc r0, r2, r6, asr #31 lsl r0, r0, #4 orr r2, r0, r4, lsr #28 lsl r4, r4, #4 lsl r0, lr, #4 orr r6, r4, lr, lsr #28 eor r2, r2, r0, asr #31 eor r6, r6, r0, asr #31 orrs r2, r6, r2 bne LBB0_2 orr r1, r0, r12, lsr #28 lsl r0, r12, #4 b LBB0_3 LBB0_2: eor r0, r3, r1 mov r1, #16 and r0, r1, r0, lsr #23 mov r1, #0 subs r0, r0, #16 sbc r1, r1, #-2147483648 LBB0_3: lsr r0, r0, #4 orr r0, r0, r1, lsl #28 asr r1, r1, #4 pop {r4, r5, r6, r7, lr} bx lr
arm	60	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return mulu<60>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #4 orr lr, r4, r6, lsr #28 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-268435456 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #4 orr r0, r0, r2, lsr #28 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-268435456 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	61	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return muls<61>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull r12, lr, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal lr, r6, r3, r0 smlal r5, r2, r3, r1 adds r4, r5, r6 adc r0, r2, r6, asr #31 lsl r0, r0, #3 orr r2, r0, r4, lsr #29 lsl r4, r4, #3 lsl r0, lr, #3 orr r6, r4, lr, lsr #29 eor r2, r2, r0, asr #31 eor r6, r6, r0, asr #31 orrs r2, r6, r2 bne LBB0_2 orr r1, r0, r12, lsr #29 lsl r0, r12, #3 b LBB0_3 LBB0_2: eor r0, r3, r1 mov r1, #8 and r0, r1, r0, lsr #25 mov r1, #0 subs r0, r0, #8 sbc r1, r1, #-2147483648 LBB0_3: lsr r0, r0, #3 orr r0, r0, r1, lsl #29 asr r1, r1, #3 pop {r4, r5, r6, r7, lr} bx lr
arm	61	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return mulu<61>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #3 orr lr, r4, r6, lsr #29 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-536870912 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #3 orr r0, r0, r2, lsr #29 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-536870912 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	62	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return muls<62>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull r12, lr, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal lr, r6, r3, r0 smlal r5, r2, r3, r1 adds r4, r5, r6 adc r0, r2, r6, asr #31 lsl r0, r0, #2 orr r2, r0, r4, lsr #30 lsl r4, r4, #2 lsl r0, lr, #2 orr r6, r4, lr, lsr #30 eor r2, r2, r0, asr #31 eor r6, r6, r0, asr #31 orrs r2, r6, r2 bne LBB0_2 orr r1, r0, r12, lsr #30 lsl r0, r12, #2 b LBB0_3 LBB0_2: eor r0, r3, r1 mov r1, #4 and r0, r1, r0, lsr #27 mov r1, #0 subs r0, r0, #4 sbc r1, r1, #-2147483648 LBB0_3: lsr r0, r0, #2 orr r0, r0, r1, lsl #30 asr r1, r1, #2 pop {r4, r5, r6, r7, lr} bx lr
arm	62	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return mulu<62>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #2 orr lr, r4, r6, lsr #30 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-1073741824 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #2 orr r0, r0, r2, lsr #30 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-1073741824 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	63	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return muls<63>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull r12, lr, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal lr, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal lr, r6, r3, r0 smlal r5, r2, r3, r1 adds r4, r5, r6 adc r0, r2, r6, asr #31 lsl r0, r0, #1 orr r2, r0, r4, lsr #31 lsl r4, r4, #1 lsl r0, lr, #1 orr r6, r4, lr, lsr #31 eor r2, r2, r0, asr #31 eor r6, r6, r0, asr #31 orrs r2, r6, r2 bne LBB0_2 orr r1, r0, r12, lsr #31 lsl r0, r12, #1 asrs r1, r1, #1 rrx r0, r0 pop {r4, r5, r6, r7, lr} bx lr LBB0_2: eor r0, r3, r1 mov r1, #2 and r0, r1, r0, lsr #29 mov r1, #0 subs r0, r0, #2 sbc r1, r1, #-2147483648 asrs r1, r1, #1 rrx r0, r0 pop {r4, r5, r6, r7, lr} bx lr
arm	63	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return mulu<63>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 push {r8, r10} umull lr, r8, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 adcs r5, lr, r6 mov r6, r1 mov r2, r5 adc r8, r8, #0 umlal r6, r2, r3, r0 lsl r4, r2, #1 orr lr, r4, r6, lsr #31 umull r4, r10, r3, r0 adds r0, r1, r4 mvn r1, #-2147483648 adcs r0, r5, r10 adc r0, r8, #0 lsl r0, r0, #1 orr r0, r0, r2, lsr #31 orrs r0, lr, r0 mvnne r12, #0 biceq r1, r6, #-2147483648 mov r0, r12 pop {r8, r10} pop {r4, r5, r6, r7, lr} bx lr
arm	64	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return muls<64>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 asr r4, r1, #31 umull lr, r12, r2, r0 mul r5, r2, r4 asr r4, r3, #31 umlal r12, r5, r2, r1 mul r6, r4, r0 asr r2, r5, #31 umlal r12, r6, r3, r0 smlal r5, r2, r3, r1 adds r0, r5, r6 adc r2, r2, r6, asr #31 eor r0, r0, r12, asr #31 eor r2, r2, r12, asr #31 orr r2, r0, r2 eor r0, r3, r1 mvn r3, #0 mov r1, #0 adds r0, r3, r0, lsr #31 sbc r1, r1, #-2147483648 cmp r2, #0 moveq r0, lr moveq r1, r12 pop {r4, r5, r6, r7, lr} bx lr
arm	64	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return mulu<64>(a, b); }	_f: push {r4, r5, r6, r7, lr} add r7, sp, #12 umull lr, r4, r3, r1 umull r5, r6, r2, r1 umull r12, r1, r2, r0 adds r1, r1, r5 mov r5, #0 adcs r2, lr, r6 adc r6, r4, #0 mov r4, #0 umlal r1, r4, r3, r0 rsbs r0, r4, #0 eor r0, r2, r0 sbc r2, r5, #0 eor r2, r6, r2 orrs r0, r0, r2 mvn r0, #0 movne r12, r0 movne r1, r0 mov r0, r12 pop {r4, r5, r6, r7, lr} bx lr
arm	4	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return divs<4>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #8 add r3, r1, #1 orr r2, r3, r2 tst r2, #15 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	4	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return divu<4>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	5	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return divs<5>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #16 add r3, r1, #1 orr r2, r3, r2 tst r2, #31 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	5	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return divu<5>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	6	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return divs<6>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #32 add r3, r1, #1 orr r2, r3, r2 tst r2, #63 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	6	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return divu<6>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	7	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return divs<7>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #64 add r3, r1, #1 orr r2, r3, r2 tst r2, #127 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	7	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return divu<7>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	8	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return divs<8>(a, b); }	_f: push {r7, lr} mov r7, sp eor r2, r0, #128 add r3, r1, #1 orr r2, r3, r2 tst r2, #255 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #24 asr r0, r0, #24 pop {r7, lr} bx lr
arm	8	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return divu<8>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	9	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return divs<9>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #256 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #256 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	9	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return divu<9>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	10	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return divs<10>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #512 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #768 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	10	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return divu<10>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	11	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return divs<11>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #1024 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #1792 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	11	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return divu<11>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	12	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return divs<12>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #2048 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #3840 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	12	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return divu<12>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	13	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return divs<13>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #4096 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #7936 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	13	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return divu<13>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	14	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return divs<14>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #8192 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #16128 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	14	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return divu<14>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	15	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return divs<15>(a, b); }	_f: push {r7, lr} mov r7, sp add r2, r0, #16384 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #32512 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	15	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return divu<15>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	16	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return divs<16>(a, b); }	_f: push {r7, lr} mov r7, sp eor r2, r0, #32768 add r3, r1, #1 orr r2, r3, r2 mov r3, #255 orr r3, r3, #65280 tst r2, r3 addeq r0, r0, #1 bl ___divsi3 lsl r0, r0, #16 asr r0, r0, #16 pop {r7, lr} bx lr
arm	16	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return divu<16>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivsi3 pop {r7, lr} bx lr
arm	17	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return divs<17>(a, b); }	_f: add r2, r0, #65536 add r3, r1, #1 orr r2, r3, r2 ldr r3, LCPI0_0 tst r2, r3 addeq r0, r0, #1 b ___divsi3 LCPI0_0:
arm	17	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return divu<17>(a, b); }	_f: b ___udivsi3
arm	18	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return divs<18>(a, b); }	_f: add r2, r0, #131072 add r3, r1, #1 orr r2, r3, r2 ldr r3, LCPI0_0 tst r2, r3 addeq r0, r0, #1 b ___divsi3 LCPI0_0:
arm	18	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return divu<18>(a, b); }	_f: b ___udivsi3
arm	19	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return divs<19>(a, b); }	_f: add r2, r0, #262144 add r3, r1, #1 orr r2, r3, r2 ldr r3, LCPI0_0 tst r2, r3 addeq r0, r0, #1 b ___divsi3 LCPI0_0:
arm	19	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return divu<19>(a, b); }	_f: b ___udivsi3
arm	20	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return divs<20>(a, b); }	_f: add r2, r0, #524288 add r3, r1, #1 orr r2, r3, r2 ldr r3, LCPI0_0 tst r2, r3 addeq r0, r0, #1 b ___divsi3 LCPI0_0:
arm	20	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return divu<20>(a, b); }	_f: b ___udivsi3
arm	21	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return divs<21>(a, b); }	_f: add r2, r0, #1048576 add r3, r1, #1 orr r2, r3, r2 ldr r3, LCPI0_0 tst r2, r3 addeq r0, r0, #1 b ___divsi3 LCPI0_0:
arm	21	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return divu<21>(a, b); }	_f: b ___udivsi3
arm	22	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return divs<22>(a, b); }	_f: add r2, r0, #2097152 add r3, r1, #1 orr r2, r3, r2 ldr r3, LCPI0_0 tst r2, r3 addeq r0, r0, #1 b ___divsi3 LCPI0_0:
arm	22	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return divu<22>(a, b); }	_f: b ___udivsi3
arm	23	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return divs<23>(a, b); }	_f: add r2, r0, #4194304 add r3, r1, #1 orr r2, r3, r2 ldr r3, LCPI0_0 tst r2, r3 addeq r0, r0, #1 b ___divsi3 LCPI0_0:
arm	23	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return divu<23>(a, b); }	_f: b ___udivsi3
arm	24	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return divs<24>(a, b); }	_f: add r2, r0, #8388608 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-16777216 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	24	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return divu<24>(a, b); }	_f: b ___udivsi3
arm	25	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return divs<25>(a, b); }	_f: add r2, r0, #16777216 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-33554432 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	25	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return divu<25>(a, b); }	_f: b ___udivsi3
arm	26	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return divs<26>(a, b); }	_f: add r2, r0, #33554432 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-67108864 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	26	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return divu<26>(a, b); }	_f: b ___udivsi3
arm	27	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return divs<27>(a, b); }	_f: add r2, r0, #67108864 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-134217728 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	27	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return divu<27>(a, b); }	_f: b ___udivsi3
arm	28	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return divs<28>(a, b); }	_f: add r2, r0, #134217728 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-268435456 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	28	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return divu<28>(a, b); }	_f: b ___udivsi3
arm	29	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return divs<29>(a, b); }	_f: add r2, r0, #268435456 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-536870912 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	29	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return divu<29>(a, b); }	_f: b ___udivsi3
arm	30	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return divs<30>(a, b); }	_f: add r2, r0, #536870912 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-1073741824 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	30	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return divu<30>(a, b); }	_f: b ___udivsi3
arm	31	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return divs<31>(a, b); }	_f: add r2, r0, #1073741824 add r3, r1, #1 orr r2, r3, r2 mvn r3, #-2147483648 tst r2, r3 addeq r0, r0, #1 b ___divsi3
arm	31	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return divu<31>(a, b); }	_f: b ___udivsi3
arm	32	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return divs<32>(a, b); }	_f: eor r2, r0, #-2147483648 add r3, r1, #1 orrs r2, r3, r2 addeq r0, r0, #1 b ___divsi3
arm	32	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return divu<32>(a, b); }	_f: b ___udivsi3
arm	33	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return divs<33>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #1 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #1 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	33	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return divu<33>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	34	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return divs<34>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #2 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #3 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	34	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return divu<34>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	35	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return divs<35>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #4 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #7 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	35	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return divu<35>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	36	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return divs<36>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #8 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #15 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	36	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return divu<36>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	37	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return divs<37>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #16 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #31 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	37	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return divu<37>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	38	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return divs<38>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #32 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #63 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	38	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return divu<38>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	39	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return divs<39>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #64 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #127 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	39	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return divu<39>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	40	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return divs<40>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 eor r4, r1, #128 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 and r4, r4, #255 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	40	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return divu<40>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	41	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return divs<41>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #256 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #256 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	41	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return divu<41>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	42	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return divs<42>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #512 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #768 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	42	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return divu<42>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	43	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return divs<43>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #1024 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #1792 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	43	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return divu<43>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	44	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return divs<44>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #2048 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #3840 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	44	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return divu<44>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	45	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return divs<45>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #4096 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #7936 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	45	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return divu<45>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	46	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return divs<46>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #8192 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #16128 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	46	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return divu<46>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	47	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return divs<47>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #16384 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #32512 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	47	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return divu<47>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	48	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return divs<48>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 eor r4, r1, #32768 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 mov r4, #255 orr r4, r4, #65280 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	48	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return divu<48>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	49	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return divs<49>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #65536 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 ldr r4, LCPI0_0 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr LCPI0_0:
arm	49	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return divu<49>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	50	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return divs<50>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #131072 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 ldr r4, LCPI0_0 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr LCPI0_0:
arm	50	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return divu<50>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	51	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return divs<51>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #262144 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 ldr r4, LCPI0_0 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr LCPI0_0:
arm	51	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return divu<51>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	52	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return divs<52>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #524288 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 ldr r4, LCPI0_0 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr LCPI0_0:
arm	52	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return divu<52>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	53	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return divs<53>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #1048576 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 ldr r4, LCPI0_0 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr LCPI0_0:
arm	53	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return divu<53>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	54	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return divs<54>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #2097152 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 ldr r4, LCPI0_0 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr LCPI0_0:
arm	54	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return divu<54>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	55	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return divs<55>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #4194304 adc lr, r3, #0 orr r12, r12, r0 orr lr, lr, r4 ldr r4, LCPI0_0 and r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr LCPI0_0:
arm	55	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return divu<55>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	56	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return divs<56>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 eor r4, r1, #8388608 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-16777216 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	56	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return divu<56>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	57	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return divs<57>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #16777216 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-33554432 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	57	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return divu<57>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	58	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return divs<58>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #33554432 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-67108864 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	58	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return divu<58>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	59	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return divs<59>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #67108864 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-134217728 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	59	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return divu<59>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	60	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return divs<60>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #134217728 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-268435456 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	60	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return divu<60>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	61	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return divs<61>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #268435456 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-536870912 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	61	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return divu<61>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	62	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return divs<62>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #536870912 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-1073741824 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	62	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return divu<62>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	63	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return divs<63>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 add r4, r1, #1073741824 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 bic r4, r4, #-2147483648 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	63	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return divu<63>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm	64	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return divs<64>(a, b); }	_f: push {r4, r7, lr} add r7, sp, #4 adds r12, r2, #1 eor r4, r1, #-2147483648 adc lr, r3, #0 orr r12, r12, r0 orr r4, lr, r4 orr r4, r12, r4 adds r12, r0, #1 adc lr, r1, #0 cmp r4, #0 moveq r0, r12 moveq r1, lr bl ___divdi3 pop {r4, r7, lr} bx lr
arm	64	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return divu<64>(a, b); }	_f: push {r7, lr} mov r7, sp bl ___udivdi3 pop {r7, lr} bx lr
arm64	4	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return adds<4>(a, b); }	_f: ; @f lsl w8, w0, #1 and w8, w8, #0x10 add w8, w8, #112 sbfx w8, w8, #4, #4 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #4 tst w9, #0x8 csel w0, w8, w10, eq ret
arm64	4	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return addu<4>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xff cmp w9, #15 ccmp w9, w8, #0, ls and w8, w8, #0xf mov w9, #15 csel w0, w9, w8, ne ret
arm64	5	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return adds<5>(a, b); }	_f: ; @f lsr w8, w0, #1 and w8, w8, #0x8 add w8, w8, #120 sbfx w8, w8, #3, #5 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #5 tst w9, #0x10 csel w0, w8, w10, eq ret
arm64	5	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return addu<5>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xff cmp w9, #31 ccmp w9, w8, #0, ls and w8, w8, #0x1f mov w9, #31 csel w0, w9, w8, ne ret
arm64	6	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return adds<6>(a, b); }	_f: ; @f lsr w8, w0, #3 and w8, w8, #0x4 add w8, w8, #124 sbfx w8, w8, #2, #6 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #6 tst w9, #0x20 csel w0, w8, w10, eq ret
arm64	6	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return addu<6>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xff cmp w9, #63 ccmp w9, w8, #0, ls and w8, w8, #0x3f mov w9, #63 csel w0, w9, w8, ne ret
arm64	7	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return adds<7>(a, b); }	_f: ; @f lsr w8, w0, #5 and w8, w8, #0x2 add w8, w8, #126 sbfx w8, w8, #1, #7 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #7 tst w9, #0x40 csel w0, w8, w10, eq ret
arm64	7	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return addu<7>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xff cmp w9, w8 cset w10, ne orr w9, w10, w9, lsr #7 neg w9, w9 orr w8, w8, w9 and w0, w8, #0x7f ret
arm64	8	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return adds<8>(a, b); }	_f: ; @f ubfx w8, w0, #7, #1 add w8, w8, #127 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sxtb w9, w9 cmp w9, #0 csel w8, w8, w10, ge sxtb w0, w8 ret
arm64	8	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return addu<8>(a, b); }	_f: ; @f add w8, w0, w1 mov w9, #255 cmp w8, #255 csel w0, w8, w9, lo ret
arm64	9	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return adds<9>(a, b); }	_f: ; @f lsr w8, w0, #1 and w8, w8, #0x80 mov w9, #32640 add w8, w8, w9 sbfx w8, w8, #7, #9 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #9 tst w9, #0x100 csel w0, w8, w10, eq ret
arm64	9	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return addu<9>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xffff cmp w9, #511 ccmp w9, w8, #0, ls and w8, w8, #0x1ff mov w9, #511 csel w0, w9, w8, ne ret
arm64	10	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return adds<10>(a, b); }	_f: ; @f lsr w8, w0, #3 and w8, w8, #0x40 mov w9, #32704 add w8, w8, w9 sbfx w8, w8, #6, #10 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #10 tst w9, #0x200 csel w0, w8, w10, eq ret
arm64	10	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return addu<10>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xffff cmp w9, #1023 ccmp w9, w8, #0, ls and w8, w8, #0x3ff mov w9, #1023 csel w0, w9, w8, ne ret
arm64	11	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return adds<11>(a, b); }	_f: ; @f lsr w8, w0, #5 and w8, w8, #0x20 mov w9, #32736 add w8, w8, w9 sbfx w8, w8, #5, #11 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #11 tst w9, #0x400 csel w0, w8, w10, eq ret
arm64	11	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return addu<11>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xffff cmp w9, #2047 ccmp w9, w8, #0, ls and w8, w8, #0x7ff mov w9, #2047 csel w0, w9, w8, ne ret
arm64	12	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return adds<12>(a, b); }	_f: ; @f lsr w8, w0, #7 and w8, w8, #0x10 mov w9, #32752 add w8, w8, w9 sbfx w8, w8, #4, #12 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #12 tst w9, #0x800 csel w0, w8, w10, eq ret
arm64	12	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return addu<12>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xffff cmp w9, #4095 ccmp w9, w8, #0, ls and w8, w8, #0xfff mov w9, #4095 csel w0, w9, w8, ne ret
arm64	13	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return adds<13>(a, b); }	_f: ; @f lsr w8, w0, #9 and w8, w8, #0x8 mov w9, #32760 add w8, w8, w9 sbfx w8, w8, #3, #13 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #13 tst w9, #0x1000 csel w0, w8, w10, eq ret
arm64	13	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return addu<13>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xffff ubfx w10, w8, #13, #3 cmp w10, #0 ccmp w9, w8, #0, eq and w8, w8, #0x1fff mov w9, #8191 csel w0, w9, w8, ne ret
arm64	14	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return adds<14>(a, b); }	_f: ; @f lsr w8, w0, #11 and w8, w8, #0x4 mov w9, #32764 add w8, w8, w9 sbfx w8, w8, #2, #14 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #14 tst w9, #0x2000 csel w0, w8, w10, eq ret
arm64	14	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return addu<14>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xffff ubfx w10, w8, #14, #2 cmp w10, #0 ccmp w9, w8, #0, eq and w8, w8, #0x3fff mov w9, #16383 csel w0, w9, w8, ne ret
arm64	15	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return adds<15>(a, b); }	_f: ; @f lsr w8, w0, #13 and w8, w8, #0x2 mov w9, #32766 add w8, w8, w9 sbfx w8, w8, #1, #15 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #15 tst w9, #0x4000 csel w0, w8, w10, eq ret
arm64	15	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return addu<15>(a, b); }	_f: ; @f add w8, w1, w0 and w9, w8, #0xffff cmp w9, w8 cset w10, ne orr w9, w10, w9, lsr #15 neg w9, w9 orr w8, w8, w9 and w0, w8, #0x7fff ret
arm64	16	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return adds<16>(a, b); }	_f: ; @f and w8, w0, #0x8000 mov w9, #32767 add w8, w9, w8, lsr #15 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sxth w9, w9 cmp w9, #0 csel w8, w8, w10, ge sxth w0, w8 ret
arm64	16	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return addu<16>(a, b); }	_f: ; @f mov w8, #65535 add w9, w0, w1 cmp w9, w8 csel w0, w9, w8, lo ret
arm64	17	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return adds<17>(a, b); }	_f: ; @f lsr w8, w0, #1 and w8, w8, #0x8000 mov w9, #2147450880 add w8, w8, w9 asr w8, w8, #15 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #17 tst w9, #0x10000 csel w0, w8, w10, eq ret
arm64	17	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return addu<17>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #17 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x1ffff mov w10, #131071 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	18	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return adds<18>(a, b); }	_f: ; @f lsr w8, w0, #3 and w8, w8, #0x4000 mov w9, #2147467264 add w8, w8, w9 asr w8, w8, #14 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #18 tst w9, #0x20000 csel w0, w8, w10, eq ret
arm64	18	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return addu<18>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #18 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x3ffff mov w10, #262143 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	19	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return adds<19>(a, b); }	_f: ; @f lsr w8, w0, #5 and w8, w8, #0x2000 mov w9, #2147475456 add w8, w8, w9 asr w8, w8, #13 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #19 tst w9, #0x40000 csel w0, w8, w10, eq ret
arm64	19	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return addu<19>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #19 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x7ffff mov w10, #524287 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	20	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return adds<20>(a, b); }	_f: ; @f lsr w8, w0, #7 and w8, w8, #0x1000 mov w9, #2147479552 add w8, w8, w9 asr w8, w8, #12 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #20 tst w9, #0x80000 csel w0, w8, w10, eq ret
arm64	20	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return addu<20>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #20 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0xfffff mov w10, #1048575 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	21	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return adds<21>(a, b); }	_f: ; @f lsr w8, w0, #9 and w8, w8, #0x800 mov w9, #2147481600 add w8, w8, w9 asr w8, w8, #11 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #21 tst w9, #0x100000 csel w0, w8, w10, eq ret
arm64	21	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return addu<21>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #21 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x1fffff mov w10, #2097151 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	22	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return adds<22>(a, b); }	_f: ; @f lsr w8, w0, #11 and w8, w8, #0x400 mov w9, #2147482624 add w8, w8, w9 asr w8, w8, #10 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #22 tst w9, #0x200000 csel w0, w8, w10, eq ret
arm64	22	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return addu<22>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #22 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x3fffff mov w10, #4194303 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	23	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return adds<23>(a, b); }	_f: ; @f lsr w8, w0, #13 and w8, w8, #0x200 mov w9, #2147483136 add w8, w8, w9 asr w8, w8, #9 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #23 tst w9, #0x400000 csel w0, w8, w10, eq ret
arm64	23	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return addu<23>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #23 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x7fffff mov w10, #8388607 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	24	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return adds<24>(a, b); }	_f: ; @f lsr w8, w0, #15 and w8, w8, #0x100 mov w9, #2147483392 add w8, w8, w9 asr w8, w8, #8 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #24 tst w9, #0x800000 csel w0, w8, w10, eq ret
arm64	24	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return addu<24>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #24 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0xffffff mov w10, #16777215 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	25	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return adds<25>(a, b); }	_f: ; @f lsr w8, w0, #17 and w8, w8, #0x80 mov w9, #2147483520 add w8, w8, w9 asr w8, w8, #7 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #25 tst w9, #0x1000000 csel w0, w8, w10, eq ret
arm64	25	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return addu<25>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #25 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x1ffffff mov w10, #33554431 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	26	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return adds<26>(a, b); }	_f: ; @f lsr w8, w0, #19 and w8, w8, #0x40 mov w9, #2147483584 add w8, w8, w9 asr w8, w8, #6 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #26 tst w9, #0x2000000 csel w0, w8, w10, eq ret
arm64	26	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return addu<26>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #26 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x3ffffff mov w10, #67108863 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	27	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return adds<27>(a, b); }	_f: ; @f lsr w8, w0, #21 and w8, w8, #0x20 mov w9, #2147483616 add w8, w8, w9 asr w8, w8, #5 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #27 tst w9, #0x4000000 csel w0, w8, w10, eq ret
arm64	27	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return addu<27>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #27 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x7ffffff mov w10, #134217727 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	28	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return adds<28>(a, b); }	_f: ; @f lsr w8, w0, #23 and w8, w8, #0x10 mov w9, #2147483632 add w8, w8, w9 asr w8, w8, #4 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #28 tst w9, #0x8000000 csel w0, w8, w10, eq ret
arm64	28	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return addu<28>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #28 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0xfffffff mov w10, #268435455 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	29	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return adds<29>(a, b); }	_f: ; @f lsr w8, w0, #25 and w8, w8, #0x8 mov w9, #2147483640 add w8, w8, w9 asr w8, w8, #3 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #29 tst w9, #0x10000000 csel w0, w8, w10, eq ret
arm64	29	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return addu<29>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #29 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x1fffffff mov w10, #536870911 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	30	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return adds<30>(a, b); }	_f: ; @f lsr w8, w0, #27 and w8, w8, #0x4 mov w9, #2147483644 add w8, w8, w9 asr w8, w8, #2 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #30 tst w9, #0x20000000 csel w0, w8, w10, eq ret
arm64	30	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return addu<30>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs lsr w10, w8, #30 cmp w10, #0 cset w10, ne orr w9, w9, w10 and w8, w8, #0x3fffffff mov w10, #1073741823 cmp w9, #0 csel w0, w10, w8, ne ret
arm64	31	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return adds<31>(a, b); }	_f: ; @f lsr w8, w0, #29 and w8, w8, #0x2 mov w9, #2147483646 add w8, w8, w9 asr w8, w8, #1 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 sbfx w10, w10, #0, #31 tst w9, #0x40000000 csel w0, w8, w10, eq ret
arm64	31	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return addu<31>(a, b); }	_f: ; @f adds w8, w1, w0 cset w9, hs orr w9, w9, w8, lsr #31 neg w9, w9 orr w8, w8, w9 and w0, w8, #0x7fffffff ret
arm64	32	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return adds<32>(a, b); }	_f: ; @f mov w8, #2147483647 add w8, w8, w0, lsr #31 eor w9, w8, w1 add w10, w1, w0 eor w11, w10, w1 orn w9, w9, w11 cmp w9, #0 csel w0, w8, w10, ge ret
arm64	32	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return addu<32>(a, b); }	_f: ; @f adds w8, w0, w1 csinv w0, w8, wzr, lo ret
arm64	33	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return adds<33>(a, b); }	_f: ; @f lsr x8, x0, #1 and x8, x8, #0x80000000 mov x9, #9223372034707292160 add x8, x8, x9 asr x8, x8, #31 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #33 tst x9, #0x100000000 csel x0, x8, x10, eq ret
arm64	33	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return addu<33>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #33 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1ffffffff cmp w9, #0 mov x9, #8589934591 csel x0, x9, x8, ne ret
arm64	34	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return adds<34>(a, b); }	_f: ; @f lsr x8, x0, #3 and x8, x8, #0x40000000 mov x9, #9223372035781033984 add x8, x8, x9 asr x8, x8, #30 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #34 tst x9, #0x200000000 csel x0, x8, x10, eq ret
arm64	34	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return addu<34>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #34 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3ffffffff cmp w9, #0 mov x9, #17179869183 csel x0, x9, x8, ne ret
arm64	35	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return adds<35>(a, b); }	_f: ; @f lsr x8, x0, #5 and x8, x8, #0x20000000 mov x9, #9223372036317904896 add x8, x8, x9 asr x8, x8, #29 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #35 tst x9, #0x400000000 csel x0, x8, x10, eq ret
arm64	35	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return addu<35>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #35 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x7ffffffff cmp w9, #0 mov x9, #34359738367 csel x0, x9, x8, ne ret
arm64	36	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return adds<36>(a, b); }	_f: ; @f lsr x8, x0, #7 and x8, x8, #0x10000000 mov x9, #9223372036586340352 add x8, x8, x9 asr x8, x8, #28 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #36 tst x9, #0x800000000 csel x0, x8, x10, eq ret
arm64	36	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return addu<36>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #36 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0xfffffffff cmp w9, #0 mov x9, #68719476735 csel x0, x9, x8, ne ret
arm64	37	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return adds<37>(a, b); }	_f: ; @f lsr x8, x0, #9 and x8, x8, #0x8000000 mov x9, #9223372036720558080 add x8, x8, x9 asr x8, x8, #27 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #37 tst x9, #0x1000000000 csel x0, x8, x10, eq ret
arm64	37	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return addu<37>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #37 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1fffffffff cmp w9, #0 mov x9, #137438953471 csel x0, x9, x8, ne ret
arm64	38	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return adds<38>(a, b); }	_f: ; @f lsr x8, x0, #11 and x8, x8, #0x4000000 mov x9, #9223372036787666944 add x8, x8, x9 asr x8, x8, #26 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #38 tst x9, #0x2000000000 csel x0, x8, x10, eq ret
arm64	38	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return addu<38>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #38 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3fffffffff cmp w9, #0 mov x9, #274877906943 csel x0, x9, x8, ne ret
arm64	39	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return adds<39>(a, b); }	_f: ; @f lsr x8, x0, #13 and x8, x8, #0x2000000 mov x9, #9223372036821221376 add x8, x8, x9 asr x8, x8, #25 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #39 tst x9, #0x4000000000 csel x0, x8, x10, eq ret
arm64	39	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return addu<39>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #39 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x7fffffffff cmp w9, #0 mov x9, #549755813887 csel x0, x9, x8, ne ret
arm64	40	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return adds<40>(a, b); }	_f: ; @f lsr x8, x0, #15 and x8, x8, #0x1000000 mov x9, #9223372036837998592 add x8, x8, x9 asr x8, x8, #24 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #40 tst x9, #0x8000000000 csel x0, x8, x10, eq ret
arm64	40	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return addu<40>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #40 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0xffffffffff cmp w9, #0 mov x9, #1099511627775 csel x0, x9, x8, ne ret
arm64	41	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return adds<41>(a, b); }	_f: ; @f lsr x8, x0, #17 and x8, x8, #0x800000 mov x9, #9223372036846387200 add x8, x8, x9 asr x8, x8, #23 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #41 tst x9, #0x10000000000 csel x0, x8, x10, eq ret
arm64	41	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return addu<41>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #41 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1ffffffffff cmp w9, #0 mov x9, #2199023255551 csel x0, x9, x8, ne ret
arm64	42	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return adds<42>(a, b); }	_f: ; @f lsr x8, x0, #19 and x8, x8, #0x400000 mov x9, #9223372036850581504 add x8, x8, x9 asr x8, x8, #22 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #42 tst x9, #0x20000000000 csel x0, x8, x10, eq ret
arm64	42	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return addu<42>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #42 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3ffffffffff cmp w9, #0 mov x9, #4398046511103 csel x0, x9, x8, ne ret
arm64	43	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return adds<43>(a, b); }	_f: ; @f lsr x8, x0, #21 and x8, x8, #0x200000 mov x9, #9223372036852678656 add x8, x8, x9 asr x8, x8, #21 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #43 tst x9, #0x40000000000 csel x0, x8, x10, eq ret
arm64	43	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return addu<43>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #43 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x7ffffffffff cmp w9, #0 mov x9, #8796093022207 csel x0, x9, x8, ne ret
arm64	44	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return adds<44>(a, b); }	_f: ; @f lsr x8, x0, #23 and x8, x8, #0x100000 mov x9, #9223372036853727232 add x8, x8, x9 asr x8, x8, #20 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #44 tst x9, #0x80000000000 csel x0, x8, x10, eq ret
arm64	44	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return addu<44>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #44 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0xfffffffffff cmp w9, #0 mov x9, #17592186044415 csel x0, x9, x8, ne ret
arm64	45	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return adds<45>(a, b); }	_f: ; @f lsr x8, x0, #25 and x8, x8, #0x80000 mov x9, #9223372036854251520 add x8, x8, x9 asr x8, x8, #19 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #45 tst x9, #0x100000000000 csel x0, x8, x10, eq ret
arm64	45	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return addu<45>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #45 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1fffffffffff cmp w9, #0 mov x9, #35184372088831 csel x0, x9, x8, ne ret
arm64	46	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return adds<46>(a, b); }	_f: ; @f lsr x8, x0, #27 and x8, x8, #0x40000 mov x9, #9223372036854513664 add x8, x8, x9 asr x8, x8, #18 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #46 tst x9, #0x200000000000 csel x0, x8, x10, eq ret
arm64	46	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return addu<46>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #46 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3fffffffffff cmp w9, #0 mov x9, #70368744177663 csel x0, x9, x8, ne ret
arm64	47	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return adds<47>(a, b); }	_f: ; @f lsr x8, x0, #29 and x8, x8, #0x20000 mov x9, #9223372036854644736 add x8, x8, x9 asr x8, x8, #17 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #47 tst x9, #0x400000000000 csel x0, x8, x10, eq ret
arm64	47	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return addu<47>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #47 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x7fffffffffff cmp w9, #0 mov x9, #140737488355327 csel x0, x9, x8, ne ret
arm64	48	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return adds<48>(a, b); }	_f: ; @f lsr x8, x0, #31 and x8, x8, #0x10000 mov x9, #9223372036854710272 add x8, x8, x9 asr x8, x8, #16 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #48 tst x9, #0x800000000000 csel x0, x8, x10, eq ret
arm64	48	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return addu<48>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #48 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0xffffffffffff cmp w9, #0 mov x9, #281474976710655 csel x0, x9, x8, ne ret
arm64	49	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return adds<49>(a, b); }	_f: ; @f lsr x8, x0, #33 and x8, x8, #0x8000 mov x9, #9223372036854743040 add x8, x8, x9 asr x8, x8, #15 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #49 tst x9, #0x1000000000000 csel x0, x8, x10, eq ret
arm64	49	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return addu<49>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #49 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1ffffffffffff cmp w9, #0 mov x9, #562949953421311 csel x0, x9, x8, ne ret
arm64	50	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return adds<50>(a, b); }	_f: ; @f lsr x8, x0, #35 and x8, x8, #0x4000 mov x9, #9223372036854759424 add x8, x8, x9 asr x8, x8, #14 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #50 tst x9, #0x2000000000000 csel x0, x8, x10, eq ret
arm64	50	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return addu<50>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #50 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3ffffffffffff cmp w9, #0 mov x9, #1125899906842623 csel x0, x9, x8, ne ret
arm64	51	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return adds<51>(a, b); }	_f: ; @f lsr x8, x0, #37 and x8, x8, #0x2000 mov x9, #9223372036854767616 add x8, x8, x9 asr x8, x8, #13 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #51 tst x9, #0x4000000000000 csel x0, x8, x10, eq ret
arm64	51	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return addu<51>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #51 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x7ffffffffffff cmp w9, #0 mov x9, #2251799813685247 csel x0, x9, x8, ne ret
arm64	52	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return adds<52>(a, b); }	_f: ; @f lsr x8, x0, #39 and x8, x8, #0x1000 mov x9, #9223372036854771712 add x8, x8, x9 asr x8, x8, #12 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #52 tst x9, #0x8000000000000 csel x0, x8, x10, eq ret
arm64	52	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return addu<52>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #52 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0xfffffffffffff cmp w9, #0 mov x9, #4503599627370495 csel x0, x9, x8, ne ret
arm64	53	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return adds<53>(a, b); }	_f: ; @f lsr x8, x0, #41 and x8, x8, #0x800 mov x9, #9223372036854773760 add x8, x8, x9 asr x8, x8, #11 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #53 tst x9, #0x10000000000000 csel x0, x8, x10, eq ret
arm64	53	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return addu<53>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #53 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1fffffffffffff cmp w9, #0 mov x9, #9007199254740991 csel x0, x9, x8, ne ret
arm64	54	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return adds<54>(a, b); }	_f: ; @f lsr x8, x0, #43 and x8, x8, #0x400 mov x9, #9223372036854774784 add x8, x8, x9 asr x8, x8, #10 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #54 tst x9, #0x20000000000000 csel x0, x8, x10, eq ret
arm64	54	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return addu<54>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #54 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3fffffffffffff cmp w9, #0 mov x9, #18014398509481983 csel x0, x9, x8, ne ret
arm64	55	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return adds<55>(a, b); }	_f: ; @f lsr x8, x0, #45 and x8, x8, #0x200 mov x9, #9223372036854775296 add x8, x8, x9 asr x8, x8, #9 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #55 tst x9, #0x40000000000000 csel x0, x8, x10, eq ret
arm64	55	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return addu<55>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #55 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x7fffffffffffff cmp w9, #0 mov x9, #36028797018963967 csel x0, x9, x8, ne ret
arm64	56	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return adds<56>(a, b); }	_f: ; @f lsr x8, x0, #47 and x8, x8, #0x100 mov x9, #9223372036854775552 add x8, x8, x9 asr x8, x8, #8 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #56 tst x9, #0x80000000000000 csel x0, x8, x10, eq ret
arm64	56	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return addu<56>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #56 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0xffffffffffffff cmp w9, #0 mov x9, #72057594037927935 csel x0, x9, x8, ne ret
arm64	57	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return adds<57>(a, b); }	_f: ; @f lsr x8, x0, #49 and x8, x8, #0x80 mov x9, #9223372036854775680 add x8, x8, x9 asr x8, x8, #7 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #57 tst x9, #0x100000000000000 csel x0, x8, x10, eq ret
arm64	57	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return addu<57>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #57 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1ffffffffffffff cmp w9, #0 mov x9, #144115188075855871 csel x0, x9, x8, ne ret
arm64	58	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return adds<58>(a, b); }	_f: ; @f lsr x8, x0, #51 and x8, x8, #0x40 mov x9, #9223372036854775744 add x8, x8, x9 asr x8, x8, #6 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #58 tst x9, #0x200000000000000 csel x0, x8, x10, eq ret
arm64	58	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return addu<58>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #58 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3ffffffffffffff cmp w9, #0 mov x9, #288230376151711743 csel x0, x9, x8, ne ret
arm64	59	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return adds<59>(a, b); }	_f: ; @f lsr x8, x0, #53 and x8, x8, #0x20 mov x9, #9223372036854775776 add x8, x8, x9 asr x8, x8, #5 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #59 tst x9, #0x400000000000000 csel x0, x8, x10, eq ret
arm64	59	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return addu<59>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #59 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x7ffffffffffffff cmp w9, #0 mov x9, #576460752303423487 csel x0, x9, x8, ne ret
arm64	60	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return adds<60>(a, b); }	_f: ; @f lsr x8, x0, #55 and x8, x8, #0x10 mov x9, #9223372036854775792 add x8, x8, x9 asr x8, x8, #4 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #60 tst x9, #0x800000000000000 csel x0, x8, x10, eq ret
arm64	60	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return addu<60>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #60 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0xfffffffffffffff cmp w9, #0 mov x9, #1152921504606846975 csel x0, x9, x8, ne ret
arm64	61	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return adds<61>(a, b); }	_f: ; @f lsr x8, x0, #57 and x8, x8, #0x8 mov x9, #9223372036854775800 add x8, x8, x9 asr x8, x8, #3 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #61 tst x9, #0x1000000000000000 csel x0, x8, x10, eq ret
arm64	61	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return addu<61>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #61 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x1fffffffffffffff cmp w9, #0 mov x9, #2305843009213693951 csel x0, x9, x8, ne ret
arm64	62	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return adds<62>(a, b); }	_f: ; @f lsr x8, x0, #59 and x8, x8, #0x4 mov x9, #9223372036854775804 add x8, x8, x9 asr x8, x8, #2 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #62 tst x9, #0x2000000000000000 csel x0, x8, x10, eq ret
arm64	62	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return addu<62>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs lsr x10, x8, #62 cmp x10, #0 cset w10, ne orr w9, w9, w10 and x8, x8, #0x3fffffffffffffff cmp w9, #0 mov x9, #4611686018427387903 csel x0, x9, x8, ne ret
arm64	63	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return adds<63>(a, b); }	_f: ; @f lsr x8, x0, #61 and x8, x8, #0x2 mov x9, #9223372036854775806 add x8, x8, x9 asr x8, x8, #1 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 sbfx x10, x10, #0, #63 tst x9, #0x4000000000000000 csel x0, x8, x10, eq ret
arm64	63	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return addu<63>(a, b); }	_f: ; @f adds x8, x1, x0 cset w9, hs orr x9, x9, x8, lsr #63 neg x9, x9 orr x8, x8, x9 and x0, x8, #0x7fffffffffffffff ret
arm64	64	add	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return adds<64>(a, b); }	_f: ; @f mov x8, #9223372036854775807 add x8, x8, x0, lsr #63 eor x9, x8, x1 add x10, x1, x0 eor x11, x10, x1 orn x9, x9, x11 cmp x9, #0 csel x0, x8, x10, ge ret
arm64	64	add	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return addu<64>(a, b); }	_f: ; @f adds x8, x0, x1 csinv x0, x8, xzr, lo ret
arm64	4	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return subs<4>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #3, #1 add w10, w10, #7 tst w8, #0x8 csel w8, w9, w10, eq sbfx w0, w8, #0, #4 ret
arm64	4	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return subu<4>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0xf ret
arm64	5	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return subs<5>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #4, #1 add w10, w10, #15 tst w8, #0x10 csel w8, w9, w10, eq sbfx w0, w8, #0, #5 ret
arm64	5	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return subu<5>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x1f ret
arm64	6	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return subs<6>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #5, #1 add w10, w10, #31 tst w8, #0x20 csel w8, w9, w10, eq sbfx w0, w8, #0, #6 ret
arm64	6	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return subu<6>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x3f ret
arm64	7	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return subs<7>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #6, #1 add w10, w10, #63 tst w8, #0x40 csel w8, w9, w10, eq sbfx w0, w8, #0, #7 ret
arm64	7	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return subu<7>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x7f ret
arm64	8	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return subs<8>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w10, w8 sxtb w8, w8 ubfx w10, w0, #7, #1 add w10, w10, #127 cmp w8, #0 csel w8, w10, w9, lt sxtb w0, w8 ret
arm64	8	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return subu<8>(a, b); }	_f: ; @f subs w8, w0, w1 csel w0, wzr, w8, lo ret
arm64	9	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return subs<9>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #8, #1 add w10, w10, #255 tst w8, #0x100 csel w8, w9, w10, eq sbfx w0, w8, #0, #9 ret
arm64	9	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return subu<9>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x1ff ret
arm64	10	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return subs<10>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #9, #1 add w10, w10, #511 tst w8, #0x200 csel w8, w9, w10, eq sbfx w0, w8, #0, #10 ret
arm64	10	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return subu<10>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x3ff ret
arm64	11	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return subs<11>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #10, #1 add w10, w10, #1023 tst w8, #0x400 csel w8, w9, w10, eq sbfx w0, w8, #0, #11 ret
arm64	11	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return subu<11>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x7ff ret
arm64	12	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return subs<12>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #11, #1 add w10, w10, #2047 tst w8, #0x800 csel w8, w9, w10, eq sbfx w0, w8, #0, #12 ret
arm64	12	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return subu<12>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0xfff ret
arm64	13	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return subs<13>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #12, #1 add w10, w10, #4095 tst w8, #0x1000 csel w8, w9, w10, eq sbfx w0, w8, #0, #13 ret
arm64	13	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return subu<13>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x1fff ret
arm64	14	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return subs<14>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #13, #1 mov w11, #8191 add w10, w10, w11 tst w8, #0x2000 csel w8, w9, w10, eq sbfx w0, w8, #0, #14 ret
arm64	14	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return subu<14>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x3fff ret
arm64	15	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return subs<15>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #14, #1 mov w11, #16383 add w10, w10, w11 tst w8, #0x4000 csel w8, w9, w10, eq sbfx w0, w8, #0, #15 ret
arm64	15	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return subu<15>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x7fff ret
arm64	16	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return subs<16>(a, b); }	_f: ; @f and w8, w0, #0x8000 eor w9, w1, w0 sub w10, w0, w1 eor w11, w10, w0 and w9, w11, w9 sxth w9, w9 mov w11, #32767 add w8, w11, w8, lsr #15 cmp w9, #0 csel w8, w8, w10, lt sxth w0, w8 ret
arm64	16	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return subu<16>(a, b); }	_f: ; @f subs w8, w0, w1 csel w0, wzr, w8, lo ret
arm64	17	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return subs<17>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #1 and w10, w10, #0x8000 mov w11, #2147450880 add w10, w10, w11 lsl w9, w9, #15 tst w8, #0x10000 csel w8, w9, w10, eq asr w0, w8, #15 ret
arm64	17	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return subu<17>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x1ffff ret
arm64	18	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return subs<18>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #3 and w10, w10, #0x4000 mov w11, #2147467264 add w10, w10, w11 lsl w9, w9, #14 tst w8, #0x20000 csel w8, w9, w10, eq asr w0, w8, #14 ret
arm64	18	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return subu<18>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x3ffff ret
arm64	19	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return subs<19>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #5 and w10, w10, #0x2000 mov w11, #2147475456 add w10, w10, w11 lsl w9, w9, #13 tst w8, #0x40000 csel w8, w9, w10, eq asr w0, w8, #13 ret
arm64	19	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return subu<19>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x7ffff ret
arm64	20	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return subs<20>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #7 and w10, w10, #0x1000 mov w11, #2147479552 add w10, w10, w11 lsl w9, w9, #12 tst w8, #0x80000 csel w8, w9, w10, eq asr w0, w8, #12 ret
arm64	20	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return subu<20>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0xfffff ret
arm64	21	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return subs<21>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #9 and w10, w10, #0x800 mov w11, #2147481600 add w10, w10, w11 lsl w9, w9, #11 tst w8, #0x100000 csel w8, w9, w10, eq asr w0, w8, #11 ret
arm64	21	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return subu<21>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x1fffff ret
arm64	22	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return subs<22>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #11 and w10, w10, #0x400 mov w11, #2147482624 add w10, w10, w11 lsl w9, w9, #10 tst w8, #0x200000 csel w8, w9, w10, eq asr w0, w8, #10 ret
arm64	22	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return subu<22>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x3fffff ret
arm64	23	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return subs<23>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #13 and w10, w10, #0x200 mov w11, #2147483136 add w10, w10, w11 lsl w9, w9, #9 tst w8, #0x400000 csel w8, w9, w10, eq asr w0, w8, #9 ret
arm64	23	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return subu<23>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x7fffff ret
arm64	24	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return subs<24>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 lsr w10, w0, #15 and w10, w10, #0x100 mov w11, #2147483392 add w10, w10, w11 lsl w9, w9, #8 tst w8, #0x800000 csel w8, w9, w10, eq asr w0, w8, #8 ret
arm64	24	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return subu<24>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0xffffff ret
arm64	25	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return subs<25>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #24, #1 mov w11, #16777215 add w10, w10, w11 tst w8, #0x1000000 csel w8, w9, w10, eq sbfx w0, w8, #0, #25 ret
arm64	25	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return subu<25>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x1ffffff ret
arm64	26	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return subs<26>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #25, #1 mov w11, #33554431 add w10, w10, w11 tst w8, #0x2000000 csel w8, w9, w10, eq sbfx w0, w8, #0, #26 ret
arm64	26	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return subu<26>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x3ffffff ret
arm64	27	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return subs<27>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #26, #1 mov w11, #67108863 add w10, w10, w11 tst w8, #0x4000000 csel w8, w9, w10, eq sbfx w0, w8, #0, #27 ret
arm64	27	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return subu<27>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x7ffffff ret
arm64	28	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return subs<28>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #27, #1 mov w11, #134217727 add w10, w10, w11 tst w8, #0x8000000 csel w8, w9, w10, eq sbfx w0, w8, #0, #28 ret
arm64	28	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return subu<28>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0xfffffff ret
arm64	29	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return subs<29>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #28, #1 mov w11, #268435455 add w10, w10, w11 tst w8, #0x10000000 csel w8, w9, w10, eq sbfx w0, w8, #0, #29 ret
arm64	29	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return subu<29>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x1fffffff ret
arm64	30	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return subs<30>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #29, #1 mov w11, #536870911 add w10, w10, w11 tst w8, #0x20000000 csel w8, w9, w10, eq sbfx w0, w8, #0, #30 ret
arm64	30	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return subu<30>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x3fffffff ret
arm64	31	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return subs<31>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 and w8, w8, w10 ubfx w10, w0, #30, #1 mov w11, #1073741823 add w10, w10, w11 tst w8, #0x40000000 csel w8, w9, w10, eq sbfx w0, w8, #0, #31 ret
arm64	31	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return subu<31>(a, b); }	_f: ; @f subs w8, w0, w1 csel w8, wzr, w8, lo and w0, w8, #0x7fffffff ret
arm64	32	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return subs<32>(a, b); }	_f: ; @f eor w8, w1, w0 sub w9, w0, w1 eor w10, w9, w0 mov w11, #2147483647 add w11, w11, w0, lsr #31 tst w10, w8 csel w0, w11, w9, lt ret
arm64	32	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return subu<32>(a, b); }	_f: ; @f subs w8, w0, w1 csel w0, wzr, w8, lo ret
arm64	33	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return subs<33>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #1 and x10, x10, #0x80000000 mov x11, #9223372034707292160 add x10, x10, x11 lsl x9, x9, #31 tst x8, #0x100000000 csel x8, x9, x10, eq asr x0, x8, #31 ret
arm64	33	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return subu<33>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1ffffffff ret
arm64	34	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return subs<34>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #3 and x10, x10, #0x40000000 mov x11, #9223372035781033984 add x10, x10, x11 lsl x9, x9, #30 tst x8, #0x200000000 csel x8, x9, x10, eq asr x0, x8, #30 ret
arm64	34	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return subu<34>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3ffffffff ret
arm64	35	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return subs<35>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #5 and x10, x10, #0x20000000 mov x11, #9223372036317904896 add x10, x10, x11 lsl x9, x9, #29 tst x8, #0x400000000 csel x8, x9, x10, eq asr x0, x8, #29 ret
arm64	35	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return subu<35>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7ffffffff ret
arm64	36	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return subs<36>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #7 and x10, x10, #0x10000000 mov x11, #9223372036586340352 add x10, x10, x11 lsl x9, x9, #28 tst x8, #0x800000000 csel x8, x9, x10, eq asr x0, x8, #28 ret
arm64	36	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return subu<36>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0xfffffffff ret
arm64	37	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return subs<37>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #9 and x10, x10, #0x8000000 mov x11, #9223372036720558080 add x10, x10, x11 lsl x9, x9, #27 tst x8, #0x1000000000 csel x8, x9, x10, eq asr x0, x8, #27 ret
arm64	37	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return subu<37>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1fffffffff ret
arm64	38	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return subs<38>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #11 and x10, x10, #0x4000000 mov x11, #9223372036787666944 add x10, x10, x11 lsl x9, x9, #26 tst x8, #0x2000000000 csel x8, x9, x10, eq asr x0, x8, #26 ret
arm64	38	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return subu<38>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3fffffffff ret
arm64	39	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return subs<39>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #13 and x10, x10, #0x2000000 mov x11, #9223372036821221376 add x10, x10, x11 lsl x9, x9, #25 tst x8, #0x4000000000 csel x8, x9, x10, eq asr x0, x8, #25 ret
arm64	39	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return subu<39>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7fffffffff ret
arm64	40	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return subs<40>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #15 and x10, x10, #0x1000000 mov x11, #9223372036837998592 add x10, x10, x11 lsl x9, x9, #24 tst x8, #0x8000000000 csel x8, x9, x10, eq asr x0, x8, #24 ret
arm64	40	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return subu<40>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0xffffffffff ret
arm64	41	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return subs<41>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #17 and x10, x10, #0x800000 mov x11, #9223372036846387200 add x10, x10, x11 lsl x9, x9, #23 tst x8, #0x10000000000 csel x8, x9, x10, eq asr x0, x8, #23 ret
arm64	41	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return subu<41>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1ffffffffff ret
arm64	42	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return subs<42>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #19 and x10, x10, #0x400000 mov x11, #9223372036850581504 add x10, x10, x11 lsl x9, x9, #22 tst x8, #0x20000000000 csel x8, x9, x10, eq asr x0, x8, #22 ret
arm64	42	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return subu<42>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3ffffffffff ret
arm64	43	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return subs<43>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #21 and x10, x10, #0x200000 mov x11, #9223372036852678656 add x10, x10, x11 lsl x9, x9, #21 tst x8, #0x40000000000 csel x8, x9, x10, eq asr x0, x8, #21 ret
arm64	43	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return subu<43>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7ffffffffff ret
arm64	44	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return subs<44>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #23 and x10, x10, #0x100000 mov x11, #9223372036853727232 add x10, x10, x11 lsl x9, x9, #20 tst x8, #0x80000000000 csel x8, x9, x10, eq asr x0, x8, #20 ret
arm64	44	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return subu<44>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0xfffffffffff ret
arm64	45	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return subs<45>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #25 and x10, x10, #0x80000 mov x11, #9223372036854251520 add x10, x10, x11 lsl x9, x9, #19 tst x8, #0x100000000000 csel x8, x9, x10, eq asr x0, x8, #19 ret
arm64	45	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return subu<45>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1fffffffffff ret
arm64	46	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return subs<46>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #27 and x10, x10, #0x40000 mov x11, #9223372036854513664 add x10, x10, x11 lsl x9, x9, #18 tst x8, #0x200000000000 csel x8, x9, x10, eq asr x0, x8, #18 ret
arm64	46	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return subu<46>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3fffffffffff ret
arm64	47	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return subs<47>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #29 and x10, x10, #0x20000 mov x11, #9223372036854644736 add x10, x10, x11 lsl x9, x9, #17 tst x8, #0x400000000000 csel x8, x9, x10, eq asr x0, x8, #17 ret
arm64	47	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return subu<47>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7fffffffffff ret
arm64	48	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return subs<48>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #31 and x10, x10, #0x10000 mov x11, #9223372036854710272 add x10, x10, x11 lsl x9, x9, #16 tst x8, #0x800000000000 csel x8, x9, x10, eq asr x0, x8, #16 ret
arm64	48	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return subu<48>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0xffffffffffff ret
arm64	49	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return subs<49>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #33 and x10, x10, #0x8000 mov x11, #9223372036854743040 add x10, x10, x11 lsl x9, x9, #15 tst x8, #0x1000000000000 csel x8, x9, x10, eq asr x0, x8, #15 ret
arm64	49	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return subu<49>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1ffffffffffff ret
arm64	50	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return subs<50>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #35 and x10, x10, #0x4000 mov x11, #9223372036854759424 add x10, x10, x11 lsl x9, x9, #14 tst x8, #0x2000000000000 csel x8, x9, x10, eq asr x0, x8, #14 ret
arm64	50	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return subu<50>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3ffffffffffff ret
arm64	51	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return subs<51>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #37 and x10, x10, #0x2000 mov x11, #9223372036854767616 add x10, x10, x11 lsl x9, x9, #13 tst x8, #0x4000000000000 csel x8, x9, x10, eq asr x0, x8, #13 ret
arm64	51	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return subu<51>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7ffffffffffff ret
arm64	52	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return subs<52>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #39 and x10, x10, #0x1000 mov x11, #9223372036854771712 add x10, x10, x11 lsl x9, x9, #12 tst x8, #0x8000000000000 csel x8, x9, x10, eq asr x0, x8, #12 ret
arm64	52	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return subu<52>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0xfffffffffffff ret
arm64	53	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return subs<53>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #41 and x10, x10, #0x800 mov x11, #9223372036854773760 add x10, x10, x11 lsl x9, x9, #11 tst x8, #0x10000000000000 csel x8, x9, x10, eq asr x0, x8, #11 ret
arm64	53	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return subu<53>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1fffffffffffff ret
arm64	54	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return subs<54>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #43 and x10, x10, #0x400 mov x11, #9223372036854774784 add x10, x10, x11 lsl x9, x9, #10 tst x8, #0x20000000000000 csel x8, x9, x10, eq asr x0, x8, #10 ret
arm64	54	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return subu<54>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3fffffffffffff ret
arm64	55	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return subs<55>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #45 and x10, x10, #0x200 mov x11, #9223372036854775296 add x10, x10, x11 lsl x9, x9, #9 tst x8, #0x40000000000000 csel x8, x9, x10, eq asr x0, x8, #9 ret
arm64	55	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return subu<55>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7fffffffffffff ret
arm64	56	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return subs<56>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 lsr x10, x0, #47 and x10, x10, #0x100 mov x11, #9223372036854775552 add x10, x10, x11 lsl x9, x9, #8 tst x8, #0x80000000000000 csel x8, x9, x10, eq asr x0, x8, #8 ret
arm64	56	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return subu<56>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0xffffffffffffff ret
arm64	57	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return subs<57>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 ubfx x10, x0, #56, #1 mov x11, #72057594037927935 add x10, x10, x11 tst x8, #0x100000000000000 csel x8, x9, x10, eq sbfx x0, x8, #0, #57 ret
arm64	57	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return subu<57>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1ffffffffffffff ret
arm64	58	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return subs<58>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 ubfx x10, x0, #57, #1 mov x11, #144115188075855871 add x10, x10, x11 tst x8, #0x200000000000000 csel x8, x9, x10, eq sbfx x0, x8, #0, #58 ret
arm64	58	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return subu<58>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3ffffffffffffff ret
arm64	59	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return subs<59>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 ubfx x10, x0, #58, #1 mov x11, #288230376151711743 add x10, x10, x11 tst x8, #0x400000000000000 csel x8, x9, x10, eq sbfx x0, x8, #0, #59 ret
arm64	59	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return subu<59>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7ffffffffffffff ret
arm64	60	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return subs<60>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 ubfx x10, x0, #59, #1 mov x11, #576460752303423487 add x10, x10, x11 tst x8, #0x800000000000000 csel x8, x9, x10, eq sbfx x0, x8, #0, #60 ret
arm64	60	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return subu<60>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0xfffffffffffffff ret
arm64	61	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return subs<61>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 ubfx x10, x0, #60, #1 mov x11, #1152921504606846975 add x10, x10, x11 tst x8, #0x1000000000000000 csel x8, x9, x10, eq sbfx x0, x8, #0, #61 ret
arm64	61	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return subu<61>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x1fffffffffffffff ret
arm64	62	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return subs<62>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 ubfx x10, x0, #61, #1 mov x11, #2305843009213693951 add x10, x10, x11 tst x8, #0x2000000000000000 csel x8, x9, x10, eq sbfx x0, x8, #0, #62 ret
arm64	62	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return subu<62>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x3fffffffffffffff ret
arm64	63	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return subs<63>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 and x8, x8, x10 ubfx x10, x0, #62, #1 mov x11, #4611686018427387903 add x10, x10, x11 tst x8, #0x4000000000000000 csel x8, x9, x10, eq sbfx x0, x8, #0, #63 ret
arm64	63	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return subu<63>(a, b); }	_f: ; @f subs x8, x0, x1 csel x8, xzr, x8, lo and x0, x8, #0x7fffffffffffffff ret
arm64	64	sub	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return subs<64>(a, b); }	_f: ; @f eor x8, x1, x0 sub x9, x0, x1 eor x10, x9, x0 mov x11, #9223372036854775807 add x11, x11, x0, lsr #63 tst x10, x8 csel x0, x11, x9, lt ret
arm64	64	sub	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return subu<64>(a, b); }	_f: ; @f subs x8, x0, x1 csel x0, xzr, x8, lo ret
arm64	4	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return muls<4>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #4 sxtb w10, w8 ubfx w10, w10, #3, #8 eor w11, w1, w0 lsl w11, w11, #1 and w11, w11, #0x10 add w11, w11, #112 sbfx w11, w11, #4, #4 cmp w10, w9, uxtb csel w8, w8, w11, eq sxtb w0, w8 ret
arm64	4	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return mulu<4>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0xf tst w8, #0xff0 mov w8, #15 csel w0, w9, w8, eq ret
arm64	5	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return muls<5>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #5 sxtb w10, w8 ubfx w10, w10, #4, #8 eor w11, w1, w0 lsr w11, w11, #1 and w11, w11, #0x8 add w11, w11, #120 sbfx w11, w11, #3, #5 cmp w10, w9, uxtb csel w8, w8, w11, eq sxtb w0, w8 ret
arm64	5	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return mulu<5>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x1f tst w8, #0x1fe0 mov w8, #31 csel w0, w9, w8, eq ret
arm64	6	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return muls<6>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #6 sxtb w10, w8 ubfx w10, w10, #5, #8 eor w11, w1, w0 lsr w11, w11, #3 and w11, w11, #0x4 add w11, w11, #124 sbfx w11, w11, #2, #6 cmp w10, w9, uxtb csel w8, w8, w11, eq sxtb w0, w8 ret
arm64	6	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return mulu<6>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x3f tst w8, #0x3fc0 mov w8, #63 csel w0, w9, w8, eq ret
arm64	7	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return muls<7>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #7 sxtb w10, w8 ubfx w10, w10, #6, #8 eor w11, w1, w0 lsr w11, w11, #5 and w11, w11, #0x2 add w11, w11, #126 sbfx w11, w11, #1, #7 cmp w10, w9, uxtb csel w8, w8, w11, eq sxtb w0, w8 ret
arm64	7	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return mulu<7>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x7f tst w8, #0x7f80 mov w8, #127 csel w0, w9, w8, eq ret
arm64	8	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return muls<8>(a, b); }	_f: ; @f mul w8, w1, w0 rev w8, w8 lsr w9, w8, #16 asr w10, w8, #16 lsr w8, w8, #24 ubfx w10, w10, #15, #8 eor w11, w1, w0 ubfx w11, w11, #7, #1 add w11, w11, #127 cmp w10, w9, uxtb csel w8, w8, w11, eq sxtb w0, w8 ret
arm64	8	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return mulu<8>(a, b); }	_f: ; @f mul w8, w1, w0 rev w8, w8 lsr w9, w8, #24 mov w10, #255 tst w10, w8, ror #16 csinv w8, w9, wzr, eq and w0, w8, #0xff ret
arm64	9	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return muls<9>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #9 sxth w10, w8 ubfx w10, w10, #8, #16 cmp w10, w9, uxth eor w9, w1, w0 lsr w9, w9, #1 and w9, w9, #0x80 mov w10, #32640 add w9, w9, w10 sbfx w9, w9, #7, #9 csel w8, w8, w9, eq sxth w0, w8 ret
arm64	9	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return mulu<9>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x1ff tst w8, #0x1fffe00 mov w8, #511 csel w0, w9, w8, eq ret
arm64	10	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return muls<10>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #10 sxth w10, w8 ubfx w10, w10, #9, #16 cmp w10, w9, uxth eor w9, w1, w0 lsr w9, w9, #3 and w9, w9, #0x40 mov w10, #32704 add w9, w9, w10 sbfx w9, w9, #6, #10 csel w8, w8, w9, eq sxth w0, w8 ret
arm64	10	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return mulu<10>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x3ff tst w8, #0x3fffc00 mov w8, #1023 csel w0, w9, w8, eq ret
arm64	11	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return muls<11>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #11 sxth w10, w8 ubfx w10, w10, #10, #16 cmp w10, w9, uxth eor w9, w1, w0 lsr w9, w9, #5 and w9, w9, #0x20 mov w10, #32736 add w9, w9, w10 sbfx w9, w9, #5, #11 csel w8, w8, w9, eq sxth w0, w8 ret
arm64	11	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return mulu<11>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x7ff tst w8, #0x7fff800 mov w8, #2047 csel w0, w9, w8, eq ret
arm64	12	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return muls<12>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #12 sxth w10, w8 ubfx w10, w10, #11, #16 cmp w10, w9, uxth eor w9, w1, w0 lsr w9, w9, #7 and w9, w9, #0x10 mov w10, #32752 add w9, w9, w10 sbfx w9, w9, #4, #12 csel w8, w8, w9, eq sxth w0, w8 ret
arm64	12	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return mulu<12>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0xfff tst w8, #0xffff000 mov w8, #4095 csel w0, w9, w8, eq ret
arm64	13	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return muls<13>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #13 sxth w10, w8 ubfx w10, w10, #12, #16 cmp w10, w9, uxth eor w9, w1, w0 lsr w9, w9, #9 and w9, w9, #0x8 mov w10, #32760 add w9, w9, w10 sbfx w9, w9, #3, #13 csel w8, w8, w9, eq sxth w0, w8 ret
arm64	13	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return mulu<13>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x1fff tst w8, #0x1fffe000 mov w8, #8191 csel w0, w9, w8, eq ret
arm64	14	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return muls<14>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #14 sxth w10, w8 ubfx w10, w10, #13, #16 cmp w10, w9, uxth eor w9, w1, w0 lsr w9, w9, #11 and w9, w9, #0x4 mov w10, #32764 add w9, w9, w10 sbfx w9, w9, #2, #14 csel w8, w8, w9, eq sxth w0, w8 ret
arm64	14	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return mulu<14>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x3fff tst w8, #0x3fffc000 mov w8, #16383 csel w0, w9, w8, eq ret
arm64	15	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return muls<15>(a, b); }	_f: ; @f mul w8, w1, w0 lsr w9, w8, #15 sxth w10, w8 ubfx w10, w10, #14, #16 cmp w10, w9, uxth eor w9, w1, w0 lsr w9, w9, #13 and w9, w9, #0x2 mov w10, #32766 add w9, w9, w10 sbfx w9, w9, #1, #15 csel w8, w8, w9, eq sxth w0, w8 ret
arm64	15	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return mulu<15>(a, b); }	_f: ; @f mul w8, w1, w0 and w9, w8, #0x7fff tst w8, #0x7fff8000 mov w8, #32767 csel w0, w9, w8, eq ret
arm64	16	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return muls<16>(a, b); }	_f: ; @f mul w8, w1, w0 ror w8, w8, #16 lsr w9, w8, #16 asr w10, w8, #31 and w10, w10, #0xffff eor w11, w1, w0 and w11, w11, #0x8000 mov w12, #32767 add w11, w12, w11, lsr #15 cmp w10, w8, uxth csel w8, w9, w11, eq sxth w0, w8 ret
arm64	16	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return mulu<16>(a, b); }	_f: ; @f mul w8, w1, w0 ror w8, w8, #16 lsr w9, w8, #16 tst w8, #0xffff csinv w8, w9, wzr, eq and w0, w8, #0xffff ret
arm64	17	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return muls<17>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #17 cmp w9, w8, asr #16 eor w9, w1, w0 lsr w9, w9, #1 and w9, w9, #0x8000 mov w10, #2147450880 add w9, w9, w10 asr w9, w9, #15 csel w0, w8, w9, eq ret
arm64	17	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return mulu<17>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x1ffff tst x8, #0x1fffffffe0000 mov w8, #131071 csel w0, w9, w8, eq ret
arm64	18	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return muls<18>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #18 cmp w9, w8, asr #17 eor w9, w1, w0 lsr w9, w9, #3 and w9, w9, #0x4000 mov w10, #2147467264 add w9, w9, w10 asr w9, w9, #14 csel w0, w8, w9, eq ret
arm64	18	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return mulu<18>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x3ffff tst x8, #0x3fffffffc0000 mov w8, #262143 csel w0, w9, w8, eq ret
arm64	19	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return muls<19>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #19 cmp w9, w8, asr #18 eor w9, w1, w0 lsr w9, w9, #5 and w9, w9, #0x2000 mov w10, #2147475456 add w9, w9, w10 asr w9, w9, #13 csel w0, w8, w9, eq ret
arm64	19	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return mulu<19>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x7ffff tst x8, #0x7fffffff80000 mov w8, #524287 csel w0, w9, w8, eq ret
arm64	20	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return muls<20>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #20 cmp w9, w8, asr #19 eor w9, w1, w0 lsr w9, w9, #7 and w9, w9, #0x1000 mov w10, #2147479552 add w9, w9, w10 asr w9, w9, #12 csel w0, w8, w9, eq ret
arm64	20	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return mulu<20>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0xfffff tst x8, #0xffffffff00000 mov w8, #1048575 csel w0, w9, w8, eq ret
arm64	21	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return muls<21>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #21 cmp w9, w8, asr #20 eor w9, w1, w0 lsr w9, w9, #9 and w9, w9, #0x800 mov w10, #2147481600 add w9, w9, w10 asr w9, w9, #11 csel w0, w8, w9, eq ret
arm64	21	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return mulu<21>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x1fffff tst x8, #0x1fffffffe00000 mov w8, #2097151 csel w0, w9, w8, eq ret
arm64	22	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return muls<22>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #22 cmp w9, w8, asr #21 eor w9, w1, w0 lsr w9, w9, #11 and w9, w9, #0x400 mov w10, #2147482624 add w9, w9, w10 asr w9, w9, #10 csel w0, w8, w9, eq ret
arm64	22	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return mulu<22>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x3fffff tst x8, #0x3fffffffc00000 mov w8, #4194303 csel w0, w9, w8, eq ret
arm64	23	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return muls<23>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #23 cmp w9, w8, asr #22 eor w9, w1, w0 lsr w9, w9, #13 and w9, w9, #0x200 mov w10, #2147483136 add w9, w9, w10 asr w9, w9, #9 csel w0, w8, w9, eq ret
arm64	23	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return mulu<23>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x7fffff tst x8, #0x7fffffff800000 mov w8, #8388607 csel w0, w9, w8, eq ret
arm64	24	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return muls<24>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #24 cmp w9, w8, asr #23 eor w9, w1, w0 lsr w9, w9, #15 and w9, w9, #0x100 mov w10, #2147483392 add w9, w9, w10 asr w9, w9, #8 csel w0, w8, w9, eq ret
arm64	24	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return mulu<24>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0xffffff tst x8, #0xffffffff000000 mov w8, #16777215 csel w0, w9, w8, eq ret
arm64	25	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return muls<25>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #25 cmp w9, w8, asr #24 eor w9, w1, w0 lsr w9, w9, #17 and w9, w9, #0x80 mov w10, #2147483520 add w9, w9, w10 asr w9, w9, #7 csel w0, w8, w9, eq ret
arm64	25	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return mulu<25>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x1ffffff tst x8, #0x1fffffffe000000 mov w8, #33554431 csel w0, w9, w8, eq ret
arm64	26	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return muls<26>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #26 cmp w9, w8, asr #25 eor w9, w1, w0 lsr w9, w9, #19 and w9, w9, #0x40 mov w10, #2147483584 add w9, w9, w10 asr w9, w9, #6 csel w0, w8, w9, eq ret
arm64	26	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return mulu<26>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x3ffffff tst x8, #0x3fffffffc000000 mov w8, #67108863 csel w0, w9, w8, eq ret
arm64	27	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return muls<27>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #27 cmp w9, w8, asr #26 eor w9, w1, w0 lsr w9, w9, #21 and w9, w9, #0x20 mov w10, #2147483616 add w9, w9, w10 asr w9, w9, #5 csel w0, w8, w9, eq ret
arm64	27	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return mulu<27>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x7ffffff tst x8, #0x7fffffff8000000 mov w8, #134217727 csel w0, w9, w8, eq ret
arm64	28	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return muls<28>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #28 cmp w9, w8, asr #27 eor w9, w1, w0 lsr w9, w9, #23 and w9, w9, #0x10 mov w10, #2147483632 add w9, w9, w10 asr w9, w9, #4 csel w0, w8, w9, eq ret
arm64	28	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return mulu<28>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0xfffffff tst x8, #0xffffffff0000000 mov w8, #268435455 csel w0, w9, w8, eq ret
arm64	29	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return muls<29>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #29 cmp w9, w8, asr #28 eor w9, w1, w0 lsr w9, w9, #25 and w9, w9, #0x8 mov w10, #2147483640 add w9, w9, w10 asr w9, w9, #3 csel w0, w8, w9, eq ret
arm64	29	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return mulu<29>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x1fffffff tst x8, #0x1fffffffe0000000 mov w8, #536870911 csel w0, w9, w8, eq ret
arm64	30	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return muls<30>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #30 cmp w9, w8, asr #29 eor w9, w1, w0 lsr w9, w9, #27 and w9, w9, #0x4 mov w10, #2147483644 add w9, w9, w10 asr w9, w9, #2 csel w0, w8, w9, eq ret
arm64	30	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return mulu<30>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x3fffffff tst x8, #0x3fffffffc0000000 mov w8, #1073741823 csel w0, w9, w8, eq ret
arm64	31	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return muls<31>(a, b); }	_f: ; @f smull x8, w1, w0 lsr x9, x8, #31 cmp w9, w8, asr #30 eor w9, w1, w0 lsr w9, w9, #29 and w9, w9, #0x2 mov w10, #2147483646 add w9, w9, w10 asr w9, w9, #1 csel w0, w8, w9, eq ret
arm64	31	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return mulu<31>(a, b); }	_f: ; @f umull x8, w1, w0 and w9, w8, #0x7fffffff tst x8, #0x7fffffff80000000 mov w8, #2147483647 csel w0, w9, w8, eq ret
arm64	32	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return muls<32>(a, b); }	_f: ; @f smull x8, w1, w0 ror x8, x8, #32 lsr x9, x8, #32 eor w10, w1, w0 mov w11, #2147483647 add w10, w11, w10, lsr #31 cmp w8, w9, asr #31 csel w0, w9, w10, eq ret
arm64	32	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return mulu<32>(a, b); }	_f: ; @f umull x8, w1, w0 ror x8, x8, #32 lsr x9, x8, #32 cmp w8, #0 csinv w0, w9, wzr, eq ret
arm64	33	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return muls<33>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #33 lsl x9, x12, #31 eor x10, x1, x0 lsr x10, x10, #1 and x10, x10, #0x80000000 mov x11, #9223372034707292160 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #31 ret
arm64	33	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return mulu<33>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #33 and x10, x12, #0xffffffff bfi x10, x9, #32, #1 mov x9, #8589934591 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	34	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return muls<34>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #34 lsl x9, x12, #30 eor x10, x1, x0 lsr x10, x10, #3 and x10, x10, #0x40000000 mov x11, #9223372035781033984 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #30 ret
arm64	34	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return mulu<34>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #34 and x10, x12, #0xffffffff bfi x10, x9, #32, #2 mov x9, #17179869183 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	35	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return muls<35>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #35 lsl x9, x12, #29 eor x10, x1, x0 lsr x10, x10, #5 and x10, x10, #0x20000000 mov x11, #9223372036317904896 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #29 ret
arm64	35	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return mulu<35>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #35 and x10, x12, #0xffffffff bfi x10, x9, #32, #3 mov x9, #34359738367 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	36	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return muls<36>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #36 lsl x9, x12, #28 eor x10, x1, x0 lsr x10, x10, #7 and x10, x10, #0x10000000 mov x11, #9223372036586340352 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #28 ret
arm64	36	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return mulu<36>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #36 and x10, x12, #0xffffffff bfi x10, x9, #32, #4 mov x9, #68719476735 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	37	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return muls<37>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #37 lsl x9, x12, #27 eor x10, x1, x0 lsr x10, x10, #9 and x10, x10, #0x8000000 mov x11, #9223372036720558080 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #27 ret
arm64	37	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return mulu<37>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #37 and x10, x12, #0xffffffff bfi x10, x9, #32, #5 mov x9, #137438953471 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	38	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return muls<38>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #38 lsl x9, x12, #26 eor x10, x1, x0 lsr x10, x10, #11 and x10, x10, #0x4000000 mov x11, #9223372036787666944 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #26 ret
arm64	38	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return mulu<38>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #38 and x10, x12, #0xffffffff bfi x10, x9, #32, #6 mov x9, #274877906943 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	39	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return muls<39>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #39 lsl x9, x12, #25 eor x10, x1, x0 lsr x10, x10, #13 and x10, x10, #0x2000000 mov x11, #9223372036821221376 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #25 ret
arm64	39	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return mulu<39>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #39 and x10, x12, #0xffffffff bfi x10, x9, #32, #7 mov x9, #549755813887 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	40	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return muls<40>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #40 lsl x9, x12, #24 eor x10, x1, x0 lsr x10, x10, #15 and x10, x10, #0x1000000 mov x11, #9223372036837998592 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #24 ret
arm64	40	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return mulu<40>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #40 and x10, x12, #0xffffffff bfi x10, x9, #32, #8 mov x9, #1099511627775 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	41	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return muls<41>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #41 lsl x9, x12, #23 eor x10, x1, x0 lsr x10, x10, #17 and x10, x10, #0x800000 mov x11, #9223372036846387200 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #23 ret
arm64	41	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return mulu<41>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #41 and x10, x12, #0xffffffff bfi x10, x9, #32, #9 mov x9, #2199023255551 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	42	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return muls<42>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #42 lsl x9, x12, #22 eor x10, x1, x0 lsr x10, x10, #19 and x10, x10, #0x400000 mov x11, #9223372036850581504 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #22 ret
arm64	42	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return mulu<42>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #42 and x10, x12, #0xffffffff bfi x10, x9, #32, #10 mov x9, #4398046511103 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	43	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return muls<43>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #43 lsl x9, x12, #21 eor x10, x1, x0 lsr x10, x10, #21 and x10, x10, #0x200000 mov x11, #9223372036852678656 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #21 ret
arm64	43	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return mulu<43>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #43 and x10, x12, #0xffffffff bfi x10, x9, #32, #11 mov x9, #8796093022207 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	44	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return muls<44>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #44 lsl x9, x12, #20 eor x10, x1, x0 lsr x10, x10, #23 and x10, x10, #0x100000 mov x11, #9223372036853727232 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #20 ret
arm64	44	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return mulu<44>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #44 and x10, x12, #0xffffffff bfi x10, x9, #32, #12 mov x9, #17592186044415 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	45	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return muls<45>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #45 lsl x9, x12, #19 eor x10, x1, x0 lsr x10, x10, #25 and x10, x10, #0x80000 mov x11, #9223372036854251520 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #19 ret
arm64	45	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return mulu<45>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #45 and x10, x12, #0xffffffff bfi x10, x9, #32, #13 mov x9, #35184372088831 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	46	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return muls<46>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #46 lsl x9, x12, #18 eor x10, x1, x0 lsr x10, x10, #27 and x10, x10, #0x40000 mov x11, #9223372036854513664 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #18 ret
arm64	46	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return mulu<46>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #46 and x10, x12, #0xffffffff bfi x10, x9, #32, #14 mov x9, #70368744177663 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	47	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return muls<47>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #47 lsl x9, x12, #17 eor x10, x1, x0 lsr x10, x10, #29 and x10, x10, #0x20000 mov x11, #9223372036854644736 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #17 ret
arm64	47	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return mulu<47>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #47 and x10, x12, #0xffffffff bfi x10, x9, #32, #15 mov x9, #140737488355327 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	48	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return muls<48>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #48 lsl x9, x12, #16 eor x10, x1, x0 lsr x10, x10, #31 and x10, x10, #0x10000 mov x11, #9223372036854710272 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #16 ret
arm64	48	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return mulu<48>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #48 and x10, x12, #0xffffffff bfi x10, x9, #32, #16 mov x9, #281474976710655 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	49	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return muls<49>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #49 lsl x9, x12, #15 eor x10, x1, x0 lsr x10, x10, #33 and x10, x10, #0x8000 mov x11, #9223372036854743040 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #15 ret
arm64	49	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return mulu<49>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #49 and x10, x12, #0xffffffff bfi x10, x9, #32, #17 mov x9, #562949953421311 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	50	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return muls<50>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #50 lsl x9, x12, #14 eor x10, x1, x0 lsr x10, x10, #35 and x10, x10, #0x4000 mov x11, #9223372036854759424 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #14 ret
arm64	50	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return mulu<50>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #50 and x10, x12, #0xffffffff bfi x10, x9, #32, #18 mov x9, #1125899906842623 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	51	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return muls<51>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #51 lsl x9, x12, #13 eor x10, x1, x0 lsr x10, x10, #37 and x10, x10, #0x2000 mov x11, #9223372036854767616 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #13 ret
arm64	51	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return mulu<51>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #51 and x10, x12, #0xffffffff bfi x10, x9, #32, #19 mov x9, #2251799813685247 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	52	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return muls<52>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #52 lsl x9, x12, #12 eor x10, x1, x0 lsr x10, x10, #39 and x10, x10, #0x1000 mov x11, #9223372036854771712 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #12 ret
arm64	52	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return mulu<52>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #52 and x10, x12, #0xffffffff bfi x10, x9, #32, #20 mov x9, #4503599627370495 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	53	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return muls<53>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #53 lsl x9, x12, #11 eor x10, x1, x0 lsr x10, x10, #41 and x10, x10, #0x800 mov x11, #9223372036854773760 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #11 ret
arm64	53	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return mulu<53>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #53 and x10, x12, #0xffffffff bfi x10, x9, #32, #21 mov x9, #9007199254740991 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	54	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return muls<54>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #54 lsl x9, x12, #10 eor x10, x1, x0 lsr x10, x10, #43 and x10, x10, #0x400 mov x11, #9223372036854774784 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #10 ret
arm64	54	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return mulu<54>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #54 and x10, x12, #0xffffffff bfi x10, x9, #32, #22 mov x9, #18014398509481983 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	55	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return muls<55>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #55 lsl x9, x12, #9 eor x10, x1, x0 lsr x10, x10, #45 and x10, x10, #0x200 mov x11, #9223372036854775296 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #9 ret
arm64	55	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return mulu<55>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #55 and x10, x12, #0xffffffff bfi x10, x9, #32, #23 mov x9, #36028797018963967 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	56	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return muls<56>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #56 lsl x9, x12, #8 eor x10, x1, x0 lsr x10, x10, #47 and x10, x10, #0x100 mov x11, #9223372036854775552 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #8 ret
arm64	56	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return mulu<56>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #56 and x10, x12, #0xffffffff bfi x10, x9, #32, #24 mov x9, #72057594037927935 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	57	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return muls<57>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #57 lsl x9, x12, #7 eor x10, x1, x0 lsr x10, x10, #49 and x10, x10, #0x80 mov x11, #9223372036854775680 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #7 ret
arm64	57	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return mulu<57>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #57 and x10, x12, #0xffffffff bfi x10, x9, #32, #25 mov x9, #144115188075855871 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	58	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return muls<58>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #58 lsl x9, x12, #6 eor x10, x1, x0 lsr x10, x10, #51 and x10, x10, #0x40 mov x11, #9223372036854775744 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #6 ret
arm64	58	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return mulu<58>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #58 and x10, x12, #0xffffffff bfi x10, x9, #32, #26 mov x9, #288230376151711743 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	59	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return muls<59>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #59 lsl x9, x12, #5 eor x10, x1, x0 lsr x10, x10, #53 and x10, x10, #0x20 mov x11, #9223372036854775776 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #5 ret
arm64	59	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return mulu<59>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #59 and x10, x12, #0xffffffff bfi x10, x9, #32, #27 mov x9, #576460752303423487 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	60	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return muls<60>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #60 lsl x9, x12, #4 eor x10, x1, x0 lsr x10, x10, #55 and x10, x10, #0x10 mov x11, #9223372036854775792 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #4 ret
arm64	60	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return mulu<60>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #60 and x10, x12, #0xffffffff bfi x10, x9, #32, #28 mov x9, #1152921504606846975 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	61	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return muls<61>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #61 lsl x9, x12, #3 eor x10, x1, x0 lsr x10, x10, #57 and x10, x10, #0x8 mov x11, #9223372036854775800 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #3 ret
arm64	61	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return mulu<61>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #61 and x10, x12, #0xffffffff bfi x10, x9, #32, #29 mov x9, #2305843009213693951 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	62	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return muls<62>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #62 lsl x9, x12, #2 eor x10, x1, x0 lsr x10, x10, #59 and x10, x10, #0x4 mov x11, #9223372036854775804 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #2 ret
arm64	62	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return mulu<62>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #62 and x10, x12, #0xffffffff bfi x10, x9, #32, #30 mov x9, #4611686018427387903 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	63	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return muls<63>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 extr x8, x8, x10, #63 lsl x9, x12, #1 eor x10, x1, x0 lsr x10, x10, #61 and x10, x10, #0x2 mov x11, #9223372036854775806 add x10, x10, x11 cmp x8, x9, asr #63 csel x8, x9, x10, eq asr x0, x8, #1 ret
arm64	63	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return mulu<63>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 add x8, x8, x9, lsr #32 lsl x10, x9, #32 extr x8, x8, x10, #63 and x10, x12, #0xffffffff bfi x10, x9, #32, #31 mov x9, #9223372036854775807 cmp x8, #0 csel x0, x10, x9, eq ret
arm64	64	mul	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return muls<64>(a, b); }	_f: ; @f asr x8, x0, #32 and x9, x0, #0xffffffff asr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, asr #32 add x8, x8, x9, asr #32 lsl x10, x9, #32 bfi x12, x9, #32, #32 eor x9, x1, x0 mov x11, #9223372036854775807 add x9, x11, x9, lsr #63 cmp x8, x10, asr #63 csel x0, x12, x9, eq ret
arm64	64	mul	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return mulu<64>(a, b); }	_f: ; @f lsr x8, x0, #32 and x9, x0, #0xffffffff lsr x10, x1, #32 and x11, x1, #0xffffffff umull x12, w1, w0 mul x11, x11, x8 add x11, x11, x12, lsr #32 mul x9, x10, x9 add x9, x9, w11, uxtw mul x8, x10, x8 add x8, x8, x11, lsr #32 bfi x12, x9, #32, #32 cmn x8, x9, lsr #32 csinv x0, x12, xzr, eq ret
arm64	4	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<4> f (sinteger_t<4> a, sinteger_t<4> b) { return divs<4>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #8 orr w8, w8, w9 tst w8, #0xf cinc w8, w0, eq sdiv w8, w8, w1 sxtb w0, w8 ret
arm64	4	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<4> f (uinteger_t<4> a, uinteger_t<4> b) { return divu<4>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	5	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<5> f (sinteger_t<5> a, sinteger_t<5> b) { return divs<5>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #16 orr w8, w8, w9 tst w8, #0x1f cinc w8, w0, eq sdiv w8, w8, w1 sxtb w0, w8 ret
arm64	5	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<5> f (uinteger_t<5> a, uinteger_t<5> b) { return divu<5>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	6	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<6> f (sinteger_t<6> a, sinteger_t<6> b) { return divs<6>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #32 orr w8, w8, w9 tst w8, #0x3f cinc w8, w0, eq sdiv w8, w8, w1 sxtb w0, w8 ret
arm64	6	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<6> f (uinteger_t<6> a, uinteger_t<6> b) { return divu<6>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	7	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<7> f (sinteger_t<7> a, sinteger_t<7> b) { return divs<7>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #64 orr w8, w8, w9 tst w8, #0x7f cinc w8, w0, eq sdiv w8, w8, w1 sxtb w0, w8 ret
arm64	7	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<7> f (uinteger_t<7> a, uinteger_t<7> b) { return divu<7>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	8	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<8> f (sinteger_t<8> a, sinteger_t<8> b) { return divs<8>(a, b); }	_f: ; @f add w8, w1, #1 eor w9, w0, #0x80 orr w8, w8, w9 tst w8, #0xff cinc w8, w0, eq sdiv w8, w8, w1 sxtb w0, w8 ret
arm64	8	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<8> f (uinteger_t<8> a, uinteger_t<8> b) { return divu<8>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	9	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<9> f (sinteger_t<9> a, sinteger_t<9> b) { return divs<9>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #256 orr w8, w8, w9 tst w8, #0x1ff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	9	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<9> f (uinteger_t<9> a, uinteger_t<9> b) { return divu<9>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	10	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<10> f (sinteger_t<10> a, sinteger_t<10> b) { return divs<10>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #512 orr w8, w8, w9 tst w8, #0x3ff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	10	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<10> f (uinteger_t<10> a, uinteger_t<10> b) { return divu<10>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	11	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<11> f (sinteger_t<11> a, sinteger_t<11> b) { return divs<11>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #1024 orr w8, w8, w9 tst w8, #0x7ff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	11	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<11> f (uinteger_t<11> a, uinteger_t<11> b) { return divu<11>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	12	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<12> f (sinteger_t<12> a, sinteger_t<12> b) { return divs<12>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #2048 orr w8, w8, w9 tst w8, #0xfff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	12	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<12> f (uinteger_t<12> a, uinteger_t<12> b) { return divu<12>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	13	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<13> f (sinteger_t<13> a, sinteger_t<13> b) { return divs<13>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #1, lsl #12 ; =4096 orr w8, w8, w9 tst w8, #0x1fff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	13	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<13> f (uinteger_t<13> a, uinteger_t<13> b) { return divu<13>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	14	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<14> f (sinteger_t<14> a, sinteger_t<14> b) { return divs<14>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #2, lsl #12 ; =8192 orr w8, w8, w9 tst w8, #0x3fff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	14	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<14> f (uinteger_t<14> a, uinteger_t<14> b) { return divu<14>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	15	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<15> f (sinteger_t<15> a, sinteger_t<15> b) { return divs<15>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #4, lsl #12 ; =16384 orr w8, w8, w9 tst w8, #0x7fff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	15	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<15> f (uinteger_t<15> a, uinteger_t<15> b) { return divu<15>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	16	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<16> f (sinteger_t<16> a, sinteger_t<16> b) { return divs<16>(a, b); }	_f: ; @f add w8, w1, #1 eor w9, w0, #0x8000 orr w8, w8, w9 tst w8, #0xffff cinc w8, w0, eq sdiv w8, w8, w1 sxth w0, w8 ret
arm64	16	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<16> f (uinteger_t<16> a, uinteger_t<16> b) { return divu<16>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	17	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<17> f (sinteger_t<17> a, sinteger_t<17> b) { return divs<17>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #16, lsl #12 ; =65536 orr w8, w8, w9 tst w8, #0x1ffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	17	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<17> f (uinteger_t<17> a, uinteger_t<17> b) { return divu<17>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	18	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<18> f (sinteger_t<18> a, sinteger_t<18> b) { return divs<18>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #32, lsl #12 ; =131072 orr w8, w8, w9 tst w8, #0x3ffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	18	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<18> f (uinteger_t<18> a, uinteger_t<18> b) { return divu<18>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	19	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<19> f (sinteger_t<19> a, sinteger_t<19> b) { return divs<19>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #64, lsl #12 ; =262144 orr w8, w8, w9 tst w8, #0x7ffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	19	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<19> f (uinteger_t<19> a, uinteger_t<19> b) { return divu<19>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	20	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<20> f (sinteger_t<20> a, sinteger_t<20> b) { return divs<20>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #128, lsl #12 ; =524288 orr w8, w8, w9 tst w8, #0xfffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	20	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<20> f (uinteger_t<20> a, uinteger_t<20> b) { return divu<20>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	21	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<21> f (sinteger_t<21> a, sinteger_t<21> b) { return divs<21>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #256, lsl #12 ; =1048576 orr w8, w8, w9 tst w8, #0x1fffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	21	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<21> f (uinteger_t<21> a, uinteger_t<21> b) { return divu<21>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	22	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<22> f (sinteger_t<22> a, sinteger_t<22> b) { return divs<22>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #512, lsl #12 ; =2097152 orr w8, w8, w9 tst w8, #0x3fffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	22	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<22> f (uinteger_t<22> a, uinteger_t<22> b) { return divu<22>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	23	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<23> f (sinteger_t<23> a, sinteger_t<23> b) { return divs<23>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #1024, lsl #12 ; =4194304 orr w8, w8, w9 tst w8, #0x7fffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	23	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<23> f (uinteger_t<23> a, uinteger_t<23> b) { return divu<23>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	24	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<24> f (sinteger_t<24> a, sinteger_t<24> b) { return divs<24>(a, b); }	_f: ; @f add w8, w1, #1 add w9, w0, #2048, lsl #12 ; =8388608 orr w8, w8, w9 tst w8, #0xffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	24	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<24> f (uinteger_t<24> a, uinteger_t<24> b) { return divu<24>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	25	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<25> f (sinteger_t<25> a, sinteger_t<25> b) { return divs<25>(a, b); }	_f: ; @f add w8, w1, #1 mov w9, #16777216 add w9, w0, w9 orr w8, w8, w9 tst w8, #0x1ffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	25	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<25> f (uinteger_t<25> a, uinteger_t<25> b) { return divu<25>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	26	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<26> f (sinteger_t<26> a, sinteger_t<26> b) { return divs<26>(a, b); }	_f: ; @f add w8, w1, #1 mov w9, #33554432 add w9, w0, w9 orr w8, w8, w9 tst w8, #0x3ffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	26	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<26> f (uinteger_t<26> a, uinteger_t<26> b) { return divu<26>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	27	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<27> f (sinteger_t<27> a, sinteger_t<27> b) { return divs<27>(a, b); }	_f: ; @f add w8, w1, #1 mov w9, #67108864 add w9, w0, w9 orr w8, w8, w9 tst w8, #0x7ffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	27	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<27> f (uinteger_t<27> a, uinteger_t<27> b) { return divu<27>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	28	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<28> f (sinteger_t<28> a, sinteger_t<28> b) { return divs<28>(a, b); }	_f: ; @f add w8, w1, #1 mov w9, #134217728 add w9, w0, w9 orr w8, w8, w9 tst w8, #0xfffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	28	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<28> f (uinteger_t<28> a, uinteger_t<28> b) { return divu<28>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	29	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<29> f (sinteger_t<29> a, sinteger_t<29> b) { return divs<29>(a, b); }	_f: ; @f add w8, w1, #1 mov w9, #268435456 add w9, w0, w9 orr w8, w8, w9 tst w8, #0x1fffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	29	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<29> f (uinteger_t<29> a, uinteger_t<29> b) { return divu<29>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	30	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<30> f (sinteger_t<30> a, sinteger_t<30> b) { return divs<30>(a, b); }	_f: ; @f add w8, w1, #1 mov w9, #536870912 add w9, w0, w9 orr w8, w8, w9 tst w8, #0x3fffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	30	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<30> f (uinteger_t<30> a, uinteger_t<30> b) { return divu<30>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	31	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<31> f (sinteger_t<31> a, sinteger_t<31> b) { return divs<31>(a, b); }	_f: ; @f add w8, w1, #1 mov w9, #1073741824 add w9, w0, w9 orr w8, w8, w9 tst w8, #0x7fffffff cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	31	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<31> f (uinteger_t<31> a, uinteger_t<31> b) { return divu<31>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	32	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<32> f (sinteger_t<32> a, sinteger_t<32> b) { return divs<32>(a, b); }	_f: ; @f add w8, w1, #1 eor w9, w0, #0x80000000 orr w8, w8, w9 cmp w8, #0 cinc w8, w0, eq sdiv w0, w8, w1 ret
arm64	32	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<32> f (uinteger_t<32> a, uinteger_t<32> b) { return divu<32>(a, b); }	_f: ; @f udiv w0, w0, w1 ret
arm64	33	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<33> f (sinteger_t<33> a, sinteger_t<33> b) { return divs<33>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #4294967296 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1ffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	33	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<33> f (uinteger_t<33> a, uinteger_t<33> b) { return divu<33>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	34	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<34> f (sinteger_t<34> a, sinteger_t<34> b) { return divs<34>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #8589934592 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3ffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	34	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<34> f (uinteger_t<34> a, uinteger_t<34> b) { return divu<34>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	35	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<35> f (sinteger_t<35> a, sinteger_t<35> b) { return divs<35>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #17179869184 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7ffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	35	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<35> f (uinteger_t<35> a, uinteger_t<35> b) { return divu<35>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	36	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<36> f (sinteger_t<36> a, sinteger_t<36> b) { return divs<36>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #34359738368 add x9, x0, x9 orr x8, x8, x9 tst x8, #0xfffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	36	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<36> f (uinteger_t<36> a, uinteger_t<36> b) { return divu<36>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	37	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<37> f (sinteger_t<37> a, sinteger_t<37> b) { return divs<37>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #68719476736 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1fffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	37	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<37> f (uinteger_t<37> a, uinteger_t<37> b) { return divu<37>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	38	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<38> f (sinteger_t<38> a, sinteger_t<38> b) { return divs<38>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #137438953472 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3fffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	38	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<38> f (uinteger_t<38> a, uinteger_t<38> b) { return divu<38>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	39	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<39> f (sinteger_t<39> a, sinteger_t<39> b) { return divs<39>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #274877906944 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7fffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	39	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<39> f (uinteger_t<39> a, uinteger_t<39> b) { return divu<39>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	40	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<40> f (sinteger_t<40> a, sinteger_t<40> b) { return divs<40>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #549755813888 add x9, x0, x9 orr x8, x8, x9 tst x8, #0xffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	40	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<40> f (uinteger_t<40> a, uinteger_t<40> b) { return divu<40>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	41	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<41> f (sinteger_t<41> a, sinteger_t<41> b) { return divs<41>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #1099511627776 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1ffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	41	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<41> f (uinteger_t<41> a, uinteger_t<41> b) { return divu<41>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	42	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<42> f (sinteger_t<42> a, sinteger_t<42> b) { return divs<42>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #2199023255552 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3ffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	42	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<42> f (uinteger_t<42> a, uinteger_t<42> b) { return divu<42>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	43	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<43> f (sinteger_t<43> a, sinteger_t<43> b) { return divs<43>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #4398046511104 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7ffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	43	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<43> f (uinteger_t<43> a, uinteger_t<43> b) { return divu<43>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	44	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<44> f (sinteger_t<44> a, sinteger_t<44> b) { return divs<44>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #8796093022208 add x9, x0, x9 orr x8, x8, x9 tst x8, #0xfffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	44	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<44> f (uinteger_t<44> a, uinteger_t<44> b) { return divu<44>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	45	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<45> f (sinteger_t<45> a, sinteger_t<45> b) { return divs<45>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #17592186044416 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1fffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	45	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<45> f (uinteger_t<45> a, uinteger_t<45> b) { return divu<45>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	46	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<46> f (sinteger_t<46> a, sinteger_t<46> b) { return divs<46>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #35184372088832 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3fffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	46	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<46> f (uinteger_t<46> a, uinteger_t<46> b) { return divu<46>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	47	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<47> f (sinteger_t<47> a, sinteger_t<47> b) { return divs<47>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #70368744177664 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7fffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	47	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<47> f (uinteger_t<47> a, uinteger_t<47> b) { return divu<47>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	48	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<48> f (sinteger_t<48> a, sinteger_t<48> b) { return divs<48>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #140737488355328 add x9, x0, x9 orr x8, x8, x9 tst x8, #0xffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	48	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<48> f (uinteger_t<48> a, uinteger_t<48> b) { return divu<48>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	49	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<49> f (sinteger_t<49> a, sinteger_t<49> b) { return divs<49>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #281474976710656 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1ffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	49	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<49> f (uinteger_t<49> a, uinteger_t<49> b) { return divu<49>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	50	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<50> f (sinteger_t<50> a, sinteger_t<50> b) { return divs<50>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #562949953421312 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3ffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	50	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<50> f (uinteger_t<50> a, uinteger_t<50> b) { return divu<50>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	51	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<51> f (sinteger_t<51> a, sinteger_t<51> b) { return divs<51>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #1125899906842624 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7ffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	51	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<51> f (uinteger_t<51> a, uinteger_t<51> b) { return divu<51>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	52	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<52> f (sinteger_t<52> a, sinteger_t<52> b) { return divs<52>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #2251799813685248 add x9, x0, x9 orr x8, x8, x9 tst x8, #0xfffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	52	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<52> f (uinteger_t<52> a, uinteger_t<52> b) { return divu<52>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	53	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<53> f (sinteger_t<53> a, sinteger_t<53> b) { return divs<53>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #4503599627370496 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1fffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	53	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<53> f (uinteger_t<53> a, uinteger_t<53> b) { return divu<53>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	54	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<54> f (sinteger_t<54> a, sinteger_t<54> b) { return divs<54>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #9007199254740992 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3fffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	54	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<54> f (uinteger_t<54> a, uinteger_t<54> b) { return divu<54>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	55	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<55> f (sinteger_t<55> a, sinteger_t<55> b) { return divs<55>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #18014398509481984 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7fffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	55	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<55> f (uinteger_t<55> a, uinteger_t<55> b) { return divu<55>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	56	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<56> f (sinteger_t<56> a, sinteger_t<56> b) { return divs<56>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #36028797018963968 add x9, x0, x9 orr x8, x8, x9 tst x8, #0xffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	56	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<56> f (uinteger_t<56> a, uinteger_t<56> b) { return divu<56>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	57	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<57> f (sinteger_t<57> a, sinteger_t<57> b) { return divs<57>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #72057594037927936 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1ffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	57	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<57> f (uinteger_t<57> a, uinteger_t<57> b) { return divu<57>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	58	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<58> f (sinteger_t<58> a, sinteger_t<58> b) { return divs<58>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #144115188075855872 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3ffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	58	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<58> f (uinteger_t<58> a, uinteger_t<58> b) { return divu<58>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	59	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<59> f (sinteger_t<59> a, sinteger_t<59> b) { return divs<59>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #288230376151711744 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7ffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	59	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<59> f (uinteger_t<59> a, uinteger_t<59> b) { return divu<59>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	60	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<60> f (sinteger_t<60> a, sinteger_t<60> b) { return divs<60>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #576460752303423488 add x9, x0, x9 orr x8, x8, x9 tst x8, #0xfffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	60	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<60> f (uinteger_t<60> a, uinteger_t<60> b) { return divu<60>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	61	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<61> f (sinteger_t<61> a, sinteger_t<61> b) { return divs<61>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #1152921504606846976 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x1fffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	61	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<61> f (uinteger_t<61> a, uinteger_t<61> b) { return divu<61>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	62	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<62> f (sinteger_t<62> a, sinteger_t<62> b) { return divs<62>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #2305843009213693952 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x3fffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	62	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<62> f (uinteger_t<62> a, uinteger_t<62> b) { return divu<62>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	63	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<63> f (sinteger_t<63> a, sinteger_t<63> b) { return divs<63>(a, b); }	_f: ; @f add x8, x1, #1 mov x9, #4611686018427387904 add x9, x0, x9 orr x8, x8, x9 tst x8, #0x7fffffffffffffff cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	63	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<63> f (uinteger_t<63> a, uinteger_t<63> b) { return divu<63>(a, b); }	_f: ; @f udiv x0, x0, x1 ret
arm64	64	div	signed	#include "saturation/saturation.hpp" using namespace saturation; extern "C" sinteger_t<64> f (sinteger_t<64> a, sinteger_t<64> b) { return divs<64>(a, b); }	_f: ; @f add x8, x1, #1 eor x9, x0, #0x8000000000000000 orr x8, x8, x9 cmp x8, #0 cinc x8, x0, eq sdiv x0, x8, x1 ret
arm64	64	div	unsigned	#include "saturation/saturation.hpp" using namespace saturation; extern "C" uinteger_t<64> f (uinteger_t<64> a, uinteger_t<64> b) { return divu<64>(a, b); }	_f: ; @f udiv x0, x0, x1 ret