text stringlengths 1 1.05M |
|---|
.file "project.c"
.def __main; .scl 2; .type 32; .endef
.section .rdata,"dr"
.align 8
.LC0:
.ascii "\12Enter values of a, b, c of quadratic equation (aX^2 + bX + c): \0"
.LC1:
.ascii "%f%f%f\0"
.align 8
.LC5:
.ascii "Two distinct and real roots exists: %.2f and %.2f\0"
.align 8
.LC6:
.ascii "Two equal and real roots exists: %.2f and %.2f\0"
.align 8
.LC7:
.ascii "Two distinct complex roots exists: %.2f + i%.2f and %.2f - i%.2f\0"
.text
.globl main
.def main; .scl 2; .type 32; .endef
.seh_proc main
main:
pushq %rbp
.seh_pushreg %rbp
movq %rsp, %rbp
.seh_setframe %rbp, 0
subq $96, %rsp
.seh_stackalloc 96
movaps %xmm6, -16(%rbp)
.seh_savexmm %xmm6, 80
.seh_endprologue
call __main
leaq .LC0(%rip), %rcx
call printf
leaq -44(%rbp), %rcx
leaq -40(%rbp), %rdx
leaq -36(%rbp), %rax
movq %rcx, %r9
movq %rdx, %r8
movq %rax, %rdx
leaq .LC1(%rip), %rcx
call scanf
movss -40(%rbp), %xmm1
movss -40(%rbp), %xmm0
mulss %xmm1, %xmm0
movss -36(%rbp), %xmm2
movss .LC2(%rip), %xmm1
mulss %xmm2, %xmm1
movss -44(%rbp), %xmm2
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -20(%rbp)
movss -20(%rbp), %xmm0
pxor %xmm1, %xmm1
ucomiss %xmm1, %xmm0
seta %al
movzbl %al, %eax
testl %eax, %eax
je .L3
cmpl $1, %eax
jne .L2
movss -40(%rbp), %xmm1
movss .LC4(%rip), %xmm0
xorps %xmm1, %xmm0
cvtss2sd %xmm0, %xmm6
cvtss2sd -20(%rbp), %xmm5
movq %xmm5, %rax
movq %rax, %xmm0
call sqrt
movq %xmm0, %rax
movq %rax, %xmm1
addsd %xmm6, %xmm1
movss -36(%rbp), %xmm0
addss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm3
movss %xmm3, -24(%rbp)
movss -40(%rbp), %xmm1
movss .LC4(%rip), %xmm0
xorps %xmm1, %xmm0
cvtss2sd %xmm0, %xmm6
cvtss2sd -20(%rbp), %xmm5
movq %xmm5, %rax
movq %rax, %xmm0
call sqrt
movq %xmm0, %rax
movq %rax, %xmm3
subsd %xmm3, %xmm6
movapd %xmm6, %xmm1
movss -36(%rbp), %xmm0
addss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm4
movss %xmm4, -28(%rbp)
cvtss2sd -28(%rbp), %xmm1
cvtss2sd -24(%rbp), %xmm0
movq %xmm1, %rax
movq %rax, %rdx
movq %rdx, %rcx
movq %rax, %xmm1
movq %xmm0, %rax
movq %rax, %rdx
movq %rcx, %xmm2
movq %xmm1, %r8
movq %rdx, %xmm1
movq %rax, %rdx
leaq .LC5(%rip), %rcx
call printf
jmp .L2
.L3:
pxor %xmm0, %xmm0
ucomiss -20(%rbp), %xmm0
seta %al
movzbl %al, %eax
testl %eax, %eax
je .L6
cmpl $1, %eax
je .L7
jmp .L9
.L7:
movss -40(%rbp), %xmm1
movss .LC4(%rip), %xmm0
xorps %xmm0, %xmm1
movss -36(%rbp), %xmm0
addss %xmm0, %xmm0
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss %xmm0, -28(%rbp)
movss -28(%rbp), %xmm0
movss %xmm0, -24(%rbp)
cvtss2sd -28(%rbp), %xmm1
cvtss2sd -24(%rbp), %xmm0
movq %xmm1, %rax
movq %rax, %rdx
movq %rdx, %rcx
movq %rax, %xmm1
movq %xmm0, %rax
movq %rax, %rdx
movq %rcx, %xmm2
movq %xmm1, %r8
movq %rdx, %xmm1
movq %rax, %rdx
leaq .LC6(%rip), %rcx
call printf
jmp .L5
.L6:
movss -40(%rbp), %xmm1
movss .LC4(%rip), %xmm0
xorps %xmm0, %xmm1
movss -36(%rbp), %xmm0
addss %xmm0, %xmm0
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss %xmm0, -28(%rbp)
movss -28(%rbp), %xmm0
movss %xmm0, -24(%rbp)
movss -20(%rbp), %xmm1
movss .LC4(%rip), %xmm0
xorps %xmm1, %xmm0
cvtss2sd %xmm0, %xmm5
movq %xmm5, %rax
movq %rax, %xmm0
call sqrt
movq %xmm0, %rax
movss -36(%rbp), %xmm0
addss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movq %rax, %xmm4
divsd %xmm0, %xmm4
movapd %xmm4, %xmm0
cvtsd2ss %xmm0, %xmm3
movss %xmm3, -32(%rbp)
cvtss2sd -32(%rbp), %xmm0
cvtss2sd -28(%rbp), %xmm3
cvtss2sd -32(%rbp), %xmm2
cvtss2sd -24(%rbp), %xmm1
movq %xmm3, %rax
movq %rax, %rdx
movq %rdx, %r8
movq %rax, %xmm5
movq %xmm2, %rax
movq %rax, %rdx
movq %rdx, %rcx
movq %rax, %xmm4
movq %xmm1, %rax
movq %rax, %rdx
movsd %xmm0, 32(%rsp)
movq %r8, %xmm3
movq %xmm5, %r9
movq %rcx, %xmm2
movq %xmm4, %r8
movq %rdx, %xmm1
movq %rax, %rdx
leaq .LC7(%rip), %rcx
call printf
nop
.L5:
.L9:
nop
.L2:
call getch
movl $0, %eax
movaps -16(%rbp), %xmm6
addq $96, %rsp
popq %rbp
ret
.seh_endproc
.section .rdata,"dr"
.align 4
.LC2:
.long 1082130432
.align 16
.LC4:
.long -2147483648
.long 0
.long 0
.long 0
.ident "GCC: (x86_64-posix-seh-rev1, Built by MinGW-W64 project) 6.2.0"
.def printf; .scl 2; .type 32; .endef
.def scanf; .scl 2; .type 32; .endef
.def sqrt; .scl 2; .type 32; .endef
.def getch; .scl 2; .type 32; .endef
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r15
push %rax
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0x17c1b, %r11
nop
nop
nop
nop
and $19665, %rax
vmovups (%r11), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $0, %xmm5, %r13
nop
sub $28179, %r15
lea addresses_WC_ht+0x109b, %rdx
clflush (%rdx)
nop
nop
dec %r11
mov $0x6162636465666768, %r13
movq %r13, (%rdx)
sub %r15, %r15
lea addresses_normal_ht+0x1bb5b, %r15
nop
cmp %rax, %rax
mov (%r15), %r11w
nop
nop
inc %rdx
lea addresses_D_ht+0x3edb, %rsi
lea addresses_WC_ht+0xe01b, %rdi
clflush (%rdi)
nop
nop
nop
nop
and $35557, %rdx
mov $103, %rcx
rep movsw
nop
nop
nop
nop
nop
sub $1276, %rcx
lea addresses_UC_ht+0xc396, %rsi
nop
sub %rdi, %rdi
mov $0x6162636465666768, %rdx
movq %rdx, (%rsi)
nop
and $42189, %rdi
lea addresses_UC_ht+0xe81b, %r13
nop
nop
nop
nop
add $7442, %rcx
mov (%r13), %edx
nop
nop
dec %r15
lea addresses_normal_ht+0x9e5b, %rsi
lea addresses_WC_ht+0x17adb, %rdi
clflush (%rdi)
nop
nop
nop
nop
inc %r13
mov $26, %rcx
rep movsb
nop
nop
nop
inc %rsi
lea addresses_WC_ht+0x101b, %rsi
lea addresses_A_ht+0x241b, %rdi
clflush (%rsi)
nop
nop
xor %rax, %rax
mov $45, %rcx
rep movsb
add $55178, %r11
lea addresses_normal_ht+0x1b4ab, %rsi
lea addresses_normal_ht+0xf81b, %rdi
nop
nop
nop
xor %r13, %r13
mov $23, %rcx
rep movsq
and $42471, %rax
lea addresses_UC_ht+0x1270b, %rdx
nop
nop
nop
nop
xor $55776, %rax
movl $0x61626364, (%rdx)
nop
nop
cmp %r15, %r15
lea addresses_WT_ht+0xb1db, %rsi
lea addresses_UC_ht+0x114a0, %rdi
nop
xor $26156, %r15
mov $2, %rcx
rep movsb
nop
nop
nop
nop
nop
dec %rdi
lea addresses_normal_ht+0x17103, %rax
nop
dec %rdx
movb (%rax), %cl
nop
nop
nop
nop
nop
xor %r11, %r11
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rax
pop %r15
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r9
push %rbp
push %rbx
push %rcx
push %rdx
push %rsi
// Store
lea addresses_D+0x721b, %rdx
nop
nop
xor $43825, %r9
mov $0x5152535455565758, %rbp
movq %rbp, %xmm7
movups %xmm7, (%rdx)
and $16607, %rcx
// Store
lea addresses_WT+0x1a3c3, %r9
sub %r11, %r11
movb $0x51, (%r9)
inc %rcx
// Store
mov $0x3b141d000000081b, %rbp
clflush (%rbp)
nop
nop
nop
and $26791, %rcx
movb $0x51, (%rbp)
nop
nop
sub %rcx, %rcx
// Store
lea addresses_D+0x3b9b, %rbx
nop
nop
nop
nop
add $56086, %r9
mov $0x5152535455565758, %rdx
movq %rdx, %xmm4
movups %xmm4, (%rbx)
nop
nop
nop
nop
cmp $11066, %r9
// Faulty Load
lea addresses_A+0x1001b, %r9
and %rcx, %rcx
mov (%r9), %ebx
lea oracles, %r9
and $0xff, %rbx
shlq $12, %rbx
mov (%r9,%rbx,1), %rbx
pop %rsi
pop %rdx
pop %rcx
pop %rbx
pop %rbp
pop %r9
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_A', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_D', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_WT', 'same': False, 'AVXalign': False, 'congruent': 2}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_NC', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_D', 'same': False, 'AVXalign': False, 'congruent': 7}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_A', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': True, 'congruent': 7}}
{'OP': 'LOAD', 'src': {'size': 2, 'NT': True, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 6}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_D_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 11}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 4}, 'dst': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 11}, 'dst': {'same': True, 'type': 'addresses_A_ht', 'congruent': 10}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 3}, 'dst': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 4}}
{'OP': 'REPM', 'src': {'same': True, 'type': 'addresses_WT_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 0}}
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
; Copyright (c) 2022 Sam Blenny
; SPDX-License-Identifier: MIT
;
; MarkabForth store and fetch words (meant to be included in ../libmarkab.nasm)
; This include path is relative to the working directory that will be in effect
; when running the Makefile in the parent directory of this file. So the
; include path is relative to ../Makefile, which is confusing.
%include "libmarkab/common_macros.nasm"
extern DSBase
extern Mem
extern mErr13AddressOOR
extern mErr1Underflow
global mFetch
global mStore
global mByteFetch
global mByteStore
global mWordFetch
global mWordStore
mFetch: ; Fetch: pop addr, load & push dword [Mem+T]
movq rdi, DSDeep ; need at least 1 item on stack
cmp dil, 1
jb mErr1Underflow
test T, T ; check address satisfies: 0 <= T < MemSize-3
jl mErr13AddressOOR
cmp T, MemSize-3
jge mErr13AddressOOR
mov T, [Mem+T] ; pop addr, load dword, push dword
ret
mStore: ; Store dword (second) at address [Mem+T]
movq rsi, DSDeep ; make sure stack depth >= 2 items (data, address)
cmp esi, 2
jb mErr1Underflow
cmp T, Fence ; check address satisfies: Fence < T < MemSize-3
jle mErr13AddressOOR
cmp T, MemSize-3
jge mErr13AddressOOR
mov edi, T ; save address
dec esi ; drop address
mov T, [DSBase+4*esi-4] ; T now contains the data dword from former second
mov [Mem+edi], T ; store data at [Mem+T]
dec rsi ; drop data dword
movq DSDeep, rsi
mov T, [DSBase+4*esi-4]
ret
mByteFetch: ; Fetch: pop addr, load & push byte [Mem+T]
movq rdi, DSDeep ; make sure stack has at least 1 item (address)
cmp dil, 1
jb mErr1Underflow
test T, T ; check address satisfies: 0 <= T < MemSize
jl mErr13AddressOOR
cmp T, MemSize
jge mErr13AddressOOR
xor W, W ; pop addr, load dword
mov WB, byte [Mem+T]
mov T, W ; push dword
ret
mByteStore: ; Store low byte of (second) at address [Mem+T]
movq rdi, DSDeep ; make sure stack depth >= 2 items (data, address)
cmp dil, 2
jb mErr1Underflow
cmp T, Fence ; check address satisfies: Fence < T < MemSize
jle mErr13AddressOOR
cmp T, MemSize
jge mErr13AddressOOR
mov esi, T ; save address
dec edi ; drop address
mov T, [DSBase+4*edi-4] ; T now contains the data from former second
mov byte [Mem+esi], TB ; store data at [Mem+T]
dec edi ; drop data dword
movq DSDeep, rdi
mov T, [DSBase+4*edi-4]
ret
mWordFetch: ; Fetch: pop addr, load & push word [Mem+T]
movq rdi, DSDeep ; make sure stack has at least 1 item (address)
cmp dil, 1
jb mErr1Underflow
test T, T ; check address satisfies: 0 <= T < MemSize-1
jl mErr13AddressOOR
cmp T, MemSize-1
jge mErr13AddressOOR
xor W, W ; pop addr, load dword
mov WW, word [Mem+T]
mov T, W ; push dword
ret
mWordStore: ; Store low word of (second) at address [Mem+T]
movq rdi, DSDeep ; make sure stack depth >= 2 items (data, address)
cmp dil, 2
jb mErr1Underflow
cmp T, Fence ; check address satisfies: Fence < T < MemSize-1
jle mErr13AddressOOR
cmp T, MemSize-1
jge mErr13AddressOOR
mov esi, T ; save address
dec edi ; drop address
mov T, [DSBase+4*edi-4] ; T now contains the data from former second
mov word [Mem+esi], TW ; store data at [Mem+T]
dec edi ; drop data dword
movq DSDeep, rdi
mov T, [DSBase+4*edi-4]
ret
|
; A248583: The least number m == 1 (mod 6) that is divisible by prime(n).
; 25,7,55,13,85,19,115,145,31,37,205,43,235,265,295,61,67,355,73,79,415,445,97,505,103,535,109,565,127,655,685,139,745,151,157,163,835,865,895,181,955,193,985,199,211,223,1135,229,1165,1195,241,1255,1285,1315,1345,271,277,1405,283,1465,307
add $0,2
mul $0,2
seq $0,173919 ; Numbers that are prime or one less than a prime.
mov $1,$0
mov $2,2
lpb $1
mod $1,6
lpe
mul $0,$1
add $0,$2
sub $0,2
|
; A010938: Binomial coefficient C(22,n).
; 1,22,231,1540,7315,26334,74613,170544,319770,497420,646646,705432,646646,497420,319770,170544,74613,26334,7315,1540,231,22,1
mov $1,22
bin $1,$0
|
copyright zengfr site:http://github.com/zengfr/romhack
00042A move.l D1, (A0)+
00042C dbra D0, $42a
004D2A move.l D0, (A4)+
004D2C move.l D0, (A4)+
005AAC tst.b ($506,A5) [123p+ B8]
005AB0 bne $5bda
018E90 tst.b ($506,A5)
018E94 bne $18e9e [base+506]
0191C4 tst.b ($506,A5)
0191C8 bne $193ce [base+506]
019356 tst.b ($506,A5)
01935A bne $193ce
01DBBA move.b (A0)+, ($506,A5) [base+4FD]
01DBBE move.w (A0)+, ($d8,A6) [base+506]
078FFC tst.b ($506,A5)
079000 beq $79006 [base+506]
0AAACA move.l (A0), D2
0AAACC move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, base+6FFE, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAACE move.w D0, ($2,A0)
0AAAD2 cmp.l (A0), D0
0AAAD4 bne $aaafc
0AAAD8 move.l D2, (A0)+
0AAADA cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, base+6FFE, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAAE6 move.l (A0), D2
0AAAE8 move.w D0, (A0) [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, base+6FFE, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
0AAAF4 move.l D2, (A0)+
0AAAF6 cmpa.l A0, A1 [123p+11A, 123p+11C, 123p+11E, 123p+120, 123p+122, 123p+124, 123p+126, 123p+128, 123p+12A, base+6FFE, enemy+BC, enemy+C0, enemy+C2, enemy+C4, enemy+CC, enemy+CE, enemy+D0, enemy+D2, enemy+D4, enemy+D6, enemy+D8, enemy+DA, item+86, item+88, item+8A, item+98, item+9A, item+9C, item+9E, item+A0, item+A2, item+A4, item+A6, scr1]
copyright zengfr site:http://github.com/zengfr/romhack
|
; A008831: Discrete logarithm of n to the base 2 modulo 13.
; Submitted by Christian Krause
; 0,1,4,2,9,5,11,3,8,10,7,6
add $0,1
mov $1,$0
seq $1,196 ; Integer part of square root of n. Or, number of positive squares <= n. Or, n appears 2n+1 times.
add $1,270
lpb $1
mov $2,2
sub $2,$0
lpb $2
mov $1,0
mov $2,0
lpe
mov $2,$0
mod $2,2
mov $3,1
lpb $2
add $0,14
sub $2,1
lpe
lpb $3
div $0,2
sub $3,1
lpe
sub $1,1
add $4,1
lpe
mov $0,$4
|
// Copyright (c) 2011-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2017 The PIVX developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "addresstablemodel.h"
#include "guiutil.h"
#include "walletmodel.h"
#include "base58.h"
#include "wallet.h"
#include <QDebug>
#include <QFont>
const QString AddressTableModel::Send = "S";
const QString AddressTableModel::Receive = "R";
const QString AddressTableModel::Zerocoin = "X";
struct AddressTableEntry {
enum Type {
Sending,
Receiving,
Zerocoin,
Hidden /* QSortFilterProxyModel will filter these out */
};
Type type;
QString label;
QString address;
QString pubcoin;
AddressTableEntry() {}
AddressTableEntry(Type type, const QString &pubcoin): type(type), pubcoin(pubcoin) {}
AddressTableEntry(Type type, const QString& label, const QString& address) : type(type), label(label), address(address) {}
};
struct AddressTableEntryLessThan {
bool operator()(const AddressTableEntry& a, const AddressTableEntry& b) const
{
return a.address < b.address;
}
bool operator()(const AddressTableEntry& a, const QString& b) const
{
return a.address < b;
}
bool operator()(const QString& a, const AddressTableEntry& b) const
{
return a < b.address;
}
};
/* Determine address type from address purpose */
static AddressTableEntry::Type translateTransactionType(const QString& strPurpose, bool isMine)
{
AddressTableEntry::Type addressType = AddressTableEntry::Hidden;
// "refund" addresses aren't shown, and change addresses aren't in mapAddressBook at all.
if (strPurpose == "send")
addressType = AddressTableEntry::Sending;
else if (strPurpose == "receive")
addressType = AddressTableEntry::Receiving;
else if (strPurpose == "unknown" || strPurpose == "") // if purpose not set, guess
addressType = (isMine ? AddressTableEntry::Receiving : AddressTableEntry::Sending);
return addressType;
}
// Private implementation
class AddressTablePriv
{
public:
CWallet* wallet;
QList<AddressTableEntry> cachedAddressTable;
AddressTableModel* parent;
AddressTablePriv(CWallet* wallet, AddressTableModel* parent) : wallet(wallet), parent(parent) {}
void refreshAddressTable()
{
cachedAddressTable.clear();
{
LOCK(wallet->cs_wallet);
BOOST_FOREACH (const PAIRTYPE(CTxDestination, CAddressBookData) & item, wallet->mapAddressBook) {
const CBitcoinAddress& address = item.first;
bool fMine = IsMine(*wallet, address.Get());
AddressTableEntry::Type addressType = translateTransactionType(
QString::fromStdString(item.second.purpose), fMine);
const std::string& strName = item.second.name;
cachedAddressTable.append(AddressTableEntry(addressType,
QString::fromStdString(strName),
QString::fromStdString(address.ToString())));
}
}
// qLowerBound() and qUpperBound() require our cachedAddressTable list to be sorted in asc order
// Even though the map is already sorted this re-sorting step is needed because the originating map
// is sorted by binary address, not by base58() address.
qSort(cachedAddressTable.begin(), cachedAddressTable.end(), AddressTableEntryLessThan());
}
void updateEntry(const QString& address, const QString& label, bool isMine, const QString& purpose, int status)
{
// Find address / label in model
QList<AddressTableEntry>::iterator lower = qLowerBound(
cachedAddressTable.begin(), cachedAddressTable.end(), address, AddressTableEntryLessThan());
QList<AddressTableEntry>::iterator upper = qUpperBound(
cachedAddressTable.begin(), cachedAddressTable.end(), address, AddressTableEntryLessThan());
int lowerIndex = (lower - cachedAddressTable.begin());
int upperIndex = (upper - cachedAddressTable.begin());
bool inModel = (lower != upper);
AddressTableEntry::Type newEntryType = translateTransactionType(purpose, isMine);
switch (status) {
case CT_NEW:
if (inModel) {
qWarning() << "AddressTablePriv::updateEntry : Warning: Got CT_NEW, but entry is already in model";
break;
}
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex);
cachedAddressTable.insert(lowerIndex, AddressTableEntry(newEntryType, label, address));
parent->endInsertRows();
break;
case CT_UPDATED:
if (!inModel) {
qWarning() << "AddressTablePriv::updateEntry : Warning: Got CT_UPDATED, but entry is not in model";
break;
}
lower->type = newEntryType;
lower->label = label;
parent->emitDataChanged(lowerIndex);
break;
case CT_DELETED:
if (!inModel) {
qWarning() << "AddressTablePriv::updateEntry : Warning: Got CT_DELETED, but entry is not in model";
break;
}
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex - 1);
cachedAddressTable.erase(lower, upper);
parent->endRemoveRows();
break;
}
}
void updateEntry(const QString &pubCoin, const QString &isUsed, int status)
{
// Find address / label in model
QList<AddressTableEntry>::iterator lower = qLowerBound(
cachedAddressTable.begin(), cachedAddressTable.end(), pubCoin, AddressTableEntryLessThan());
QList<AddressTableEntry>::iterator upper = qUpperBound(
cachedAddressTable.begin(), cachedAddressTable.end(), pubCoin, AddressTableEntryLessThan());
int lowerIndex = (lower - cachedAddressTable.begin());
bool inModel = (lower != upper);
AddressTableEntry::Type newEntryType = AddressTableEntry::Zerocoin;
switch(status)
{
case CT_NEW:
if(inModel)
{
qWarning() << "AddressTablePriv_ZC::updateEntry : Warning: Got CT_NEW, but entry is already in model";
}
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex);
cachedAddressTable.insert(lowerIndex, AddressTableEntry(newEntryType, isUsed, pubCoin));
parent->endInsertRows();
break;
case CT_UPDATED:
if(!inModel)
{
qWarning() << "AddressTablePriv_ZC::updateEntry : Warning: Got CT_UPDATED, but entry is not in model";
break;
}
lower->type = newEntryType;
lower->label = isUsed;
parent->emitDataChanged(lowerIndex);
break;
}
}
int size()
{
return cachedAddressTable.size();
}
AddressTableEntry* index(int idx)
{
if (idx >= 0 && idx < cachedAddressTable.size()) {
return &cachedAddressTable[idx];
} else {
return 0;
}
}
};
AddressTableModel::AddressTableModel(CWallet* wallet, WalletModel* parent) : QAbstractTableModel(parent), walletModel(parent), wallet(wallet), priv(0)
{
columns << tr("Label") << tr("Address");
priv = new AddressTablePriv(wallet, this);
priv->refreshAddressTable();
}
AddressTableModel::~AddressTableModel()
{
delete priv;
}
int AddressTableModel::rowCount(const QModelIndex& parent) const
{
Q_UNUSED(parent);
return priv->size();
}
int AddressTableModel::columnCount(const QModelIndex& parent) const
{
Q_UNUSED(parent);
return columns.length();
}
QVariant AddressTableModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid())
return QVariant();
AddressTableEntry* rec = static_cast<AddressTableEntry*>(index.internalPointer());
if (role == Qt::DisplayRole || role == Qt::EditRole) {
switch (index.column()) {
case Label:
if (rec->label.isEmpty() && role == Qt::DisplayRole) {
return tr("(no label)");
} else {
return rec->label;
}
case Address:
return rec->address;
}
} else if (role == Qt::FontRole) {
QFont font;
if (index.column() == Address) {
font = GUIUtil::bitcoinAddressFont();
}
return font;
} else if (role == TypeRole) {
switch (rec->type) {
case AddressTableEntry::Sending:
return Send;
case AddressTableEntry::Receiving:
return Receive;
default:
break;
}
}
return QVariant();
}
bool AddressTableModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (!index.isValid())
return false;
AddressTableEntry* rec = static_cast<AddressTableEntry*>(index.internalPointer());
std::string strPurpose = (rec->type == AddressTableEntry::Sending ? "send" : "receive");
editStatus = OK;
if (role == Qt::EditRole) {
LOCK(wallet->cs_wallet); /* For SetAddressBook / DelAddressBook */
CTxDestination curAddress = CBitcoinAddress(rec->address.toStdString()).Get();
if (index.column() == Label) {
// Do nothing, if old label == new label
if (rec->label == value.toString()) {
editStatus = NO_CHANGES;
return false;
}
wallet->SetAddressBook(curAddress, value.toString().toStdString(), strPurpose);
} else if (index.column() == Address) {
CTxDestination newAddress = CBitcoinAddress(value.toString().toStdString()).Get();
// Refuse to set invalid address, set error status and return false
if (boost::get<CNoDestination>(&newAddress)) {
editStatus = INVALID_ADDRESS;
return false;
}
// Do nothing, if old address == new address
else if (newAddress == curAddress) {
editStatus = NO_CHANGES;
return false;
}
// Check for duplicate addresses to prevent accidental deletion of addresses, if you try
// to paste an existing address over another address (with a different label)
else if (wallet->mapAddressBook.count(newAddress)) {
editStatus = DUPLICATE_ADDRESS;
return false;
}
// Double-check that we're not overwriting a receiving address
else if (rec->type == AddressTableEntry::Sending) {
// Remove old entry
wallet->DelAddressBook(curAddress);
// Add new entry with new address
wallet->SetAddressBook(newAddress, rec->label.toStdString(), strPurpose);
}
}
return true;
}
return false;
}
QVariant AddressTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Horizontal) {
if (role == Qt::DisplayRole && section < columns.size()) {
return columns[section];
}
}
return QVariant();
}
Qt::ItemFlags AddressTableModel::flags(const QModelIndex& index) const
{
if (!index.isValid())
return 0;
AddressTableEntry* rec = static_cast<AddressTableEntry*>(index.internalPointer());
Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
// Can edit address and label for sending addresses,
// and only label for receiving addresses.
if (rec->type == AddressTableEntry::Sending ||
(rec->type == AddressTableEntry::Receiving && index.column() == Label)) {
retval |= Qt::ItemIsEditable;
}
return retval;
}
QModelIndex AddressTableModel::index(int row, int column, const QModelIndex& parent) const
{
Q_UNUSED(parent);
AddressTableEntry* data = priv->index(row);
if (data) {
return createIndex(row, column, priv->index(row));
} else {
return QModelIndex();
}
}
void AddressTableModel::updateEntry(const QString& address,
const QString& label,
bool isMine,
const QString& purpose,
int status)
{
// Update address book model from Bitcoin2 core
priv->updateEntry(address, label, isMine, purpose, status);
}
void AddressTableModel::updateEntry(const QString &pubCoin, const QString &isUsed, int status)
{
// Update stealth address book model from Bitcoin core
priv->updateEntry(pubCoin, isUsed, status);
}
QString AddressTableModel::addRow(const QString& type, const QString& label, const QString& address)
{
std::string strLabel = label.toStdString();
std::string strAddress = address.toStdString();
editStatus = OK;
if (type == Send) {
if (!walletModel->validateAddress(address)) {
editStatus = INVALID_ADDRESS;
return QString();
}
// Check for duplicate addresses
{
LOCK(wallet->cs_wallet);
if (wallet->mapAddressBook.count(CBitcoinAddress(strAddress).Get())) {
editStatus = DUPLICATE_ADDRESS;
return QString();
}
}
} else if (type == Receive) {
// Generate a new address to associate with given label
CPubKey newKey;
if (!wallet->GetKeyFromPool(newKey)) {
WalletModel::UnlockContext ctx(walletModel->requestUnlock(true));
if (!ctx.isValid()) {
// Unlock wallet failed or was cancelled
editStatus = WALLET_UNLOCK_FAILURE;
return QString();
}
if (!wallet->GetKeyFromPool(newKey)) {
editStatus = KEY_GENERATION_FAILURE;
return QString();
}
}
strAddress = CBitcoinAddress(newKey.GetID()).ToString();
} else {
return QString();
}
// Add entry
{
LOCK(wallet->cs_wallet);
wallet->SetAddressBook(CBitcoinAddress(strAddress).Get(), strLabel,
(type == Send ? "send" : "receive"));
}
return QString::fromStdString(strAddress);
}
bool AddressTableModel::removeRows(int row, int count, const QModelIndex& parent)
{
Q_UNUSED(parent);
AddressTableEntry* rec = priv->index(row);
if (count != 1 || !rec || rec->type == AddressTableEntry::Receiving) {
// Can only remove one row at a time, and cannot remove rows not in model.
// Also refuse to remove receiving addresses.
return false;
}
{
LOCK(wallet->cs_wallet);
wallet->DelAddressBook(CBitcoinAddress(rec->address.toStdString()).Get());
}
return true;
}
/* Look up label for address in address book, if not found return empty string.
*/
QString AddressTableModel::labelForAddress(const QString& address) const
{
{
LOCK(wallet->cs_wallet);
CBitcoinAddress address_parsed(address.toStdString());
std::map<CTxDestination, CAddressBookData>::iterator mi = wallet->mapAddressBook.find(address_parsed.Get());
if (mi != wallet->mapAddressBook.end()) {
return QString::fromStdString(mi->second.name);
}
}
return QString();
}
int AddressTableModel::lookupAddress(const QString& address) const
{
QModelIndexList lst = match(index(0, Address, QModelIndex()),
Qt::EditRole, address, 1, Qt::MatchExactly);
if (lst.isEmpty()) {
return -1;
} else {
return lst.at(0).row();
}
}
void AddressTableModel::emitDataChanged(int idx)
{
emit dataChanged(index(idx, 0, QModelIndex()), index(idx, columns.length() - 1, QModelIndex()));
}
|
# Questo esempio è tratto da Appendice A Sez. A9 - Chiamate di sistema
# pag. A33 (utima edizione italiana)
# ATTENZIONE; guardare bene le istruzioi alla riga 22 e alla riga 34 con i relativi commenti.
# il codice seguente stampa la stringa "La risposta e' 55":
.data
str:
.asciiz "La risposta e' "
.text
li $v0, 4 # Codice della chiamata di sistema per print_str
la $a0, str # Indirizzo della stringa da stampare
syscall # Stampa la stringa
li $v0, 1 # Codice della chiamata di sistema per print_int
la $a0, 5 # Numero intero da stampare..caricato in $a0 come se fosse un indirizzo!!!
# Questa è l'istruzione ripresa da Appendice A Sez. A9 - Chiamate di sistema
# In effetti e' MOLTO DISCUTIBILE: sarebbe piu' corretto usare l'istruzione li
# (riga 36). Funiona perche', in realta', nella la si specifica un "indirizzo" fornito come immediato
# e la istruzione "la" fa esattamente la stessa cosa di una "li" di un valore immediato
# (della serie: i bit son sempre bit...)
# A conferma, guardate il codice generato dall'assemblatore
# traducendo le pseudo istruzioni la (riga 22) e li (riga 34):
# e' esattamente uguale nei due casi!!!
syscall # Stampa l’intero
li $a0, 5 # Numero intero da stampare
syscall # Stampa di nuovo l’intero (in $v0 c'è ancora 1)
# Provate anche a commentare le due istruzioni che seguono e confrontate
# i messaggi di terminazione con e senza le due istruzioni
li $v0, 17
syscall
|
; BCD TO HEX
.model small
.stack
.data
m1 DB 10,13, "hex equivalent is: $"
number DW 14
.code
Disp MACRO xx
MOV AH, 09
LEA DX, XX
INT 21H
ENDM
.startup
MOV AX, number
MOV BX, 16
MOV CL, 0
LOOP1:
MOV DX, 0
DIV BX
PUSH DX
INC CL
CMP AX, 0
JNZ LOOP1
Disp m1
BACK:
POP dx
cmp dx,09h
jg logic
ADD DL, 30H
logic:
add dl,37h
MOV AH, 02
INT 21H
DEC CL
JNZ BACK
.exit
end
|
db 0 ; species ID placeholder
db 48, 72, 48, 48, 72, 48
; hp atk def spd sat sdf
db PSYCHIC, PSYCHIC ; type
db 225 ; catch rate
db 61 ; base exp
db NO_ITEM, NO_ITEM ; items
db GENDER_UNKNOWN ; gender ratio
db 40 ; step cycles to hatch
INCBIN "gfx/pokemon/unown_a/front.dimensions"
db GROWTH_MEDIUM_FAST ; growth rate
dn EGG_NONE, EGG_NONE ; egg groups
db 70 ; happiness
; tm/hm learnset
tmhm
; end
|
_wc: file format elf32-i386
Disassembly of section .text:
00000000 <wc>:
char buf[512];
void
wc(int fd, char *name)
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 48 sub $0x48,%esp
int i, n;
int l, w, c, inword;
l = w = c = 0;
6: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
d: 8b 45 e8 mov -0x18(%ebp),%eax
10: 89 45 ec mov %eax,-0x14(%ebp)
13: 8b 45 ec mov -0x14(%ebp),%eax
16: 89 45 f0 mov %eax,-0x10(%ebp)
inword = 0;
19: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
while((n = read(fd, buf, sizeof(buf))) > 0){
20: eb 68 jmp 8a <wc+0x8a>
for(i=0; i<n; i++){
22: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
29: eb 57 jmp 82 <wc+0x82>
c++;
2b: 83 45 e8 01 addl $0x1,-0x18(%ebp)
if(buf[i] == '\n')
2f: 8b 45 f4 mov -0xc(%ebp),%eax
32: 05 60 0d 00 00 add $0xd60,%eax
37: 0f b6 00 movzbl (%eax),%eax
3a: 3c 0a cmp $0xa,%al
3c: 75 04 jne 42 <wc+0x42>
l++;
3e: 83 45 f0 01 addl $0x1,-0x10(%ebp)
if(strchr(" \r\t\n\v", buf[i]))
42: 8b 45 f4 mov -0xc(%ebp),%eax
45: 05 60 0d 00 00 add $0xd60,%eax
4a: 0f b6 00 movzbl (%eax),%eax
4d: 0f be c0 movsbl %al,%eax
50: 89 44 24 04 mov %eax,0x4(%esp)
54: c7 04 24 4c 0a 00 00 movl $0xa4c,(%esp)
5b: e8 58 02 00 00 call 2b8 <strchr>
60: 85 c0 test %eax,%eax
62: 74 09 je 6d <wc+0x6d>
inword = 0;
64: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
6b: eb 11 jmp 7e <wc+0x7e>
else if(!inword){
6d: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
71: 75 0b jne 7e <wc+0x7e>
w++;
73: 83 45 ec 01 addl $0x1,-0x14(%ebp)
inword = 1;
77: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
int l, w, c, inword;
l = w = c = 0;
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(i=0; i<n; i++){
7e: 83 45 f4 01 addl $0x1,-0xc(%ebp)
82: 8b 45 f4 mov -0xc(%ebp),%eax
85: 3b 45 e0 cmp -0x20(%ebp),%eax
88: 7c a1 jl 2b <wc+0x2b>
int i, n;
int l, w, c, inword;
l = w = c = 0;
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
8a: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
91: 00
92: c7 44 24 04 60 0d 00 movl $0xd60,0x4(%esp)
99: 00
9a: 8b 45 08 mov 0x8(%ebp),%eax
9d: 89 04 24 mov %eax,(%esp)
a0: e8 b4 03 00 00 call 459 <read>
a5: 89 45 e0 mov %eax,-0x20(%ebp)
a8: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
ac: 0f 8f 70 ff ff ff jg 22 <wc+0x22>
w++;
inword = 1;
}
}
}
if(n < 0){
b2: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
b6: 79 19 jns d1 <wc+0xd1>
printf(1, "wc: read error\n");
b8: c7 44 24 04 52 0a 00 movl $0xa52,0x4(%esp)
bf: 00
c0: c7 04 24 01 00 00 00 movl $0x1,(%esp)
c7: e8 76 05 00 00 call 642 <printf>
exit();
cc: e8 70 03 00 00 call 441 <exit>
}
printf(1, "%d %d %d %s\n", l, w, c, name);
d1: 8b 45 0c mov 0xc(%ebp),%eax
d4: 89 44 24 14 mov %eax,0x14(%esp)
d8: 8b 45 e8 mov -0x18(%ebp),%eax
db: 89 44 24 10 mov %eax,0x10(%esp)
df: 8b 45 ec mov -0x14(%ebp),%eax
e2: 89 44 24 0c mov %eax,0xc(%esp)
e6: 8b 45 f0 mov -0x10(%ebp),%eax
e9: 89 44 24 08 mov %eax,0x8(%esp)
ed: c7 44 24 04 62 0a 00 movl $0xa62,0x4(%esp)
f4: 00
f5: c7 04 24 01 00 00 00 movl $0x1,(%esp)
fc: e8 41 05 00 00 call 642 <printf>
}
101: c9 leave
102: c3 ret
00000103 <main>:
int
main(int argc, char *argv[])
{
103: 55 push %ebp
104: 89 e5 mov %esp,%ebp
106: 83 e4 f0 and $0xfffffff0,%esp
109: 83 ec 20 sub $0x20,%esp
int fd, i;
if(argc <= 1){
10c: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
110: 7f 19 jg 12b <main+0x28>
wc(0, "");
112: c7 44 24 04 6f 0a 00 movl $0xa6f,0x4(%esp)
119: 00
11a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
121: e8 da fe ff ff call 0 <wc>
exit();
126: e8 16 03 00 00 call 441 <exit>
}
for(i = 1; i < argc; i++){
12b: c7 44 24 1c 01 00 00 movl $0x1,0x1c(%esp)
132: 00
133: e9 8f 00 00 00 jmp 1c7 <main+0xc4>
if((fd = open(argv[i], 0)) < 0){
138: 8b 44 24 1c mov 0x1c(%esp),%eax
13c: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx
143: 8b 45 0c mov 0xc(%ebp),%eax
146: 01 d0 add %edx,%eax
148: 8b 00 mov (%eax),%eax
14a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
151: 00
152: 89 04 24 mov %eax,(%esp)
155: e8 27 03 00 00 call 481 <open>
15a: 89 44 24 18 mov %eax,0x18(%esp)
15e: 83 7c 24 18 00 cmpl $0x0,0x18(%esp)
163: 79 2f jns 194 <main+0x91>
printf(1, "wc: cannot open %s\n", argv[i]);
165: 8b 44 24 1c mov 0x1c(%esp),%eax
169: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx
170: 8b 45 0c mov 0xc(%ebp),%eax
173: 01 d0 add %edx,%eax
175: 8b 00 mov (%eax),%eax
177: 89 44 24 08 mov %eax,0x8(%esp)
17b: c7 44 24 04 70 0a 00 movl $0xa70,0x4(%esp)
182: 00
183: c7 04 24 01 00 00 00 movl $0x1,(%esp)
18a: e8 b3 04 00 00 call 642 <printf>
exit();
18f: e8 ad 02 00 00 call 441 <exit>
}
wc(fd, argv[i]);
194: 8b 44 24 1c mov 0x1c(%esp),%eax
198: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx
19f: 8b 45 0c mov 0xc(%ebp),%eax
1a2: 01 d0 add %edx,%eax
1a4: 8b 00 mov (%eax),%eax
1a6: 89 44 24 04 mov %eax,0x4(%esp)
1aa: 8b 44 24 18 mov 0x18(%esp),%eax
1ae: 89 04 24 mov %eax,(%esp)
1b1: e8 4a fe ff ff call 0 <wc>
close(fd);
1b6: 8b 44 24 18 mov 0x18(%esp),%eax
1ba: 89 04 24 mov %eax,(%esp)
1bd: e8 a7 02 00 00 call 469 <close>
if(argc <= 1){
wc(0, "");
exit();
}
for(i = 1; i < argc; i++){
1c2: 83 44 24 1c 01 addl $0x1,0x1c(%esp)
1c7: 8b 44 24 1c mov 0x1c(%esp),%eax
1cb: 3b 45 08 cmp 0x8(%ebp),%eax
1ce: 0f 8c 64 ff ff ff jl 138 <main+0x35>
exit();
}
wc(fd, argv[i]);
close(fd);
}
exit();
1d4: e8 68 02 00 00 call 441 <exit>
000001d9 <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
1d9: 55 push %ebp
1da: 89 e5 mov %esp,%ebp
1dc: 57 push %edi
1dd: 53 push %ebx
asm volatile("cld; rep stosb" :
1de: 8b 4d 08 mov 0x8(%ebp),%ecx
1e1: 8b 55 10 mov 0x10(%ebp),%edx
1e4: 8b 45 0c mov 0xc(%ebp),%eax
1e7: 89 cb mov %ecx,%ebx
1e9: 89 df mov %ebx,%edi
1eb: 89 d1 mov %edx,%ecx
1ed: fc cld
1ee: f3 aa rep stos %al,%es:(%edi)
1f0: 89 ca mov %ecx,%edx
1f2: 89 fb mov %edi,%ebx
1f4: 89 5d 08 mov %ebx,0x8(%ebp)
1f7: 89 55 10 mov %edx,0x10(%ebp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
1fa: 5b pop %ebx
1fb: 5f pop %edi
1fc: 5d pop %ebp
1fd: c3 ret
000001fe <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
1fe: 55 push %ebp
1ff: 89 e5 mov %esp,%ebp
201: 83 ec 10 sub $0x10,%esp
char *os;
os = s;
204: 8b 45 08 mov 0x8(%ebp),%eax
207: 89 45 fc mov %eax,-0x4(%ebp)
while((*s++ = *t++) != 0)
20a: 90 nop
20b: 8b 45 08 mov 0x8(%ebp),%eax
20e: 8d 50 01 lea 0x1(%eax),%edx
211: 89 55 08 mov %edx,0x8(%ebp)
214: 8b 55 0c mov 0xc(%ebp),%edx
217: 8d 4a 01 lea 0x1(%edx),%ecx
21a: 89 4d 0c mov %ecx,0xc(%ebp)
21d: 0f b6 12 movzbl (%edx),%edx
220: 88 10 mov %dl,(%eax)
222: 0f b6 00 movzbl (%eax),%eax
225: 84 c0 test %al,%al
227: 75 e2 jne 20b <strcpy+0xd>
;
return os;
229: 8b 45 fc mov -0x4(%ebp),%eax
}
22c: c9 leave
22d: c3 ret
0000022e <strcmp>:
int
strcmp(const char *p, const char *q)
{
22e: 55 push %ebp
22f: 89 e5 mov %esp,%ebp
while(*p && *p == *q)
231: eb 08 jmp 23b <strcmp+0xd>
p++, q++;
233: 83 45 08 01 addl $0x1,0x8(%ebp)
237: 83 45 0c 01 addl $0x1,0xc(%ebp)
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
23b: 8b 45 08 mov 0x8(%ebp),%eax
23e: 0f b6 00 movzbl (%eax),%eax
241: 84 c0 test %al,%al
243: 74 10 je 255 <strcmp+0x27>
245: 8b 45 08 mov 0x8(%ebp),%eax
248: 0f b6 10 movzbl (%eax),%edx
24b: 8b 45 0c mov 0xc(%ebp),%eax
24e: 0f b6 00 movzbl (%eax),%eax
251: 38 c2 cmp %al,%dl
253: 74 de je 233 <strcmp+0x5>
p++, q++;
return (uchar)*p - (uchar)*q;
255: 8b 45 08 mov 0x8(%ebp),%eax
258: 0f b6 00 movzbl (%eax),%eax
25b: 0f b6 d0 movzbl %al,%edx
25e: 8b 45 0c mov 0xc(%ebp),%eax
261: 0f b6 00 movzbl (%eax),%eax
264: 0f b6 c0 movzbl %al,%eax
267: 29 c2 sub %eax,%edx
269: 89 d0 mov %edx,%eax
}
26b: 5d pop %ebp
26c: c3 ret
0000026d <strlen>:
uint
strlen(char *s)
{
26d: 55 push %ebp
26e: 89 e5 mov %esp,%ebp
270: 83 ec 10 sub $0x10,%esp
int n;
for(n = 0; s[n]; n++)
273: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
27a: eb 04 jmp 280 <strlen+0x13>
27c: 83 45 fc 01 addl $0x1,-0x4(%ebp)
280: 8b 55 fc mov -0x4(%ebp),%edx
283: 8b 45 08 mov 0x8(%ebp),%eax
286: 01 d0 add %edx,%eax
288: 0f b6 00 movzbl (%eax),%eax
28b: 84 c0 test %al,%al
28d: 75 ed jne 27c <strlen+0xf>
;
return n;
28f: 8b 45 fc mov -0x4(%ebp),%eax
}
292: c9 leave
293: c3 ret
00000294 <memset>:
void*
memset(void *dst, int c, uint n)
{
294: 55 push %ebp
295: 89 e5 mov %esp,%ebp
297: 83 ec 0c sub $0xc,%esp
stosb(dst, c, n);
29a: 8b 45 10 mov 0x10(%ebp),%eax
29d: 89 44 24 08 mov %eax,0x8(%esp)
2a1: 8b 45 0c mov 0xc(%ebp),%eax
2a4: 89 44 24 04 mov %eax,0x4(%esp)
2a8: 8b 45 08 mov 0x8(%ebp),%eax
2ab: 89 04 24 mov %eax,(%esp)
2ae: e8 26 ff ff ff call 1d9 <stosb>
return dst;
2b3: 8b 45 08 mov 0x8(%ebp),%eax
}
2b6: c9 leave
2b7: c3 ret
000002b8 <strchr>:
char*
strchr(const char *s, char c)
{
2b8: 55 push %ebp
2b9: 89 e5 mov %esp,%ebp
2bb: 83 ec 04 sub $0x4,%esp
2be: 8b 45 0c mov 0xc(%ebp),%eax
2c1: 88 45 fc mov %al,-0x4(%ebp)
for(; *s; s++)
2c4: eb 14 jmp 2da <strchr+0x22>
if(*s == c)
2c6: 8b 45 08 mov 0x8(%ebp),%eax
2c9: 0f b6 00 movzbl (%eax),%eax
2cc: 3a 45 fc cmp -0x4(%ebp),%al
2cf: 75 05 jne 2d6 <strchr+0x1e>
return (char*)s;
2d1: 8b 45 08 mov 0x8(%ebp),%eax
2d4: eb 13 jmp 2e9 <strchr+0x31>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
2d6: 83 45 08 01 addl $0x1,0x8(%ebp)
2da: 8b 45 08 mov 0x8(%ebp),%eax
2dd: 0f b6 00 movzbl (%eax),%eax
2e0: 84 c0 test %al,%al
2e2: 75 e2 jne 2c6 <strchr+0xe>
if(*s == c)
return (char*)s;
return 0;
2e4: b8 00 00 00 00 mov $0x0,%eax
}
2e9: c9 leave
2ea: c3 ret
000002eb <gets>:
char*
gets(char *buf, int max)
{
2eb: 55 push %ebp
2ec: 89 e5 mov %esp,%ebp
2ee: 83 ec 28 sub $0x28,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
2f1: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
2f8: eb 4c jmp 346 <gets+0x5b>
cc = read(0, &c, 1);
2fa: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
301: 00
302: 8d 45 ef lea -0x11(%ebp),%eax
305: 89 44 24 04 mov %eax,0x4(%esp)
309: c7 04 24 00 00 00 00 movl $0x0,(%esp)
310: e8 44 01 00 00 call 459 <read>
315: 89 45 f0 mov %eax,-0x10(%ebp)
if(cc < 1)
318: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
31c: 7f 02 jg 320 <gets+0x35>
break;
31e: eb 31 jmp 351 <gets+0x66>
buf[i++] = c;
320: 8b 45 f4 mov -0xc(%ebp),%eax
323: 8d 50 01 lea 0x1(%eax),%edx
326: 89 55 f4 mov %edx,-0xc(%ebp)
329: 89 c2 mov %eax,%edx
32b: 8b 45 08 mov 0x8(%ebp),%eax
32e: 01 c2 add %eax,%edx
330: 0f b6 45 ef movzbl -0x11(%ebp),%eax
334: 88 02 mov %al,(%edx)
if(c == '\n' || c == '\r')
336: 0f b6 45 ef movzbl -0x11(%ebp),%eax
33a: 3c 0a cmp $0xa,%al
33c: 74 13 je 351 <gets+0x66>
33e: 0f b6 45 ef movzbl -0x11(%ebp),%eax
342: 3c 0d cmp $0xd,%al
344: 74 0b je 351 <gets+0x66>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
346: 8b 45 f4 mov -0xc(%ebp),%eax
349: 83 c0 01 add $0x1,%eax
34c: 3b 45 0c cmp 0xc(%ebp),%eax
34f: 7c a9 jl 2fa <gets+0xf>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
351: 8b 55 f4 mov -0xc(%ebp),%edx
354: 8b 45 08 mov 0x8(%ebp),%eax
357: 01 d0 add %edx,%eax
359: c6 00 00 movb $0x0,(%eax)
return buf;
35c: 8b 45 08 mov 0x8(%ebp),%eax
}
35f: c9 leave
360: c3 ret
00000361 <stat>:
int
stat(char *n, struct stat *st)
{
361: 55 push %ebp
362: 89 e5 mov %esp,%ebp
364: 83 ec 28 sub $0x28,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
367: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
36e: 00
36f: 8b 45 08 mov 0x8(%ebp),%eax
372: 89 04 24 mov %eax,(%esp)
375: e8 07 01 00 00 call 481 <open>
37a: 89 45 f4 mov %eax,-0xc(%ebp)
if(fd < 0)
37d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
381: 79 07 jns 38a <stat+0x29>
return -1;
383: b8 ff ff ff ff mov $0xffffffff,%eax
388: eb 23 jmp 3ad <stat+0x4c>
r = fstat(fd, st);
38a: 8b 45 0c mov 0xc(%ebp),%eax
38d: 89 44 24 04 mov %eax,0x4(%esp)
391: 8b 45 f4 mov -0xc(%ebp),%eax
394: 89 04 24 mov %eax,(%esp)
397: e8 fd 00 00 00 call 499 <fstat>
39c: 89 45 f0 mov %eax,-0x10(%ebp)
close(fd);
39f: 8b 45 f4 mov -0xc(%ebp),%eax
3a2: 89 04 24 mov %eax,(%esp)
3a5: e8 bf 00 00 00 call 469 <close>
return r;
3aa: 8b 45 f0 mov -0x10(%ebp),%eax
}
3ad: c9 leave
3ae: c3 ret
000003af <atoi>:
int
atoi(const char *s)
{
3af: 55 push %ebp
3b0: 89 e5 mov %esp,%ebp
3b2: 83 ec 10 sub $0x10,%esp
int n;
n = 0;
3b5: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
while('0' <= *s && *s <= '9')
3bc: eb 25 jmp 3e3 <atoi+0x34>
n = n*10 + *s++ - '0';
3be: 8b 55 fc mov -0x4(%ebp),%edx
3c1: 89 d0 mov %edx,%eax
3c3: c1 e0 02 shl $0x2,%eax
3c6: 01 d0 add %edx,%eax
3c8: 01 c0 add %eax,%eax
3ca: 89 c1 mov %eax,%ecx
3cc: 8b 45 08 mov 0x8(%ebp),%eax
3cf: 8d 50 01 lea 0x1(%eax),%edx
3d2: 89 55 08 mov %edx,0x8(%ebp)
3d5: 0f b6 00 movzbl (%eax),%eax
3d8: 0f be c0 movsbl %al,%eax
3db: 01 c8 add %ecx,%eax
3dd: 83 e8 30 sub $0x30,%eax
3e0: 89 45 fc mov %eax,-0x4(%ebp)
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
3e3: 8b 45 08 mov 0x8(%ebp),%eax
3e6: 0f b6 00 movzbl (%eax),%eax
3e9: 3c 2f cmp $0x2f,%al
3eb: 7e 0a jle 3f7 <atoi+0x48>
3ed: 8b 45 08 mov 0x8(%ebp),%eax
3f0: 0f b6 00 movzbl (%eax),%eax
3f3: 3c 39 cmp $0x39,%al
3f5: 7e c7 jle 3be <atoi+0xf>
n = n*10 + *s++ - '0';
return n;
3f7: 8b 45 fc mov -0x4(%ebp),%eax
}
3fa: c9 leave
3fb: c3 ret
000003fc <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
3fc: 55 push %ebp
3fd: 89 e5 mov %esp,%ebp
3ff: 83 ec 10 sub $0x10,%esp
char *dst, *src;
dst = vdst;
402: 8b 45 08 mov 0x8(%ebp),%eax
405: 89 45 fc mov %eax,-0x4(%ebp)
src = vsrc;
408: 8b 45 0c mov 0xc(%ebp),%eax
40b: 89 45 f8 mov %eax,-0x8(%ebp)
while(n-- > 0)
40e: eb 17 jmp 427 <memmove+0x2b>
*dst++ = *src++;
410: 8b 45 fc mov -0x4(%ebp),%eax
413: 8d 50 01 lea 0x1(%eax),%edx
416: 89 55 fc mov %edx,-0x4(%ebp)
419: 8b 55 f8 mov -0x8(%ebp),%edx
41c: 8d 4a 01 lea 0x1(%edx),%ecx
41f: 89 4d f8 mov %ecx,-0x8(%ebp)
422: 0f b6 12 movzbl (%edx),%edx
425: 88 10 mov %dl,(%eax)
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
427: 8b 45 10 mov 0x10(%ebp),%eax
42a: 8d 50 ff lea -0x1(%eax),%edx
42d: 89 55 10 mov %edx,0x10(%ebp)
430: 85 c0 test %eax,%eax
432: 7f dc jg 410 <memmove+0x14>
*dst++ = *src++;
return vdst;
434: 8b 45 08 mov 0x8(%ebp),%eax
}
437: c9 leave
438: c3 ret
00000439 <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
439: b8 01 00 00 00 mov $0x1,%eax
43e: cd 40 int $0x40
440: c3 ret
00000441 <exit>:
SYSCALL(exit)
441: b8 02 00 00 00 mov $0x2,%eax
446: cd 40 int $0x40
448: c3 ret
00000449 <wait>:
SYSCALL(wait)
449: b8 03 00 00 00 mov $0x3,%eax
44e: cd 40 int $0x40
450: c3 ret
00000451 <pipe>:
SYSCALL(pipe)
451: b8 04 00 00 00 mov $0x4,%eax
456: cd 40 int $0x40
458: c3 ret
00000459 <read>:
SYSCALL(read)
459: b8 05 00 00 00 mov $0x5,%eax
45e: cd 40 int $0x40
460: c3 ret
00000461 <write>:
SYSCALL(write)
461: b8 10 00 00 00 mov $0x10,%eax
466: cd 40 int $0x40
468: c3 ret
00000469 <close>:
SYSCALL(close)
469: b8 15 00 00 00 mov $0x15,%eax
46e: cd 40 int $0x40
470: c3 ret
00000471 <kill>:
SYSCALL(kill)
471: b8 06 00 00 00 mov $0x6,%eax
476: cd 40 int $0x40
478: c3 ret
00000479 <exec>:
SYSCALL(exec)
479: b8 07 00 00 00 mov $0x7,%eax
47e: cd 40 int $0x40
480: c3 ret
00000481 <open>:
SYSCALL(open)
481: b8 0f 00 00 00 mov $0xf,%eax
486: cd 40 int $0x40
488: c3 ret
00000489 <mknod>:
SYSCALL(mknod)
489: b8 11 00 00 00 mov $0x11,%eax
48e: cd 40 int $0x40
490: c3 ret
00000491 <unlink>:
SYSCALL(unlink)
491: b8 12 00 00 00 mov $0x12,%eax
496: cd 40 int $0x40
498: c3 ret
00000499 <fstat>:
SYSCALL(fstat)
499: b8 08 00 00 00 mov $0x8,%eax
49e: cd 40 int $0x40
4a0: c3 ret
000004a1 <link>:
SYSCALL(link)
4a1: b8 13 00 00 00 mov $0x13,%eax
4a6: cd 40 int $0x40
4a8: c3 ret
000004a9 <mkdir>:
SYSCALL(mkdir)
4a9: b8 14 00 00 00 mov $0x14,%eax
4ae: cd 40 int $0x40
4b0: c3 ret
000004b1 <chdir>:
SYSCALL(chdir)
4b1: b8 09 00 00 00 mov $0x9,%eax
4b6: cd 40 int $0x40
4b8: c3 ret
000004b9 <dup>:
SYSCALL(dup)
4b9: b8 0a 00 00 00 mov $0xa,%eax
4be: cd 40 int $0x40
4c0: c3 ret
000004c1 <getpid>:
SYSCALL(getpid)
4c1: b8 0b 00 00 00 mov $0xb,%eax
4c6: cd 40 int $0x40
4c8: c3 ret
000004c9 <sbrk>:
SYSCALL(sbrk)
4c9: b8 0c 00 00 00 mov $0xc,%eax
4ce: cd 40 int $0x40
4d0: c3 ret
000004d1 <sleep>:
SYSCALL(sleep)
4d1: b8 0d 00 00 00 mov $0xd,%eax
4d6: cd 40 int $0x40
4d8: c3 ret
000004d9 <uptime>:
SYSCALL(uptime)
4d9: b8 0e 00 00 00 mov $0xe,%eax
4de: cd 40 int $0x40
4e0: c3 ret
000004e1 <gettime>:
SYSCALL(gettime)
4e1: b8 16 00 00 00 mov $0x16,%eax
4e6: cd 40 int $0x40
4e8: c3 ret
000004e9 <settickets>:
SYSCALL(settickets)
4e9: b8 17 00 00 00 mov $0x17,%eax
4ee: cd 40 int $0x40
4f0: c3 ret
000004f1 <putc>:
#include "stat.h"
#include "user.h"
static void
putc(int fd, char c)
{
4f1: 55 push %ebp
4f2: 89 e5 mov %esp,%ebp
4f4: 83 ec 18 sub $0x18,%esp
4f7: 8b 45 0c mov 0xc(%ebp),%eax
4fa: 88 45 f4 mov %al,-0xc(%ebp)
write(fd, &c, 1);
4fd: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
504: 00
505: 8d 45 f4 lea -0xc(%ebp),%eax
508: 89 44 24 04 mov %eax,0x4(%esp)
50c: 8b 45 08 mov 0x8(%ebp),%eax
50f: 89 04 24 mov %eax,(%esp)
512: e8 4a ff ff ff call 461 <write>
}
517: c9 leave
518: c3 ret
00000519 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
519: 55 push %ebp
51a: 89 e5 mov %esp,%ebp
51c: 56 push %esi
51d: 53 push %ebx
51e: 83 ec 30 sub $0x30,%esp
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
521: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if(sgn && xx < 0){
528: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
52c: 74 17 je 545 <printint+0x2c>
52e: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
532: 79 11 jns 545 <printint+0x2c>
neg = 1;
534: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
x = -xx;
53b: 8b 45 0c mov 0xc(%ebp),%eax
53e: f7 d8 neg %eax
540: 89 45 ec mov %eax,-0x14(%ebp)
543: eb 06 jmp 54b <printint+0x32>
} else {
x = xx;
545: 8b 45 0c mov 0xc(%ebp),%eax
548: 89 45 ec mov %eax,-0x14(%ebp)
}
i = 0;
54b: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
do{
buf[i++] = digits[x % base];
552: 8b 4d f4 mov -0xc(%ebp),%ecx
555: 8d 41 01 lea 0x1(%ecx),%eax
558: 89 45 f4 mov %eax,-0xc(%ebp)
55b: 8b 5d 10 mov 0x10(%ebp),%ebx
55e: 8b 45 ec mov -0x14(%ebp),%eax
561: ba 00 00 00 00 mov $0x0,%edx
566: f7 f3 div %ebx
568: 89 d0 mov %edx,%eax
56a: 0f b6 80 10 0d 00 00 movzbl 0xd10(%eax),%eax
571: 88 44 0d dc mov %al,-0x24(%ebp,%ecx,1)
}while((x /= base) != 0);
575: 8b 75 10 mov 0x10(%ebp),%esi
578: 8b 45 ec mov -0x14(%ebp),%eax
57b: ba 00 00 00 00 mov $0x0,%edx
580: f7 f6 div %esi
582: 89 45 ec mov %eax,-0x14(%ebp)
585: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
589: 75 c7 jne 552 <printint+0x39>
if(neg)
58b: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
58f: 74 10 je 5a1 <printint+0x88>
buf[i++] = '-';
591: 8b 45 f4 mov -0xc(%ebp),%eax
594: 8d 50 01 lea 0x1(%eax),%edx
597: 89 55 f4 mov %edx,-0xc(%ebp)
59a: c6 44 05 dc 2d movb $0x2d,-0x24(%ebp,%eax,1)
while(--i >= 0)
59f: eb 1f jmp 5c0 <printint+0xa7>
5a1: eb 1d jmp 5c0 <printint+0xa7>
putc(fd, buf[i]);
5a3: 8d 55 dc lea -0x24(%ebp),%edx
5a6: 8b 45 f4 mov -0xc(%ebp),%eax
5a9: 01 d0 add %edx,%eax
5ab: 0f b6 00 movzbl (%eax),%eax
5ae: 0f be c0 movsbl %al,%eax
5b1: 89 44 24 04 mov %eax,0x4(%esp)
5b5: 8b 45 08 mov 0x8(%ebp),%eax
5b8: 89 04 24 mov %eax,(%esp)
5bb: e8 31 ff ff ff call 4f1 <putc>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
5c0: 83 6d f4 01 subl $0x1,-0xc(%ebp)
5c4: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
5c8: 79 d9 jns 5a3 <printint+0x8a>
putc(fd, buf[i]);
}
5ca: 83 c4 30 add $0x30,%esp
5cd: 5b pop %ebx
5ce: 5e pop %esi
5cf: 5d pop %ebp
5d0: c3 ret
000005d1 <printlong>:
static void
printlong(int fd, unsigned long long xx, int base, int sgn)
{
5d1: 55 push %ebp
5d2: 89 e5 mov %esp,%ebp
5d4: 83 ec 38 sub $0x38,%esp
5d7: 8b 45 0c mov 0xc(%ebp),%eax
5da: 89 45 e0 mov %eax,-0x20(%ebp)
5dd: 8b 45 10 mov 0x10(%ebp),%eax
5e0: 89 45 e4 mov %eax,-0x1c(%ebp)
// Force hexadecimal
uint upper, lower;
upper = xx >> 32;
5e3: 8b 45 e0 mov -0x20(%ebp),%eax
5e6: 8b 55 e4 mov -0x1c(%ebp),%edx
5e9: 89 d0 mov %edx,%eax
5eb: 31 d2 xor %edx,%edx
5ed: 89 45 f4 mov %eax,-0xc(%ebp)
lower = xx & 0xffffffff;
5f0: 8b 45 e0 mov -0x20(%ebp),%eax
5f3: 89 45 f0 mov %eax,-0x10(%ebp)
if(upper) printint(fd, upper, 16, 0);
5f6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
5fa: 74 22 je 61e <printlong+0x4d>
5fc: 8b 45 f4 mov -0xc(%ebp),%eax
5ff: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
606: 00
607: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
60e: 00
60f: 89 44 24 04 mov %eax,0x4(%esp)
613: 8b 45 08 mov 0x8(%ebp),%eax
616: 89 04 24 mov %eax,(%esp)
619: e8 fb fe ff ff call 519 <printint>
printint(fd, lower, 16, 0);
61e: 8b 45 f0 mov -0x10(%ebp),%eax
621: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
628: 00
629: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
630: 00
631: 89 44 24 04 mov %eax,0x4(%esp)
635: 8b 45 08 mov 0x8(%ebp),%eax
638: 89 04 24 mov %eax,(%esp)
63b: e8 d9 fe ff ff call 519 <printint>
}
640: c9 leave
641: c3 ret
00000642 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
// bdg 10/05/2015: Add %l
void
printf(int fd, char *fmt, ...)
{
642: 55 push %ebp
643: 89 e5 mov %esp,%ebp
645: 83 ec 48 sub $0x48,%esp
char *s;
int c, i, state;
uint *ap;
state = 0;
648: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
ap = (uint*)(void*)&fmt + 1;
64f: 8d 45 0c lea 0xc(%ebp),%eax
652: 83 c0 04 add $0x4,%eax
655: 89 45 e8 mov %eax,-0x18(%ebp)
for(i = 0; fmt[i]; i++){
658: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
65f: e9 ba 01 00 00 jmp 81e <printf+0x1dc>
c = fmt[i] & 0xff;
664: 8b 55 0c mov 0xc(%ebp),%edx
667: 8b 45 f0 mov -0x10(%ebp),%eax
66a: 01 d0 add %edx,%eax
66c: 0f b6 00 movzbl (%eax),%eax
66f: 0f be c0 movsbl %al,%eax
672: 25 ff 00 00 00 and $0xff,%eax
677: 89 45 e4 mov %eax,-0x1c(%ebp)
if(state == 0){
67a: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
67e: 75 2c jne 6ac <printf+0x6a>
if(c == '%'){
680: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
684: 75 0c jne 692 <printf+0x50>
state = '%';
686: c7 45 ec 25 00 00 00 movl $0x25,-0x14(%ebp)
68d: e9 88 01 00 00 jmp 81a <printf+0x1d8>
} else {
putc(fd, c);
692: 8b 45 e4 mov -0x1c(%ebp),%eax
695: 0f be c0 movsbl %al,%eax
698: 89 44 24 04 mov %eax,0x4(%esp)
69c: 8b 45 08 mov 0x8(%ebp),%eax
69f: 89 04 24 mov %eax,(%esp)
6a2: e8 4a fe ff ff call 4f1 <putc>
6a7: e9 6e 01 00 00 jmp 81a <printf+0x1d8>
}
} else if(state == '%'){
6ac: 83 7d ec 25 cmpl $0x25,-0x14(%ebp)
6b0: 0f 85 64 01 00 00 jne 81a <printf+0x1d8>
if(c == 'd'){
6b6: 83 7d e4 64 cmpl $0x64,-0x1c(%ebp)
6ba: 75 2d jne 6e9 <printf+0xa7>
printint(fd, *ap, 10, 1);
6bc: 8b 45 e8 mov -0x18(%ebp),%eax
6bf: 8b 00 mov (%eax),%eax
6c1: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp)
6c8: 00
6c9: c7 44 24 08 0a 00 00 movl $0xa,0x8(%esp)
6d0: 00
6d1: 89 44 24 04 mov %eax,0x4(%esp)
6d5: 8b 45 08 mov 0x8(%ebp),%eax
6d8: 89 04 24 mov %eax,(%esp)
6db: e8 39 fe ff ff call 519 <printint>
ap++;
6e0: 83 45 e8 04 addl $0x4,-0x18(%ebp)
6e4: e9 2a 01 00 00 jmp 813 <printf+0x1d1>
} else if(c == 'l') {
6e9: 83 7d e4 6c cmpl $0x6c,-0x1c(%ebp)
6ed: 75 38 jne 727 <printf+0xe5>
printlong(fd, *(unsigned long long *)ap, 10, 0);
6ef: 8b 45 e8 mov -0x18(%ebp),%eax
6f2: 8b 50 04 mov 0x4(%eax),%edx
6f5: 8b 00 mov (%eax),%eax
6f7: c7 44 24 10 00 00 00 movl $0x0,0x10(%esp)
6fe: 00
6ff: c7 44 24 0c 0a 00 00 movl $0xa,0xc(%esp)
706: 00
707: 89 44 24 04 mov %eax,0x4(%esp)
70b: 89 54 24 08 mov %edx,0x8(%esp)
70f: 8b 45 08 mov 0x8(%ebp),%eax
712: 89 04 24 mov %eax,(%esp)
715: e8 b7 fe ff ff call 5d1 <printlong>
// long longs take up 2 argument slots
ap++;
71a: 83 45 e8 04 addl $0x4,-0x18(%ebp)
ap++;
71e: 83 45 e8 04 addl $0x4,-0x18(%ebp)
722: e9 ec 00 00 00 jmp 813 <printf+0x1d1>
} else if(c == 'x' || c == 'p'){
727: 83 7d e4 78 cmpl $0x78,-0x1c(%ebp)
72b: 74 06 je 733 <printf+0xf1>
72d: 83 7d e4 70 cmpl $0x70,-0x1c(%ebp)
731: 75 2d jne 760 <printf+0x11e>
printint(fd, *ap, 16, 0);
733: 8b 45 e8 mov -0x18(%ebp),%eax
736: 8b 00 mov (%eax),%eax
738: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
73f: 00
740: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
747: 00
748: 89 44 24 04 mov %eax,0x4(%esp)
74c: 8b 45 08 mov 0x8(%ebp),%eax
74f: 89 04 24 mov %eax,(%esp)
752: e8 c2 fd ff ff call 519 <printint>
ap++;
757: 83 45 e8 04 addl $0x4,-0x18(%ebp)
75b: e9 b3 00 00 00 jmp 813 <printf+0x1d1>
} else if(c == 's'){
760: 83 7d e4 73 cmpl $0x73,-0x1c(%ebp)
764: 75 45 jne 7ab <printf+0x169>
s = (char*)*ap;
766: 8b 45 e8 mov -0x18(%ebp),%eax
769: 8b 00 mov (%eax),%eax
76b: 89 45 f4 mov %eax,-0xc(%ebp)
ap++;
76e: 83 45 e8 04 addl $0x4,-0x18(%ebp)
if(s == 0)
772: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
776: 75 09 jne 781 <printf+0x13f>
s = "(null)";
778: c7 45 f4 84 0a 00 00 movl $0xa84,-0xc(%ebp)
while(*s != 0){
77f: eb 1e jmp 79f <printf+0x15d>
781: eb 1c jmp 79f <printf+0x15d>
putc(fd, *s);
783: 8b 45 f4 mov -0xc(%ebp),%eax
786: 0f b6 00 movzbl (%eax),%eax
789: 0f be c0 movsbl %al,%eax
78c: 89 44 24 04 mov %eax,0x4(%esp)
790: 8b 45 08 mov 0x8(%ebp),%eax
793: 89 04 24 mov %eax,(%esp)
796: e8 56 fd ff ff call 4f1 <putc>
s++;
79b: 83 45 f4 01 addl $0x1,-0xc(%ebp)
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
79f: 8b 45 f4 mov -0xc(%ebp),%eax
7a2: 0f b6 00 movzbl (%eax),%eax
7a5: 84 c0 test %al,%al
7a7: 75 da jne 783 <printf+0x141>
7a9: eb 68 jmp 813 <printf+0x1d1>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
7ab: 83 7d e4 63 cmpl $0x63,-0x1c(%ebp)
7af: 75 1d jne 7ce <printf+0x18c>
putc(fd, *ap);
7b1: 8b 45 e8 mov -0x18(%ebp),%eax
7b4: 8b 00 mov (%eax),%eax
7b6: 0f be c0 movsbl %al,%eax
7b9: 89 44 24 04 mov %eax,0x4(%esp)
7bd: 8b 45 08 mov 0x8(%ebp),%eax
7c0: 89 04 24 mov %eax,(%esp)
7c3: e8 29 fd ff ff call 4f1 <putc>
ap++;
7c8: 83 45 e8 04 addl $0x4,-0x18(%ebp)
7cc: eb 45 jmp 813 <printf+0x1d1>
} else if(c == '%'){
7ce: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
7d2: 75 17 jne 7eb <printf+0x1a9>
putc(fd, c);
7d4: 8b 45 e4 mov -0x1c(%ebp),%eax
7d7: 0f be c0 movsbl %al,%eax
7da: 89 44 24 04 mov %eax,0x4(%esp)
7de: 8b 45 08 mov 0x8(%ebp),%eax
7e1: 89 04 24 mov %eax,(%esp)
7e4: e8 08 fd ff ff call 4f1 <putc>
7e9: eb 28 jmp 813 <printf+0x1d1>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
7eb: c7 44 24 04 25 00 00 movl $0x25,0x4(%esp)
7f2: 00
7f3: 8b 45 08 mov 0x8(%ebp),%eax
7f6: 89 04 24 mov %eax,(%esp)
7f9: e8 f3 fc ff ff call 4f1 <putc>
putc(fd, c);
7fe: 8b 45 e4 mov -0x1c(%ebp),%eax
801: 0f be c0 movsbl %al,%eax
804: 89 44 24 04 mov %eax,0x4(%esp)
808: 8b 45 08 mov 0x8(%ebp),%eax
80b: 89 04 24 mov %eax,(%esp)
80e: e8 de fc ff ff call 4f1 <putc>
}
state = 0;
813: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
81a: 83 45 f0 01 addl $0x1,-0x10(%ebp)
81e: 8b 55 0c mov 0xc(%ebp),%edx
821: 8b 45 f0 mov -0x10(%ebp),%eax
824: 01 d0 add %edx,%eax
826: 0f b6 00 movzbl (%eax),%eax
829: 84 c0 test %al,%al
82b: 0f 85 33 fe ff ff jne 664 <printf+0x22>
putc(fd, c);
}
state = 0;
}
}
}
831: c9 leave
832: c3 ret
00000833 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
833: 55 push %ebp
834: 89 e5 mov %esp,%ebp
836: 83 ec 10 sub $0x10,%esp
Header *bp, *p;
bp = (Header*)ap - 1;
839: 8b 45 08 mov 0x8(%ebp),%eax
83c: 83 e8 08 sub $0x8,%eax
83f: 89 45 f8 mov %eax,-0x8(%ebp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
842: a1 48 0d 00 00 mov 0xd48,%eax
847: 89 45 fc mov %eax,-0x4(%ebp)
84a: eb 24 jmp 870 <free+0x3d>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
84c: 8b 45 fc mov -0x4(%ebp),%eax
84f: 8b 00 mov (%eax),%eax
851: 3b 45 fc cmp -0x4(%ebp),%eax
854: 77 12 ja 868 <free+0x35>
856: 8b 45 f8 mov -0x8(%ebp),%eax
859: 3b 45 fc cmp -0x4(%ebp),%eax
85c: 77 24 ja 882 <free+0x4f>
85e: 8b 45 fc mov -0x4(%ebp),%eax
861: 8b 00 mov (%eax),%eax
863: 3b 45 f8 cmp -0x8(%ebp),%eax
866: 77 1a ja 882 <free+0x4f>
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
868: 8b 45 fc mov -0x4(%ebp),%eax
86b: 8b 00 mov (%eax),%eax
86d: 89 45 fc mov %eax,-0x4(%ebp)
870: 8b 45 f8 mov -0x8(%ebp),%eax
873: 3b 45 fc cmp -0x4(%ebp),%eax
876: 76 d4 jbe 84c <free+0x19>
878: 8b 45 fc mov -0x4(%ebp),%eax
87b: 8b 00 mov (%eax),%eax
87d: 3b 45 f8 cmp -0x8(%ebp),%eax
880: 76 ca jbe 84c <free+0x19>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
882: 8b 45 f8 mov -0x8(%ebp),%eax
885: 8b 40 04 mov 0x4(%eax),%eax
888: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
88f: 8b 45 f8 mov -0x8(%ebp),%eax
892: 01 c2 add %eax,%edx
894: 8b 45 fc mov -0x4(%ebp),%eax
897: 8b 00 mov (%eax),%eax
899: 39 c2 cmp %eax,%edx
89b: 75 24 jne 8c1 <free+0x8e>
bp->s.size += p->s.ptr->s.size;
89d: 8b 45 f8 mov -0x8(%ebp),%eax
8a0: 8b 50 04 mov 0x4(%eax),%edx
8a3: 8b 45 fc mov -0x4(%ebp),%eax
8a6: 8b 00 mov (%eax),%eax
8a8: 8b 40 04 mov 0x4(%eax),%eax
8ab: 01 c2 add %eax,%edx
8ad: 8b 45 f8 mov -0x8(%ebp),%eax
8b0: 89 50 04 mov %edx,0x4(%eax)
bp->s.ptr = p->s.ptr->s.ptr;
8b3: 8b 45 fc mov -0x4(%ebp),%eax
8b6: 8b 00 mov (%eax),%eax
8b8: 8b 10 mov (%eax),%edx
8ba: 8b 45 f8 mov -0x8(%ebp),%eax
8bd: 89 10 mov %edx,(%eax)
8bf: eb 0a jmp 8cb <free+0x98>
} else
bp->s.ptr = p->s.ptr;
8c1: 8b 45 fc mov -0x4(%ebp),%eax
8c4: 8b 10 mov (%eax),%edx
8c6: 8b 45 f8 mov -0x8(%ebp),%eax
8c9: 89 10 mov %edx,(%eax)
if(p + p->s.size == bp){
8cb: 8b 45 fc mov -0x4(%ebp),%eax
8ce: 8b 40 04 mov 0x4(%eax),%eax
8d1: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
8d8: 8b 45 fc mov -0x4(%ebp),%eax
8db: 01 d0 add %edx,%eax
8dd: 3b 45 f8 cmp -0x8(%ebp),%eax
8e0: 75 20 jne 902 <free+0xcf>
p->s.size += bp->s.size;
8e2: 8b 45 fc mov -0x4(%ebp),%eax
8e5: 8b 50 04 mov 0x4(%eax),%edx
8e8: 8b 45 f8 mov -0x8(%ebp),%eax
8eb: 8b 40 04 mov 0x4(%eax),%eax
8ee: 01 c2 add %eax,%edx
8f0: 8b 45 fc mov -0x4(%ebp),%eax
8f3: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
8f6: 8b 45 f8 mov -0x8(%ebp),%eax
8f9: 8b 10 mov (%eax),%edx
8fb: 8b 45 fc mov -0x4(%ebp),%eax
8fe: 89 10 mov %edx,(%eax)
900: eb 08 jmp 90a <free+0xd7>
} else
p->s.ptr = bp;
902: 8b 45 fc mov -0x4(%ebp),%eax
905: 8b 55 f8 mov -0x8(%ebp),%edx
908: 89 10 mov %edx,(%eax)
freep = p;
90a: 8b 45 fc mov -0x4(%ebp),%eax
90d: a3 48 0d 00 00 mov %eax,0xd48
}
912: c9 leave
913: c3 ret
00000914 <morecore>:
static Header*
morecore(uint nu)
{
914: 55 push %ebp
915: 89 e5 mov %esp,%ebp
917: 83 ec 28 sub $0x28,%esp
char *p;
Header *hp;
if(nu < 4096)
91a: 81 7d 08 ff 0f 00 00 cmpl $0xfff,0x8(%ebp)
921: 77 07 ja 92a <morecore+0x16>
nu = 4096;
923: c7 45 08 00 10 00 00 movl $0x1000,0x8(%ebp)
p = sbrk(nu * sizeof(Header));
92a: 8b 45 08 mov 0x8(%ebp),%eax
92d: c1 e0 03 shl $0x3,%eax
930: 89 04 24 mov %eax,(%esp)
933: e8 91 fb ff ff call 4c9 <sbrk>
938: 89 45 f4 mov %eax,-0xc(%ebp)
if(p == (char*)-1)
93b: 83 7d f4 ff cmpl $0xffffffff,-0xc(%ebp)
93f: 75 07 jne 948 <morecore+0x34>
return 0;
941: b8 00 00 00 00 mov $0x0,%eax
946: eb 22 jmp 96a <morecore+0x56>
hp = (Header*)p;
948: 8b 45 f4 mov -0xc(%ebp),%eax
94b: 89 45 f0 mov %eax,-0x10(%ebp)
hp->s.size = nu;
94e: 8b 45 f0 mov -0x10(%ebp),%eax
951: 8b 55 08 mov 0x8(%ebp),%edx
954: 89 50 04 mov %edx,0x4(%eax)
free((void*)(hp + 1));
957: 8b 45 f0 mov -0x10(%ebp),%eax
95a: 83 c0 08 add $0x8,%eax
95d: 89 04 24 mov %eax,(%esp)
960: e8 ce fe ff ff call 833 <free>
return freep;
965: a1 48 0d 00 00 mov 0xd48,%eax
}
96a: c9 leave
96b: c3 ret
0000096c <malloc>:
void*
malloc(uint nbytes)
{
96c: 55 push %ebp
96d: 89 e5 mov %esp,%ebp
96f: 83 ec 28 sub $0x28,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
972: 8b 45 08 mov 0x8(%ebp),%eax
975: 83 c0 07 add $0x7,%eax
978: c1 e8 03 shr $0x3,%eax
97b: 83 c0 01 add $0x1,%eax
97e: 89 45 ec mov %eax,-0x14(%ebp)
if((prevp = freep) == 0){
981: a1 48 0d 00 00 mov 0xd48,%eax
986: 89 45 f0 mov %eax,-0x10(%ebp)
989: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
98d: 75 23 jne 9b2 <malloc+0x46>
base.s.ptr = freep = prevp = &base;
98f: c7 45 f0 40 0d 00 00 movl $0xd40,-0x10(%ebp)
996: 8b 45 f0 mov -0x10(%ebp),%eax
999: a3 48 0d 00 00 mov %eax,0xd48
99e: a1 48 0d 00 00 mov 0xd48,%eax
9a3: a3 40 0d 00 00 mov %eax,0xd40
base.s.size = 0;
9a8: c7 05 44 0d 00 00 00 movl $0x0,0xd44
9af: 00 00 00
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
9b2: 8b 45 f0 mov -0x10(%ebp),%eax
9b5: 8b 00 mov (%eax),%eax
9b7: 89 45 f4 mov %eax,-0xc(%ebp)
if(p->s.size >= nunits){
9ba: 8b 45 f4 mov -0xc(%ebp),%eax
9bd: 8b 40 04 mov 0x4(%eax),%eax
9c0: 3b 45 ec cmp -0x14(%ebp),%eax
9c3: 72 4d jb a12 <malloc+0xa6>
if(p->s.size == nunits)
9c5: 8b 45 f4 mov -0xc(%ebp),%eax
9c8: 8b 40 04 mov 0x4(%eax),%eax
9cb: 3b 45 ec cmp -0x14(%ebp),%eax
9ce: 75 0c jne 9dc <malloc+0x70>
prevp->s.ptr = p->s.ptr;
9d0: 8b 45 f4 mov -0xc(%ebp),%eax
9d3: 8b 10 mov (%eax),%edx
9d5: 8b 45 f0 mov -0x10(%ebp),%eax
9d8: 89 10 mov %edx,(%eax)
9da: eb 26 jmp a02 <malloc+0x96>
else {
p->s.size -= nunits;
9dc: 8b 45 f4 mov -0xc(%ebp),%eax
9df: 8b 40 04 mov 0x4(%eax),%eax
9e2: 2b 45 ec sub -0x14(%ebp),%eax
9e5: 89 c2 mov %eax,%edx
9e7: 8b 45 f4 mov -0xc(%ebp),%eax
9ea: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
9ed: 8b 45 f4 mov -0xc(%ebp),%eax
9f0: 8b 40 04 mov 0x4(%eax),%eax
9f3: c1 e0 03 shl $0x3,%eax
9f6: 01 45 f4 add %eax,-0xc(%ebp)
p->s.size = nunits;
9f9: 8b 45 f4 mov -0xc(%ebp),%eax
9fc: 8b 55 ec mov -0x14(%ebp),%edx
9ff: 89 50 04 mov %edx,0x4(%eax)
}
freep = prevp;
a02: 8b 45 f0 mov -0x10(%ebp),%eax
a05: a3 48 0d 00 00 mov %eax,0xd48
return (void*)(p + 1);
a0a: 8b 45 f4 mov -0xc(%ebp),%eax
a0d: 83 c0 08 add $0x8,%eax
a10: eb 38 jmp a4a <malloc+0xde>
}
if(p == freep)
a12: a1 48 0d 00 00 mov 0xd48,%eax
a17: 39 45 f4 cmp %eax,-0xc(%ebp)
a1a: 75 1b jne a37 <malloc+0xcb>
if((p = morecore(nunits)) == 0)
a1c: 8b 45 ec mov -0x14(%ebp),%eax
a1f: 89 04 24 mov %eax,(%esp)
a22: e8 ed fe ff ff call 914 <morecore>
a27: 89 45 f4 mov %eax,-0xc(%ebp)
a2a: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
a2e: 75 07 jne a37 <malloc+0xcb>
return 0;
a30: b8 00 00 00 00 mov $0x0,%eax
a35: eb 13 jmp a4a <malloc+0xde>
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
a37: 8b 45 f4 mov -0xc(%ebp),%eax
a3a: 89 45 f0 mov %eax,-0x10(%ebp)
a3d: 8b 45 f4 mov -0xc(%ebp),%eax
a40: 8b 00 mov (%eax),%eax
a42: 89 45 f4 mov %eax,-0xc(%ebp)
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
a45: e9 70 ff ff ff jmp 9ba <malloc+0x4e>
}
a4a: c9 leave
a4b: c3 ret
|
;
; $Id: sdk56670x.asm,v 1.0 2017/11/7 10:47:36 prasanna Exp $
;
; This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
;
; Copyright 2007-2020 Broadcom Inc. All rights reserved.
;
;
; This is the default program for the BCM56670.
; There s one LED processors on BCM56670.
; Each LED processor accomodates 64 ports.
; LED processor 0 : Physical Ports 1-64
;
; To start the first one, use the following commands from BCM:
;
; led 0 load sdk56670.hex
; led 0 auto on
; led 0 start
;
; The are 2 LEDs per port one for Link(Top) and one for activity(Bottom).
;
; Each chip drives only its own LEDs and needs to write them in the order:
; L01/A01, L02/A02, ..., L63/A63
;
; There are two bits per Ethernet LED for activity with the following colors:
; ZERO, ZERO Black
; ZERO, ONE Amber
; ONE, ZERO Green
;
; This program assumes link status is kept current in bit 0 of RAM byte (0xA0 + portnum).
; Generally, a program running on the main CPU must update these
; locations on link change; see linkscan callback in
; $SDK/src/appl/diag/ledproc.c.
;
; Current implementation:
;
; L01 reflects port 1 link status:
; Black: no link
; Green: Link
;
; A01 reflects port 1 activity status:
; Black: no activity
; Blinking Green and Black: TX activity
; Blinking Amber and Black: RX activity
; Blinking Green and Amber: TX and RX activity
;
;
TICKS EQU 1
SECOND_TICKS EQU (30*TICKS)
TXRX_ALT_TICKS EQU (SECOND_TICKS)
MIN_PORT EQU 0
NUM_PORT EQU 64
MAX_PORT EQU 63
; Assumptions
; Link status is injected by SDK from Linkscan task at PORTDATA offset
;
; Main Update Routine
;
; This routine is called once per tick.
;
update:
ld a,MIN_PORT
port_loop:
call link_status ; Top LED for this port
call chk_activity ; Bottom LED for this port
inc a
cmp a,MAX_PORT
jnz port_loop
; Update various timers
inc (TXRX_ALT_COUNT)
send 248 ; offset to shift bits so as to align LEDs on board intuitively
; Activity status LED update
chk_activity:
call get_txact ;get TX activity
jnc act1 ;TX not active, check if RX active
jmp act2 ;TX active, check if RX active
ret
act1:
call get_rxact
jnc led_black ;no activity
jmp blink_amber ;only RX active
ret
act2:
call get_rxact
jnc blink_green ;only TX active
jmp blink_amg ;TX and RX both active
ret
; Link status LED update
link_status:
call get_link
jnc led_black
jmp led_green
clc
ret
;
; get_link
;
; This routine finds the link status for a port.
; Link info is in bit 0 of the byte read from PORTDATA[port]
;
; Inputs: Port number in a
; Outputs: Carry flag set if link is up, clear if link is down.
; Destroys: b
;
get_link:
clc
ld b,PORTDATA
add b,a
ld b,(b)
tst b,0
ret
;
; get_txact
;
; This routine finds the TX activity status for a port.
; TX activity info is in bit 4 of the byte read from PORTDATA[port]
;
; Inputs: Port number in a
; Outputs: Carry flag set if TX activity is in progress, clear if not..
; Destroys: b
;
get_txact:
clc
ld b,PORTDATA
add b,a
ld b,(b)
tst b,4
ret
;
; get_rxact
;
; This routine finds the RX activity status for a port.
; TX activity info is in bit 5 of the byte read from PORTDATA[port]
;
; Inputs: Port number in a
; Outputs: Carry flag set if RX activity is in progress, clear if not..
; Destroys: b
;
get_rxact:
clc
ld b,PORTDATA
add b,a
ld b,(b)
tst b,5
ret
;
; blink_amber, blink_green, blink_amg
; Alteration between respective colors based on timer
;
blink_amber:
ld b, (TXRX_ALT_COUNT)
and b, TXRX_ALT_TICKS
jnz led_amber
jmp led_black
clc
ret
blink_green:
ld b, (TXRX_ALT_COUNT)
and b, TXRX_ALT_TICKS
jnz led_green
jmp led_black
clc
ret
blink_amg:
ld b, (TXRX_ALT_COUNT)
and b, TXRX_ALT_TICKS
jnz led_amber
jmp led_green
clc
ret
;
; led_black, led_amber, led_green
;
; Inputs: None
; Outputs: Two bits to the LED stream indicating color
; Destroys: None
;
led_black:
pushst ZERO
pack
pushst ZERO
pack
ret
led_amber:
pushst ONE
pack
pushst ZERO
pack
ret
led_green:
pushst ZERO
pack
pushst ONE
pack
ret
;
; Variables (SDK software initializes LED memory from 0xa0-0xff to 0)
;
TXRX_ALT_COUNT equ 0xe0
;
; Port data, which must be updated continually by main CPU's
; linkscan task. See $SDK/src/appl/diag/ledproc.c for examples.
; In this program, bit 0 is assumed to contain the link up/down status.
;
;LED scan chain assembly area
;Offset 0x20680 for LED 0
PORTDATA equ 0xa0 ; Size 4 bytes for each port starting A0,A4 ...
ZERO equ 0xE ; always 0
ONE equ 0xF ; always 1
|
/*
* _____ _____ ________ _
* / __// __// __/\ \//
* | | _| \ | \ \ /
* | |_//| /_ | /_ / \
* \____\\____\\____\/__/\\
*
* Graphics Environment for EXperimentations.
* Copyright (C) 2006 INRIA - Project ALICE
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* If you modify this software, you should include a notice giving the
* name of the person performing the modification, the date of modification,
* and the reason for such modification.
*
* Contact:
*
* ALICE Project - INRIA
* INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* Note that the GNU General Public License does not permit incorporating
* the Software into proprietary programs.
*/
#include <Geex/numerics/lbfgs_interface.h>
#include <LBFGSB/lbfgs.h>
#include <LBFGSB/lbfgsb.h>
#include <HLBFGS/HLBFGS.h>
#include <iostream>
//************* for LBFGS ***********
void funcgrad(ap::real_1d_array& x, double& f, ap::real_1d_array& g);
void lbfgsnewiteration(
const ap::real_1d_array& x,
double f,
const ap::real_1d_array& g
);
//************* for LBFGSB ***********
// uses also funcgrad()
void lbfgsbnewiteration(
const ap::real_1d_array& x,
double f,
const ap::real_1d_array& g
);
//************* for HLBFGS *************
void evalfunc(int N, double* x, double *prev_x, double* f, double* g) ;
void evalfunction_h(int N, double* x, double* prev_x, double* f, double* g, HESSIAN_MATRIX& m_hessian);
void hlbfgsnewiteration(int iter, int call_iter, double *x, double* f, double *g, double* gnorm);
//************ for LMBM *************
extern "C"
{
int lmbmu_(int *n, int *na, int *mcu, int *mc, int *nw,
double *x, double *f, double *rpar, int *ipar, int *iout,
float *time, float *rtim, double *w);
int funder_(int *n, double *x, double *f, double *g, int *iterm);
int lmbmnewiter_(int *iter, int *call_iter, double *x, double* f, double *g, double* gnorm);
};
namespace Geex {
class GlobalOptimizerConfig {
public:
static void set_funcgrad_callback(funcgrad_fp fp){
funcgrad_callback = fp;
}
static void set_newiteration_callback(newiteration_fp fp){
newiteration_callback = fp;
}
static void set_evalhessian_callback(evalhessian_fp fp){
evalhessian_callback = fp;
}
static void newiteration( const double* x, double f, const double* g, double gnorm ){
(*newiteration_callback)(N, x, f, g, gnorm);
}
static void funcgrad(double* x, double& f, double* g ){
(*funcgrad_callback)(N, x, f, g);
}
static void evalhessian(int N, double *x, double &f, double *g, HESSIAN_MATRIX& hessian){
(*evalhessian_callback)(N, x, f, g, hessian);
}
static void set_N(int n){
N = n;
}
private:
static funcgrad_fp funcgrad_callback;
static newiteration_fp newiteration_callback;
static evalhessian_fp evalhessian_callback;
static int N;
};
newiteration_fp GlobalOptimizerConfig::newiteration_callback = nil;
funcgrad_fp GlobalOptimizerConfig::funcgrad_callback = nil;
evalhessian_fp GlobalOptimizerConfig::evalhessian_callback = nil;
int GlobalOptimizerConfig::N = 0;
void show_bfgs_message(int info) {
switch(info) {
case -1: std::cout <<"wrong parameters were specified " << std::endl;
break;
case 0: std::cout <<"interrupted by user " << std::endl;
break;
case 1: std::cout <<"relative function decreasing is less or equal to EpsF " << std::endl;
break;
case 2: std::cout <<" step is less or equal to EpsX" << std::endl;
break;
case 4: std::cout <<"gradient norm is less or equal to EpsG, " << std::endl;
break;
case 5: std::cout <<"number of iterations exceeds MaxIts. " << std::endl;
break;
default:
break;
}
}
void LBFGSOptimizer::optimize( double* x ) {
gx_assert( newiteration_callback != nil ) ;
gx_assert( funcgrad_callback != nil ) ;
gx_assert( n>0 ) ;
gx_assert( x!=nil ) ;
GlobalOptimizerConfig::set_newiteration_callback(newiteration_callback);
GlobalOptimizerConfig::set_funcgrad_callback(funcgrad_callback);
GlobalOptimizerConfig::set_N(n);
int info;
ap::real_1d_array x_ap;
x_ap.setcontent(1, n, x); //duplicates x
lbfgsminimize(n,m,x_ap,epsg,epsf,epsx,max_iter,info);
// copy back the solution
memcpy(x, x_ap.getcontent(), n*sizeof(double));
if(verbose){
show_bfgs_message(info);
}
}
void LBFGSBOptimizer::set_nbd(int nb, int* rhs){
gx_assert (nb>0 && rhs != nil);
if(nbd!=nil) delete [] nbd;
nbd = new int[nb] ;
memcpy(nbd,rhs,nb*sizeof(int));
}
void LBFGSBOptimizer::set_l(int nb, double* rhs){
gx_assert (nb>0 && rhs != nil);
if(l!=nil) delete [] l;
l = new double[nb] ;
memcpy(l,rhs,nb*sizeof(double));
}
void LBFGSBOptimizer::set_u(int nb, double* rhs){
gx_assert (nb>0 && rhs != nil);
if(u!=nil) delete [] u;
u = new double[nb] ;
memcpy(u,rhs,nb*sizeof(double));
}
void LBFGSBOptimizer::optimize( double* x ) {
gx_assert( newiteration_callback != nil ) ;
gx_assert( funcgrad_callback != nil ) ;
gx_assert( n>0 ) ;
gx_assert( nbd != nil ) ;
gx_assert( l != nil ) ;
gx_assert( u != nil ) ;
gx_assert( x != nil ) ;
GlobalOptimizerConfig::set_newiteration_callback(newiteration_callback);
GlobalOptimizerConfig::set_funcgrad_callback(funcgrad_callback);
GlobalOptimizerConfig::set_N(n);
int info;
ap::real_1d_array x_ap;
ap::integer_1d_array nbd_ap;
ap::real_1d_array l_ap, u_ap;
x_ap.setcontent(1, n, x);
nbd_ap.setcontent(1, n, nbd);
l_ap.setcontent(1, n, l);
u_ap.setcontent(1, n, u);
lbfgsbminimize(n, m, x_ap, epsg, epsf, epsx, max_iter, nbd_ap, l_ap, u_ap, info);
memcpy(x, x_ap.getcontent(), n*sizeof(double));
if(verbose){
show_bfgs_message(info);
}
}
HLBFGSOptimizer::HLBFGSOptimizer() {
b_m1qn3 = false; b_cg = false;
}
void HLBFGSOptimizer::optimize( double* x ) {
gx_assert( newiteration_callback != nil ) ;
gx_assert( funcgrad_callback != nil ) ;
gx_assert( n>0 ) ;
gx_assert( x != nil ) ;
GlobalOptimizerConfig::set_newiteration_callback(newiteration_callback);
GlobalOptimizerConfig::set_funcgrad_callback(funcgrad_callback);
GlobalOptimizerConfig::set_N(n);
double parameter[20] ;
int hlbfgs_info[20] ;
//initialize parameters and infos
INIT_HLBFGS(parameter, hlbfgs_info) ;
hlbfgs_info[3] = b_m1qn3?1:0; //determines whether we use m1qn3
hlbfgs_info[4] = max_iter ; // max iterations
hlbfgs_info[10] = b_cg?1:0; //determines whether we use cg
parameter[5] = 0; // disabled
parameter[6] = epsg;
HLBFGS(
n,
m,
x,
evalfunc,
0,
HLBFGS_UPDATE_Hessian,
hlbfgsnewiteration,
parameter,
hlbfgs_info
);
}
HLBFGS_HessOptimizer::HLBFGS_HessOptimizer() {
b_m1qn3 = false; b_cg = false; T = 0;
}
void HLBFGS_HessOptimizer::optimize( double* x ) {
gx_assert( newiteration_callback != nil ) ;
gx_assert( funcgrad_callback != nil ) ;
gx_assert( evalhessian_callback != nil);
gx_assert( n>0 ) ;
gx_assert( x != nil ) ;
GlobalOptimizerConfig::set_newiteration_callback(newiteration_callback);
GlobalOptimizerConfig::set_funcgrad_callback(funcgrad_callback);
GlobalOptimizerConfig::set_evalhessian_callback(evalhessian_callback);
GlobalOptimizerConfig::set_N(n);
double parameter[20] ;
int hlbfgs_info[20] ;
//initialize parameters and infos
INIT_HLBFGS(parameter, hlbfgs_info) ;
hlbfgs_info[4] = max_iter ; // max iterations
hlbfgs_info[6] = T ; // update interval of hessian
hlbfgs_info[7] = 1 ; // 0: without hessian, 1: with accurate hessian
HLBFGS(
n,
m,
x,
evalfunc,
evalfunction_h,
HLBFGS_UPDATE_Hessian,
hlbfgsnewiteration,
parameter,
hlbfgs_info
);
}
LMBMOptimizer::LMBMOptimizer() {
}
void LMBMOptimizer::optimize( double* x ) {
gx_assert( newiteration_callback != nil ) ;
gx_assert( funcgrad_callback != nil ) ;
gx_assert( n>0 ) ;
gx_assert( x != nil ) ;
GlobalOptimizerConfig::set_newiteration_callback(newiteration_callback);
GlobalOptimizerConfig::set_funcgrad_callback(funcgrad_callback);
GlobalOptimizerConfig::set_N(n);
int na = 10; //2 .. 10
int mcu = m; // 3..20
int mc = m; //3..15 <= mcu
double rpar[8];
memset(rpar, 0, sizeof(double)*8);
rpar[1] = -1;
rpar[5] = 0.5;
rpar[7] = 10;
int ipar[7];
memset(ipar, 0, sizeof(int)*7);
ipar[1] = max_iter;
ipar[2] = 2*max_iter;
ipar[4] = -1;
int iout[3];
float time, rtim[2];
time = 0.0;
int nw = 2*(1+9*n+2*n*na+3*na+2*n*(mcu+1)+3*(mcu+2)*(mcu+1)/2+9*(mcu+1)); // multiply factor 2
double *w = new double[nw];
double f = 0;
lmbmu_(&n, &na, &mcu, &mc, &nw, x, &f, rpar, ipar, iout, &time, rtim, w);
delete[] w;
}
}
//-------- global functions for optimizers ----------
//----------LBFGS -------------
void funcgrad(ap::real_1d_array& x, double& f, ap::real_1d_array& g) {
Geex::GlobalOptimizerConfig::funcgrad( x.getcontent(), f, g.getcontent() );
}
void lbfgsnewiteration(
const ap::real_1d_array& x,
double f,
const ap::real_1d_array& g
){
double gnorm2 = 0.0 ;
for(int i=g.getlowbound(); i<=g.gethighbound(); i++) {
gnorm2 += g(i)*g(i) ;
}
gnorm2 = ::sqrt(gnorm2) ;
Geex::GlobalOptimizerConfig::newiteration( x.getcontent(), f, g.getcontent(), gnorm2);
}
void lbfgsbnewiteration(
const ap::real_1d_array& x,
double f,
const ap::real_1d_array& g
){
double gnorm2 = 0.0 ;
for(int i=g.getlowbound(); i<=g.gethighbound(); i++) {
gnorm2 += g(i)*g(i) ;
}
gnorm2 = ::sqrt(gnorm2) ;
Geex::GlobalOptimizerConfig::newiteration( x.getcontent(), f, g.getcontent(), gnorm2);
}
//--------- HLBFGS ------
void evalfunc(int N, double* x, double *prev_x, double* f, double* g){
Geex::GlobalOptimizerConfig::funcgrad(x, *f, g);
}
void hlbfgsnewiteration(int iter, int call_iter, double *x, double* f, double *g, double* gnorm){
Geex::GlobalOptimizerConfig::newiteration(x, *f, g, *gnorm);
}
void evalfunction_h(int N, double* x, double* prev_x, double* f, double* g, HESSIAN_MATRIX& m_hessian){
Geex::GlobalOptimizerConfig::evalhessian(N, x, *f, g, m_hessian);
}
//--------- LMBM ------
int funder_(int *n, double *x, double *f, double *g, int *iterm)
{
Geex::GlobalOptimizerConfig::funcgrad(x, *f, g);
*iterm = 0;
return 0;
}
int lmbmnewiter_(int *iter, int *call_iter, double *x, double* f, double *g, double* gnorm)
{
Geex::GlobalOptimizerConfig::newiteration(x, *f, g, sqrt(*gnorm));
return 0;
}
|
/* Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/core/platform/windows/windows_file_system.h"
#include <Shlwapi.h>
#include <Windows.h>
#include <direct.h>
#include <errno.h>
#include <fcntl.h>
#include <io.h>
#undef StrCat
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include "tensorflow/core/platform/env.h"
#include "tensorflow/core/platform/error.h"
#include "tensorflow/core/platform/file_system_helper.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/strcat.h"
#include "tensorflow/core/platform/windows/error_windows.h"
#include "tensorflow/core/platform/windows/wide_char.h"
#include "tensorflow/core/protobuf/error_codes.pb.h"
// TODO(mrry): Prevent this Windows.h #define from leaking out of our headers.
#undef DeleteFile
namespace tensorflow {
namespace {
// RAII helpers for HANDLEs
const auto CloseHandleFunc = [](HANDLE h) { ::CloseHandle(h); };
typedef std::unique_ptr<void, decltype(CloseHandleFunc)> UniqueCloseHandlePtr;
inline Status IOErrorFromWindowsError(const string& context) {
auto last_error = ::GetLastError();
return IOError(
context + string(" : ") + internal::WindowsGetLastErrorMessage(),
last_error);
}
// PLEASE NOTE: hfile is expected to be an async handle
// (i.e. opened with FILE_FLAG_OVERLAPPED)
SSIZE_T pread(HANDLE hfile, char* src, size_t num_bytes, uint64_t offset) {
assert(num_bytes <= std::numeric_limits<DWORD>::max());
OVERLAPPED overlapped = {0};
ULARGE_INTEGER offset_union;
offset_union.QuadPart = offset;
overlapped.Offset = offset_union.LowPart;
overlapped.OffsetHigh = offset_union.HighPart;
overlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
if (NULL == overlapped.hEvent) {
return -1;
}
SSIZE_T result = 0;
unsigned long bytes_read = 0;
DWORD last_error = ERROR_SUCCESS;
BOOL read_result = ::ReadFile(hfile, src, static_cast<DWORD>(num_bytes),
&bytes_read, &overlapped);
if (TRUE == read_result) {
result = bytes_read;
} else if ((FALSE == read_result) &&
((last_error = GetLastError()) != ERROR_IO_PENDING)) {
result = (last_error == ERROR_HANDLE_EOF) ? 0 : -1;
} else {
if (ERROR_IO_PENDING ==
last_error) { // Otherwise bytes_read already has the result.
BOOL overlapped_result =
::GetOverlappedResult(hfile, &overlapped, &bytes_read, TRUE);
if (FALSE == overlapped_result) {
result = (::GetLastError() == ERROR_HANDLE_EOF) ? 0 : -1;
} else {
result = bytes_read;
}
}
}
::CloseHandle(overlapped.hEvent);
return result;
}
// read() based random-access
class WindowsRandomAccessFile : public RandomAccessFile {
private:
string filename_;
HANDLE hfile_;
public:
WindowsRandomAccessFile(const string& fname, HANDLE hfile)
: filename_(fname), hfile_(hfile) {}
~WindowsRandomAccessFile() override {
if (hfile_ != NULL && hfile_ != INVALID_HANDLE_VALUE) {
::CloseHandle(hfile_);
}
}
Status Name(StringPiece* result) const override {
*result = filename_;
return Status::OK();
}
Status Read(uint64 offset, size_t n, StringPiece* result,
char* scratch) const override {
Status s;
char* dst = scratch;
while (n > 0 && s.ok()) {
size_t requested_read_length;
if (n > std::numeric_limits<DWORD>::max()) {
requested_read_length = std::numeric_limits<DWORD>::max();
} else {
requested_read_length = n;
}
SSIZE_T r = pread(hfile_, dst, requested_read_length, offset);
if (r > 0) {
offset += r;
dst += r;
n -= r;
} else if (r == 0) {
s = Status(error::OUT_OF_RANGE, "Read fewer bytes than requested");
} else if (errno == EINTR || errno == EAGAIN) {
// Retry
} else {
s = IOError(filename_, errno);
}
}
*result = StringPiece(scratch, dst - scratch);
return s;
}
#if defined(TF_CORD_SUPPORT)
Status Read(uint64 offset, size_t n, absl::Cord* cord) const override {
if (n == 0) {
return Status::OK();
}
if (n < 0) {
return errors::InvalidArgument(
"Attempting to read ", n,
" bytes. You cannot read a negative number of bytes.");
}
char* scratch = new char[n];
if (scratch == nullptr) {
return errors::ResourceExhausted("Unable to allocate ", n,
" bytes for file reading.");
}
StringPiece tmp;
Status s = Read(offset, n, &tmp, scratch);
absl::Cord tmp_cord = absl::MakeCordFromExternal(
absl::string_view(static_cast<char*>(scratch), tmp.size()),
[scratch](absl::string_view) { delete[] scratch; });
cord->Append(tmp_cord);
return s;
}
#endif
};
class WindowsWritableFile : public WritableFile {
private:
string filename_;
HANDLE hfile_;
public:
WindowsWritableFile(const string& fname, HANDLE hFile)
: filename_(fname), hfile_(hFile) {}
~WindowsWritableFile() override {
if (hfile_ != NULL && hfile_ != INVALID_HANDLE_VALUE) {
WindowsWritableFile::Close();
}
}
Status Append(StringPiece data) override {
DWORD bytes_written = 0;
DWORD data_size = static_cast<DWORD>(data.size());
BOOL write_result =
::WriteFile(hfile_, data.data(), data_size, &bytes_written, NULL);
if (FALSE == write_result) {
return IOErrorFromWindowsError("Failed to WriteFile: " + filename_);
}
assert(size_t(bytes_written) == data.size());
return Status::OK();
}
#if defined(TF_CORD_SUPPORT)
// \brief Append 'data' to the file.
Status Append(const absl::Cord& cord) override {
for (const auto& chunk : cord.Chunks()) {
DWORD bytes_written = 0;
DWORD data_size = static_cast<DWORD>(chunk.size());
BOOL write_result =
::WriteFile(hfile_, chunk.data(), data_size, &bytes_written, NULL);
if (FALSE == write_result) {
return IOErrorFromWindowsError("Failed to WriteFile: " + filename_);
}
assert(size_t(bytes_written) == chunk.size());
}
return Status::OK();
}
#endif
Status Tell(int64* position) override {
Status result = Flush();
if (!result.ok()) {
return result;
}
*position = SetFilePointer(hfile_, 0, NULL, FILE_CURRENT);
if (*position == INVALID_SET_FILE_POINTER) {
return IOErrorFromWindowsError("Tell(SetFilePointer) failed for: " +
filename_);
}
return Status::OK();
}
Status Close() override {
assert(INVALID_HANDLE_VALUE != hfile_);
Status result = Flush();
if (!result.ok()) {
return result;
}
if (FALSE == ::CloseHandle(hfile_)) {
return IOErrorFromWindowsError("CloseHandle failed for: " + filename_);
}
hfile_ = INVALID_HANDLE_VALUE;
return Status::OK();
}
Status Flush() override {
if (FALSE == ::FlushFileBuffers(hfile_)) {
return IOErrorFromWindowsError("FlushFileBuffers failed for: " +
filename_);
}
return Status::OK();
}
Status Name(StringPiece* result) const override {
*result = filename_;
return Status::OK();
}
Status Sync() override { return Flush(); }
};
class WinReadOnlyMemoryRegion : public ReadOnlyMemoryRegion {
private:
const std::string filename_;
HANDLE hfile_;
HANDLE hmap_;
const void* const address_;
const uint64 length_;
public:
WinReadOnlyMemoryRegion(const std::string& filename, HANDLE hfile,
HANDLE hmap, const void* address, uint64 length)
: filename_(filename),
hfile_(hfile),
hmap_(hmap),
address_(address),
length_(length) {}
~WinReadOnlyMemoryRegion() {
BOOL ret = ::UnmapViewOfFile(address_);
assert(ret);
ret = ::CloseHandle(hmap_);
assert(ret);
ret = ::CloseHandle(hfile_);
assert(ret);
}
const void* data() override { return address_; }
uint64 length() override { return length_; }
};
} // namespace
Status WindowsFileSystem::NewRandomAccessFile(
const string& fname, TransactionToken* token,
std::unique_ptr<RandomAccessFile>* result) {
string translated_fname = TranslateName(fname);
std::wstring ws_translated_fname = Utf8ToWideChar(translated_fname);
result->reset();
// Open the file for read-only random access
// Open in async mode which makes Windows allow more parallelism even
// if we need to do sync I/O on top of it.
DWORD file_flags = FILE_ATTRIBUTE_READONLY | FILE_FLAG_OVERLAPPED;
// Shared access is necessary for tests to pass
// almost all tests would work with a possible exception of fault_injection.
DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
HANDLE hfile =
::CreateFileW(ws_translated_fname.c_str(), GENERIC_READ, share_mode, NULL,
OPEN_EXISTING, file_flags, NULL);
if (INVALID_HANDLE_VALUE == hfile) {
string context = "NewRandomAccessFile failed to Create/Open: " + fname;
return IOErrorFromWindowsError(context);
}
result->reset(new WindowsRandomAccessFile(translated_fname, hfile));
return Status::OK();
}
Status WindowsFileSystem::NewWritableFile(
const string& fname, TransactionToken* token,
std::unique_ptr<WritableFile>* result) {
string translated_fname = TranslateName(fname);
std::wstring ws_translated_fname = Utf8ToWideChar(translated_fname);
result->reset();
DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
HANDLE hfile =
::CreateFileW(ws_translated_fname.c_str(), GENERIC_WRITE, share_mode,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE == hfile) {
string context = "Failed to create a NewWriteableFile: " + fname;
return IOErrorFromWindowsError(context);
}
result->reset(new WindowsWritableFile(translated_fname, hfile));
return Status::OK();
}
Status WindowsFileSystem::NewAppendableFile(
const string& fname, TransactionToken* token,
std::unique_ptr<WritableFile>* result) {
string translated_fname = TranslateName(fname);
std::wstring ws_translated_fname = Utf8ToWideChar(translated_fname);
result->reset();
DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
HANDLE hfile =
::CreateFileW(ws_translated_fname.c_str(), GENERIC_WRITE, share_mode,
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE == hfile) {
string context = "Failed to create a NewAppendableFile: " + fname;
return IOErrorFromWindowsError(context);
}
UniqueCloseHandlePtr file_guard(hfile, CloseHandleFunc);
DWORD file_ptr = ::SetFilePointer(hfile, NULL, NULL, FILE_END);
if (INVALID_SET_FILE_POINTER == file_ptr) {
string context = "Failed to create a NewAppendableFile: " + fname;
return IOErrorFromWindowsError(context);
}
result->reset(new WindowsWritableFile(translated_fname, hfile));
file_guard.release();
return Status::OK();
}
Status WindowsFileSystem::NewReadOnlyMemoryRegionFromFile(
const string& fname, TransactionToken* token,
std::unique_ptr<ReadOnlyMemoryRegion>* result) {
string translated_fname = TranslateName(fname);
std::wstring ws_translated_fname = Utf8ToWideChar(translated_fname);
result->reset();
Status s = Status::OK();
// Open the file for read-only
DWORD file_flags = FILE_ATTRIBUTE_READONLY;
// Open in async mode which makes Windows allow more parallelism even
// if we need to do sync I/O on top of it.
file_flags |= FILE_FLAG_OVERLAPPED;
DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
HANDLE hfile =
::CreateFileW(ws_translated_fname.c_str(), GENERIC_READ, share_mode, NULL,
OPEN_EXISTING, file_flags, NULL);
if (INVALID_HANDLE_VALUE == hfile) {
return IOErrorFromWindowsError(
"NewReadOnlyMemoryRegionFromFile failed to Create/Open: " + fname);
}
UniqueCloseHandlePtr file_guard(hfile, CloseHandleFunc);
// Use mmap when virtual address-space is plentiful.
uint64_t file_size;
s = GetFileSize(translated_fname, &file_size);
if (s.ok()) {
// Will not map empty files
if (file_size == 0) {
return IOError(
"NewReadOnlyMemoryRegionFromFile failed to map empty file: " + fname,
EINVAL);
}
HANDLE hmap = ::CreateFileMappingA(hfile, NULL, PAGE_READONLY,
0, // Whole file at its present length
0,
NULL); // Mapping name
if (!hmap) {
string context =
"Failed to create file mapping for "
"NewReadOnlyMemoryRegionFromFile: " +
fname;
return IOErrorFromWindowsError(context);
}
UniqueCloseHandlePtr map_guard(hmap, CloseHandleFunc);
const void* mapped_region =
::MapViewOfFileEx(hmap, FILE_MAP_READ,
0, // High DWORD of access start
0, // Low DWORD
file_size,
NULL); // Let the OS choose the mapping
if (!mapped_region) {
string context =
"Failed to MapViewOfFile for "
"NewReadOnlyMemoryRegionFromFile: " +
fname;
return IOErrorFromWindowsError(context);
}
result->reset(new WinReadOnlyMemoryRegion(fname, hfile, hmap, mapped_region,
file_size));
map_guard.release();
file_guard.release();
}
return s;
}
Status WindowsFileSystem::FileExists(const string& fname,
TransactionToken* token) {
constexpr int kOk = 0;
std::wstring ws_translated_fname = Utf8ToWideChar(TranslateName(fname));
if (_waccess(ws_translated_fname.c_str(), kOk) == 0) {
return Status::OK();
}
return errors::NotFound(fname, " not found");
}
Status WindowsFileSystem::GetChildren(const string& dir,
TransactionToken* token,
std::vector<string>* result) {
string translated_dir = TranslateName(dir);
std::wstring ws_translated_dir = Utf8ToWideChar(translated_dir);
result->clear();
std::wstring pattern = ws_translated_dir;
if (!pattern.empty() && pattern.back() != '\\' && pattern.back() != '/') {
pattern += L"\\*";
} else {
pattern += L'*';
}
WIN32_FIND_DATAW find_data;
HANDLE find_handle = ::FindFirstFileW(pattern.c_str(), &find_data);
if (find_handle == INVALID_HANDLE_VALUE) {
string context = "FindFirstFile failed for: " + translated_dir;
return IOErrorFromWindowsError(context);
}
do {
string file_name = WideCharToUtf8(find_data.cFileName);
const StringPiece basename = file_name;
if (basename != "." && basename != "..") {
result->push_back(file_name);
}
} while (::FindNextFileW(find_handle, &find_data));
if (!::FindClose(find_handle)) {
string context = "FindClose failed for: " + translated_dir;
return IOErrorFromWindowsError(context);
}
return Status::OK();
}
Status WindowsFileSystem::DeleteFile(const string& fname,
TransactionToken* token) {
Status result;
std::wstring file_name = Utf8ToWideChar(fname);
if (_wunlink(file_name.c_str()) != 0) {
result = IOError("Failed to delete a file: " + fname, errno);
}
return result;
}
Status WindowsFileSystem::CreateDir(const string& name,
TransactionToken* token) {
Status result;
std::wstring ws_name = Utf8ToWideChar(name);
if (ws_name.empty()) {
return errors::AlreadyExists(name);
}
if (_wmkdir(ws_name.c_str()) != 0) {
result = IOError("Failed to create a directory: " + name, errno);
}
return result;
}
Status WindowsFileSystem::DeleteDir(const string& name,
TransactionToken* token) {
Status result;
std::wstring ws_name = Utf8ToWideChar(name);
if (_wrmdir(ws_name.c_str()) != 0) {
result = IOError("Failed to remove a directory: " + name, errno);
}
return result;
}
Status WindowsFileSystem::GetFileSize(const string& fname,
TransactionToken* token, uint64* size) {
string translated_fname = TranslateName(fname);
std::wstring ws_translated_dir = Utf8ToWideChar(translated_fname);
Status result;
WIN32_FILE_ATTRIBUTE_DATA attrs;
if (TRUE == ::GetFileAttributesExW(ws_translated_dir.c_str(),
GetFileExInfoStandard, &attrs)) {
ULARGE_INTEGER file_size;
file_size.HighPart = attrs.nFileSizeHigh;
file_size.LowPart = attrs.nFileSizeLow;
*size = file_size.QuadPart;
} else {
string context = "Can not get size for: " + fname;
result = IOErrorFromWindowsError(context);
}
return result;
}
Status WindowsFileSystem::IsDirectory(const string& fname,
TransactionToken* token) {
TF_RETURN_IF_ERROR(FileExists(fname));
std::wstring ws_translated_fname = Utf8ToWideChar(TranslateName(fname));
if (PathIsDirectoryW(ws_translated_fname.c_str())) {
return Status::OK();
}
return Status(tensorflow::error::FAILED_PRECONDITION, "Not a directory");
}
Status WindowsFileSystem::RenameFile(const string& src, const string& target,
TransactionToken* token) {
// rename() is not capable of replacing the existing file as on Linux
// so use OS API directly
std::wstring ws_translated_src = Utf8ToWideChar(TranslateName(src));
std::wstring ws_translated_target = Utf8ToWideChar(TranslateName(target));
// Calling MoveFileExW with the MOVEFILE_REPLACE_EXISTING flag can fail if
// another process has a handle to the file that it didn't close yet. On the
// other hand, calling DeleteFileW + MoveFileExW will work in that scenario
// because it allows the process to keep using the old handle while also
// creating a new handle for the new file.
WIN32_FIND_DATAW find_file_data;
HANDLE target_file_handle =
::FindFirstFileW(ws_translated_target.c_str(), &find_file_data);
if (target_file_handle != INVALID_HANDLE_VALUE) {
if (!::DeleteFileW(ws_translated_target.c_str())) {
::FindClose(target_file_handle);
return IOErrorFromWindowsError(
strings::StrCat("Failed to rename: ", src, " to: ", target));
}
::FindClose(target_file_handle);
}
if (!::MoveFileExW(ws_translated_src.c_str(), ws_translated_target.c_str(),
0)) {
return IOErrorFromWindowsError(
strings::StrCat("Failed to rename: ", src, " to: ", target));
}
return Status::OK();
}
Status WindowsFileSystem::GetMatchingPaths(const string& pattern,
TransactionToken* token,
std::vector<string>* results) {
// NOTE(mrry): The existing implementation of FileSystem::GetMatchingPaths()
// does not handle Windows paths containing backslashes correctly. Since
// Windows APIs will accept forward and backslashes equivalently, we
// convert the pattern to use forward slashes exclusively. Note that this
// is not ideal, since the API expects backslash as an escape character,
// but no code appears to rely on this behavior.
string converted_pattern(pattern);
std::replace(converted_pattern.begin(), converted_pattern.end(), '\\', '/');
TF_RETURN_IF_ERROR(internal::GetMatchingPaths(this, Env::Default(),
converted_pattern, results));
for (string& result : *results) {
std::replace(result.begin(), result.end(), '/', '\\');
}
return Status::OK();
}
bool WindowsFileSystem::Match(const string& filename, const string& pattern) {
std::wstring ws_path(Utf8ToWideChar(filename));
std::wstring ws_pattern(Utf8ToWideChar(pattern));
return PathMatchSpecW(ws_path.c_str(), ws_pattern.c_str()) == TRUE;
}
Status WindowsFileSystem::Stat(const string& fname, TransactionToken* token,
FileStatistics* stat) {
Status result;
struct _stat64 sbuf;
std::wstring ws_translated_fname = Utf8ToWideChar(TranslateName(fname));
if (_wstat64(ws_translated_fname.c_str(), &sbuf) != 0) {
result = IOError(fname, errno);
} else {
stat->mtime_nsec = sbuf.st_mtime * 1e9;
stat->length = sbuf.st_size;
stat->is_directory = IsDirectory(fname).ok();
}
return result;
}
} // namespace tensorflow
|
; float __fssqrt (float number)
SECTION code_clib
SECTION code_fp_math32
PUBLIC cm32_sccz80_fssqrt
EXTERN m32_fssqrt
; square root sccz80 float
;
; enter : stack = sccz80_float number, ret
;
; exit : DEHL = sccz80_float(number^0.5)
;
; uses : af, bc, de, hl, af', bc', de', hl'
defc cm32_sccz80_fssqrt = m32_fssqrt
|
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
/**
* Test program for itkGPUBinaryThresholdImageFilter class
*
*/
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include "itkTimeProbe.h"
#include "itkGPUImage.h"
#include "itkGPUKernelManager.h"
#include "itkGPUContextManager.h"
#include "itkGPUImageToImageFilter.h"
#include "itkGPUBinaryThresholdImageFilter.h"
template< unsigned int VImageDimension >
int runGPUBinaryThresholdImageFilterTest(const std::string& inFile, const std::string& outFile)
{
typedef unsigned char InputPixelType;
typedef unsigned char OutputPixelType;
typedef itk::GPUImage< InputPixelType, VImageDimension > InputImageType;
typedef itk::GPUImage< OutputPixelType, VImageDimension > OutputImageType;
typedef itk::ImageFileReader< InputImageType > ReaderType;
typedef itk::ImageFileWriter< OutputImageType > WriterType;
typename ReaderType::Pointer reader = ReaderType::New();
typename WriterType::Pointer writer = WriterType::New();
if(!itk::IsGPUAvailable())
{
std::cerr << "OpenCL-enabled GPU is not present." << std::endl;
return EXIT_FAILURE;
}
reader->SetFileName( inFile );
writer->SetFileName( outFile );
typedef itk::BinaryThresholdImageFilter< InputImageType, OutputImageType > ThresholdFilterType;
typedef itk::GPUBinaryThresholdImageFilter< InputImageType, OutputImageType > GPUThresholdFilterType;
// threshold parameters
const InputPixelType upperThreshold = 255;
const InputPixelType lowerThreshold = 175;
const OutputPixelType outsideValue = 0;
const OutputPixelType insideValue = 255;
for(int nThreads = 1; nThreads <= 8; nThreads++)
{
typename ThresholdFilterType::Pointer CPUFilter = ThresholdFilterType::New();
itk::TimeProbe cputimer;
cputimer.Start();
// build pipeline
CPUFilter->SetNumberOfThreads( nThreads );
CPUFilter->SetOutsideValue( outsideValue );
CPUFilter->SetInsideValue( insideValue );
CPUFilter->SetUpperThreshold( upperThreshold );
CPUFilter->SetLowerThreshold( lowerThreshold );
//CPUFilter->SetInPlace( true );
CPUFilter->SetInput( reader->GetOutput() );
CPUFilter->Update();
cputimer.Stop();
std::cout << "CPU binary threshold took " << cputimer.GetMean() << " seconds with "
<< CPUFilter->GetNumberOfThreads() << " threads.\n" << std::endl;
if( nThreads == 8 )
{
typename GPUThresholdFilterType::Pointer GPUFilter = GPUThresholdFilterType::New();
itk::TimeProbe gputimer;
gputimer.Start();
GPUFilter->SetOutsideValue( outsideValue );
GPUFilter->SetInsideValue( insideValue );
GPUFilter->SetUpperThreshold( upperThreshold );
GPUFilter->SetLowerThreshold( lowerThreshold );
//GPUFilter->SetInPlace( true );
GPUFilter->SetInput( reader->GetOutput() );
GPUFilter->Update();
GPUFilter->GetOutput()->UpdateBuffers(); // synchronization point
gputimer.Stop();
std::cout << "GPU binary threshold took " << gputimer.GetMean() << " seconds.\n" << std::endl;
// ---------------
// RMS Error check
// ---------------
double diff = 0;
unsigned int nPix = 0;
itk::ImageRegionIterator<OutputImageType> cit(CPUFilter->GetOutput(), CPUFilter->GetOutput()->GetLargestPossibleRegion());
itk::ImageRegionIterator<OutputImageType> git(GPUFilter->GetOutput(), GPUFilter->GetOutput()->GetLargestPossibleRegion());
for(cit.GoToBegin(), git.GoToBegin(); !cit.IsAtEnd(); ++cit, ++git)
{
double err = (double)(cit.Get()) - (double)(git.Get());
diff += err*err;
nPix++;
}
if (nPix > 0)
{
double RMSError = sqrt( diff / (double)nPix );
std::cout << "RMS Error : " << RMSError << std::endl;
double RMSThreshold = 0;
writer->SetInput( GPUFilter->GetOutput() );
// execute pipeline filter and write output
writer->Update();
if (vnl_math_isnan(RMSError))
{
std::cout << "RMS Error is NaN! nPix: " << nPix << std::endl;
return EXIT_FAILURE;
}
if (RMSError > RMSThreshold)
{
std::cout << "RMS Error exceeds threshold (" << RMSThreshold << ")" << std::endl;
return EXIT_FAILURE;
}
}
else
{
std::cout << "No pixels in output!" << std::endl;
return EXIT_FAILURE;
}
}
}
return EXIT_SUCCESS;
}
int itkGPUBinaryThresholdImageFilterTest(int argc, char *argv[])
{
if( argc < 3 )
{
std::cerr << "Error: missing arguments" << std::endl;
std::cerr << "inputfile outputfile [num_dimensions]" << std::endl;
return EXIT_FAILURE;
}
std::string inFile( argv[1] );
std::string outFile( argv[2] );
unsigned int dim = 3;
if( argc >= 4 )
{
dim = atoi( argv[3] );
}
if( dim == 2 )
{
return runGPUBinaryThresholdImageFilterTest<2>(inFile, outFile);
}
else if( dim == 3 )
{
return runGPUBinaryThresholdImageFilterTest<3>(inFile, outFile);
}
else
{
std::cerr << "Error: only 2 or 3 dimensions allowed, " << dim << " selected." << std::endl;
return EXIT_FAILURE;
}
}
|
;------------------------------------------------------------------------------
;
; SetMem() worker for ARM
;
; This file started out as C code that did 64 bit moves if the buffer was
; 32-bit aligned, else it does a byte copy. It also does a byte copy for
; any trailing bytes. It was updated to do 32-byte at a time.
;
; Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
; This program and the accompanying materials
; are licensed and made available under the terms and conditions of the BSD License
; which accompanies this distribution. The full text of the license may be found at
; http://opensource.org/licenses/bsd-license.php
;
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
/**
Set Buffer to Value for Size bytes.
@param Buffer Memory to set.
@param Length Number of bytes to set
@param Value Value of the set operation.
@return Buffer
VOID *
EFIAPI
InternalMemSetMem (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT8 Value
)
**/
EXPORT InternalMemSetMem
AREA AsmMemStuff, CODE, READONLY
InternalMemSetMem
stmfd sp!, {r4-r11, lr}
tst r0, #3
movne r3, #0
moveq r3, #1
cmp r1, #31
movls lr, #0
andhi lr, r3, #1
cmp lr, #0
mov r12, r0
bne L31
L32
mov r3, #0
b L43
L31
and r4, r2, #0xff
orr r4, r4, r4, LSL #8
orr r4, r4, r4, LSL #16
mov r5, r4
mov r6, r4
mov r7, r4
mov r8, r4
mov r9, r4
mov r10, r4
mov r11, r4
b L32
L34
cmp lr, #0
streqb r2, [r12], #1
subeq r1, r1, #1
beq L43
sub r1, r1, #32
cmp r1, #31
movls lr, r3
stmia r12!, {r4-r11}
L43
cmp r1, #0
bne L34
ldmfd sp!, {r4-r11, pc}
END
|
;;
;; Copyright (c) 2019-2020, Intel Corporation
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions are met:
;;
;; * Redistributions of source code must retain the above copyright notice,
;; this list of conditions and the following disclaimer.
;; * Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;; * Neither the name of Intel Corporation nor the names of its contributors
;; may be used to endorse or promote products derived from this software
;; without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
;; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
;; CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
;; OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;
%define AES_CBC_ENC_X16 aes_cbc_enc_256_vaes_avx512
%define FLUSH_JOB_AES_ENC flush_job_aes256_enc_vaes_avx512
%define NUM_KEYS 15
%include "avx512/mb_mgr_aes_flush_avx512.asm"
|
; A074544: a(n) = 2^n + 7^n + 8^n.
; Submitted by Jamie Morken(s4)
; 3,17,117,863,6513,49607,379857,2920823,22542273,174571847,1356218097,10567263383,82560768033,646644832487,5076269600337,39931933631543,314707907345793,2484430327803527,19642812107654577,155514083261753303,1232713770905507553,9781917900940156967,77696797343425388817,617664557698794956663,4913947714250228405313,39120000482621160164807,311618935241305115091057,2483564001592792763769623,19802799650378807024711073,157962410666485714626099047,1260479379576072534060729297,10061295696317888007955520183
mov $1,7
pow $1,$0
mov $2,2
pow $2,$0
add $1,$2
pow $2,3
add $2,$1
mov $0,$2
|
; uint __FASTCALL__ zx_aaddr2py(void *attraddr)
; aralbrec 06.2007
SECTION code_clib
PUBLIC zx_aaddr2py
PUBLIC _zx_aaddr2py
.zx_aaddr2py
._zx_aaddr2py
ld a,l
and $e0
srl h
rra
srl h
rra
srl h
rra
ld l,a
ld h,0
ret
|
//
// Copyright (c) 2020 Gu.Qiwei(gqwmail@qq.com)
//
// Distributed under the MIT Software License
// See accompanying file LICENSE.txt or copy at
// https://opensource.org/licenses/MIT
//
#pragma once
#include <fmt/format.h>
#include <hiredis/hiredis.h>
#include <coro_redis/impl/sync_connection.ipp>
namespace coro_redis {
///
/// @brief Synchronous connection
///
class sync_connection {
public:
using cptr = std::shared_ptr<sync_connection>;
///
/// @brief construction
///
/// @param ctx Redis synchronous context
///
sync_connection(redisContext* ctx) : impl_(ctx) { }
/// @brief Send redis command.
/// @param cmd Redis command.
/// @return Redis return.
template <typename RET = std::string>
std::optional<RET> command(std::string_view cmd) const {
return impl_.command<RET>(cmd);
}
template <typename RET = std::string>
std::optional<RET> command(std::string_view cmd,
std::function<void(redisReply*)> op) const {
return impl_.command<RET>(cmd, op);
}
/// @brief Send password to Redis.
/// @param password Password.
/// @note Normally, you should not call this method.
/// Instead, you should set password with `ConnectionOptions` or URI.
/// @see https://redis.io/commands/auth
inline std::optional<std::string> auth(std::string_view password) {
return impl_.command<std::string>(fmt::format("auth {}", password));
}
/// @brief Send user and password to Redis.
/// @param user User name.
/// @param password Password.
/// @note Normally, you should not call this method.
/// Instead, you should set password with `ConnectionOptions` or URI.
/// Also this overload only works with Redis 6.0 or later.
/// @see https://redis.io/commands/auth
inline std::optional<std::string> auth(std::string_view user,
std::string_view password) {
return impl_.command<std::string>(
fmt::format("auth {} {}", user, password));
}
/// @brief Ask Redis to return the given message.
/// @param msg Message to be sent.
/// @return Return the given message.
/// @see https://redis.io/commands/echo
inline std::optional<std::string> echo(std::string_view msg) const {
return impl_.command<std::string>(fmt::format("echo {}", msg));
}
/// @brief Test if the connection is alive.
/// @return Always return *PONG*.
/// @see https://redis.io/commands/ping
inline std::optional<std::string> ping() {
return impl_.command<std::string>("ping");
}
/// @brief Test if the connection is alive.
/// @param msg Message sent to Redis.
/// @return Return the given message.
/// @see https://redis.io/commands/ping
inline std::optional<std::string> ping(std::string_view msg) {
return impl_.command<std::string>(fmt::format("ping {}", msg));
}
/// @brief After sending QUIT, only the current connection will be close,
/// while other connections in the pool is still open.
/// @see https://redis.io/commands/quit
inline std::optional<std::string> quit() {
return impl_.command<std::string>(fmt::format("quit"));
}
/// @brief Select the Redis logical database
/// @see https://redis.io/commands/select
inline std::optional<std::string> select(uint64_t idx) {
return impl_.command<std::string>(fmt::format("select {}", idx));
}
/// @brief Swap two Redis databases.
/// @param idx1 The index of the first database.
/// @param idx2 The index of the second database.
/// @see https://redis.io/commands/swapdb
inline std::optional<std::string> swapdb(uint64_t idx1, uint64_t idx2) {
return impl_.command<std::string>(fmt::format("swapdb {} {}", idx1, idx2));
}
// SERVER commands.
/// @brief Rewrite AOF in the background.
/// @see https://redis.io/commands/bgrewriteaof
inline std::optional<std::string> bgrewriteaof() {
return impl_.command<std::string>("bgrewriteaof");
}
/// @brief Save database in the background.
/// @see https://redis.io/commands/bgsave
inline std::optional<std::string> bgsave() {
return impl_.command<std::string>("bgsave");
}
/// @brief Get the size of the currently selected database.
/// @return Number of keys in currently selected database.
/// @see https://redis.io/commands/dbsize
inline std::optional<uint64_t> dbsize() {
return impl_.command<uint64_t>("dbsize");
}
/// @brief Remove keys of all databases.
/// @param async Whether flushing databases asynchronously, i.e. without
/// blocking the server.
/// @see https://redis.io/commands/flushall
inline std::optional<std::string> flushall(bool async = false) {
return impl_.command<std::string>(async ? "FLUSHALL ASYNC"
: "FLUSHALL SYNC");
}
/// @brief Remove keys of current databases.
/// @param async Whether flushing databases asynchronously, i.e. without
/// blocking the server.
/// @see https://redis.io/commands/flushdb
inline std::optional<std::string> flushdb(bool async = false) {
return impl_.command<std::string>(async ? "FLUSHDB ASYNC" : "FLUSHDB SYNC");
}
/// @brief Get the info about the server.
/// @return Server info.
/// @see https://redis.io/commands/info
inline std::optional<std::string> info() {
return impl_.command<std::string>("info");
}
/// @brief Get the info about the server on the given section.
/// @param section Section.
/// @return Server info.
/// @see https://redis.io/commands/info
inline std::optional<std::string> info(std::string_view section) {
return impl_.command<std::string>(fmt::format("info {}", section));
}
/// @brief Get the UNIX timestamp in seconds, at which the database was saved
/// successfully.
/// @return The last saving time.
/// @see https://redis.io/commands/lastsave
inline std::optional<uint64_t> lastsave() {
return impl_.command<uint64_t>("lastsave");
}
/// @brief Save databases into RDB file **synchronously**, i.e. block the
/// server during saving.
/// @see https://redis.io/commands/save
inline std::optional<std::string> save() {
return impl_.command<std::string>("save");
}
// KEY commands.
/// @brief Delete the given key.
/// @param key Key.
/// @return Number of keys removed.
/// @retval 1 If the key exists, and has been removed.
/// @retval 0 If the key does not exist.
/// @see https://redis.io/commands/del
template <typename... Args>
inline std::optional<uint64_t> del(Args && ... keys) {
std::string cmd("del");
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Get the serialized valued stored at key.
/// @param key Key.
/// @return The serialized value.
/// @note If key does not exist, `dump` returns `OptionalString{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/dump
inline std::optional<std::string> dump(std::string_view key) {
return impl_.command<std::string>(fmt::format("dump {}", key));
}
/// @brief Check if the given key exists.
/// @param key Key.
/// @return Whether the given key exists.
/// @retval 1 If key exists.
/// @retval 0 If key does not exist.
/// @see https://redis.io/commands/exists
template <typename... Args>
inline std::optional<uint64_t> exists(Args && ... keys) {
std::string cmd("exists");
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Set a timeout on key.
/// @param key Key.
/// @param timeout Timeout in seconds.
/// @return Whether timeout has been set.
/// @retval 1 If timeout has been set.
/// @retval 0 If key does not exist.
/// @see https://redis.io/commands/expire
inline std::optional<uint64_t> expire(std::string_view key, uint64_t timeout) {
return impl_.command<uint64_t>(fmt::format("expire {} {}", key, timeout));
}
/// @brief Set a timeout on key, i.e. expire the key at a future time point.
/// @param key Key.
/// @param timestamp Time in seconds since UNIX epoch.
/// @return Whether timeout has been set.
/// @retval true If timeout has been set.
/// @retval false If key does not exist.
/// @see https://redis.io/commands/expireat
inline std::optional<uint64_t> expireat(std::string_view key,
uint64_t timestamp) {
return impl_.command<uint64_t>(
fmt::format("expireat {} {}", key, timestamp));
}
/// @brief Get keys matching the given pattern.
/// @param pattern Pattern.
/// @param output Output iterator to the destination where the returned keys
/// are stored.
/// @note It's always a bad idea to call `keys`, since it might block Redis
/// for a long time,
/// especially when the data set is very big.
/// @see `Redis::scan`
/// @see https://redis.io/commands/keys
// inline std::optional<std::vector<std::string>> keys(std::string_view pattern) {
// return impl_.command<std::vector<std::string>>(fmt::format("keys {}",
// pattern));
//}
/// @brief Move a key to the given database.
/// @param key Key.
/// @param db The destination database.
/// @return Whether key has been moved.
/// @retval true If key has been moved.
/// @retval false If key was not moved.
/// @see https://redis.io/commands/move
inline std::optional<uint64_t> move(std::string_view key, uint64_t db) {
return impl_.command<uint64_t>(fmt::format("move {} {}", key, db));
}
/// @brief Remove timeout on key.
/// @param key Key.
/// @return Whether timeout has been removed.
/// @retval true If timeout has been removed.
/// @retval false If key does not exist, or does not have an associated
/// timeout.
/// @see https://redis.io/commands/persist
inline std::optional<uint64_t> persist(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("persist {}", key));
}
/// @brief Set a timeout on key.
/// @param key Key.
/// @param timeout Timeout in milliseconds.
/// @return Whether timeout has been set.
/// @retval true If timeout has been set.
/// @retval false If key does not exist.
/// @see https://redis.io/commands/pexpire
inline std::optional<uint64_t> pexpire(std::string_view key, uint64_t timeout) {
return impl_.command<uint64_t>(fmt::format("pexpire {} {}", key, timeout));
}
/// @brief Set a timeout on key, i.e. expire the key at a future time point.
/// @param key Key.
/// @param timestamp Time in milliseconds since UNIX epoch.
/// @return Whether timeout has been set.
/// @retval true If timeout has been set.
/// @retval false If key does not exist.
/// @see https://redis.io/commands/pexpireat
inline std::optional<uint64_t> pexpireat(std::string_view key,
uint64_t timestamp) {
return impl_.command<uint64_t>(
fmt::format("pexpireat {} {}", key, timestamp));
}
/// @brief Get the TTL of a key in milliseconds.
/// @param key Key.
/// @return TTL of the key in milliseconds.
/// @see https://redis.io/commands/pttl
inline std::optional<uint64_t> pttl(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("pttl {}", key));
}
/// @brief Get a random key from current database.
/// @return A random key.
/// @note If the database is empty, `randomkey` returns `OptionalString{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/randomkey
inline std::optional<std::string> randomkey() {
return impl_.command<std::string>("randomkey");
}
/// @brief Rename `key` to `newkey`.
/// @param key Key to be renamed.
/// @param newkey The new name of the key.
/// @see https://redis.io/commands/rename
inline std::optional<std::string> rename(std::string_view key,
std::string_view newkey) {
return impl_.command<std::string>(fmt::format("rename {} {}", key, newkey));
}
/// @brief Rename `key` to `newkey` if `newkey` does not exist.
/// @param key Key to be renamed.
/// @param newkey The new name of the key.
/// @return Whether key has been renamed.
/// @retval true If key has been renamed.
/// @retval false If newkey already exists.
/// @see https://redis.io/commands/renamenx
inline std::optional<uint64_t> renamenx(std::string_view key,
std::string_view newkey) {
return impl_.command<uint64_t>(fmt::format("renamenx {} {}", key, newkey));
}
/// @brief Create a key with the value obtained by `Redis::dump`.
/// @param key Key.
/// @param val Value obtained by `Redis::dump`.
/// @param ttl Timeout of the created key in milliseconds. If `ttl` is 0, set
/// no timeout.
/// @param replace Whether to overwrite an existing key.
/// If `replace` is `true` and key already exists, throw an
/// exception.
/// @see https://redis.io/commands/restore
inline std::optional<std::string> restore(std::string_view key,
std::string_view val, uint64_t ttl,
bool replace = false) {
return impl_.command<std::string>(
fmt::format("restore {} {} {} {}", key, ttl, val, replace));
}
// TODO: sort
/// @brief Scan keys of the database matching the given pattern.
///
/// Example:
/// @code{.cpp}
/// @endcode
/// @param cursor Cursor.
/// @param pattern Pattern of the keys to be scanned.
/// @param count A hint for how many keys to be scanned.
/// @param output Output iterator to the destination where the returned keys
/// are stored.
/// @return The cursor to be used for the next scan operation.
/// @see https://redis.io/commands/scan
/// TODO: support the TYPE option for Redis 6.0.
inline std::optional<scan_ret_t> scan(uint64_t cursor, uint64_t count = 0) {
return scan(cursor, "", count);
}
inline std::optional<scan_ret_t> scan(uint64_t cursor, std::string_view pattern,
uint64_t count = 0) {
return impl_.scan(cursor, pattern, count);
}
/// @brief Update the last access time of the given key.
/// @param key Key.
/// @return Whether last access time of the key has been updated.
/// @retval 1 If key exists, and last access time has been updated.
/// @retval 0 If key does not exist.
/// @see https://redis.io/commands/touch
template <typename... Args>
inline std::optional<uint64_t> touch(Args && ... keys) {
std::string cmd("touch");
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Get the remaining Time-To-Live of a key.
/// @param key Key.
/// @return TTL in seconds.
/// @retval TTL If the key has a timeout.
/// @retval -1 If the key exists but does not have a timeout.
/// @retval -2 If the key does not exist.
/// @note In Redis 2.6 or older, `ttl` returns -1 if the key does not exist,
/// or if the key exists but does not have a timeout.
/// @see https://redis.io/commands/ttl
inline std::optional<uint64_t> ttl(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("ttl {}", key));
}
/// @brief Get the type of the value stored at key.
/// @param key Key.
/// @return The type of the value.
/// @see https://redis.io/commands/type
inline std::optional<std::string> type(std::string_view key) {
return impl_.command<std::string>(fmt::format("type {}", key));
}
/// @brief Remove the given key asynchronously, i.e. without blocking Redis.
/// @param key Key.
/// @return Whether the key has been removed.
/// @retval 1 If key exists, and has been removed.
/// @retval 0 If key does not exist.
/// @see https://redis.io/commands/unlink
template <typename... Args>
inline std::optional<uint64_t> unlink(Args && ... keys) {
std::string cmd("unlink");
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Wait until previous write commands are successfully replicated to
/// at
/// least the specified number of replicas or the given timeout has
/// been reached.
/// @param numslaves Number of replicas.
/// @param timeout Timeout in milliseconds. If timeout is 0ms, wait forever.
/// @return Number of replicas that have been successfully replicated these
/// write commands.
/// @note The return value might be less than `numslaves`, because timeout has
/// been reached.
/// @see https://redis.io/commands/wait
inline std::optional<uint64_t> wait(uint64_t numslaves, uint64_t timeout) {
return impl_.command<uint64_t>(
fmt::format("wait {} {}", numslaves, timeout));
}
// STRING commands.
/// @brief Append the given string to the string stored at key.
/// @param key Key.
/// @param str String to be appended.
/// @return The length of the string after the append operation.
/// @see https://redis.io/commands/append
inline std::optional<uint64_t> append(std::string_view key,
std::string_view str) {
return impl_.command<uint64_t>(fmt::format("append {} {}", key, str));
}
/// @brief Get the number of bits that have been set for the given range of
/// the string.
/// @param key Key.
/// @param start Start index (inclusive) of the range. 0 means the beginning
/// of the string.
/// @param end End index (inclusive) of the range. -1 means the end of the
/// string.
/// @return Number of bits that have been set.
/// @note The index can be negative to index from the end of the string.
/// @see https://redis.io/commands/bitcount
inline std::optional<uint64_t> bitcount(std::string_view key, uint64_t start = 0,
uint64_t end = -1) {
return impl_.command<uint64_t>(
fmt::format("bitcount {} {} {}", key, start, end));
}
enum BitOp { AND, OR, XOR, NOT };
/// @brief Do bit operation on the string stored at `key`, and save the result
/// to `destination`.
/// @param op Bit operations.
/// @param destination The destination key where the result is saved.
/// @param key The key where the string to be operated is stored.
/// @return The length of the string saved at `destination`.
/// @see https://redis.io/commands/bitop
/// @see `BitOp`
template <typename... Args>
inline std::optional<uint64_t> bitop(BitOp op, Args && ... keys) {
std::string cmd("bitop");
switch (op) {
case BitOp::AND:
cmd.append(" AND ");
break;
case BitOp::OR:
cmd.append(" OR ");
break;
case BitOp::XOR:
cmd.append(" XOR ");
break;
case BitOp::NOT:
cmd.append(" NOT ");
break;
}
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Get the position of the first bit set to 0 or 1 in the given range
/// of the string.
/// @param key Key.
/// @param bit 0 or 1.
/// @param start Start index (inclusive) of the range. 0 means the beginning
/// of the string.
/// @param end End index (inclusive) of the range. -1 means the end of the
/// string.
/// @return The position of the first bit set to 0 or 1.
/// @see https://redis.io/commands/bitpos
inline std::optional<uint64_t> bitpos(std::string_view key, uint64_t bit,
uint64_t start = 0, uint64_t end = -1) {
return impl_.command<uint64_t>(
fmt::format("bitpos {} {} {} {}", key, bit, start, end));
}
/// @brief Decrement the integer stored at key by 1.
/// @param key Key.
/// @return The value after the decrement.
/// @see https://redis.io/commands/decr
inline std::optional<uint64_t> decr(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("decr {}", key));
}
/// @brief Decrement the integer stored at key by `decrement`.
/// @param key Key.
/// @param decrement Decrement.
/// @return The value after the decrement.
/// @see https://redis.io/commands/decrby
inline std::optional<uint64_t> decrby(std::string_view key, uint64_t decrement) {
return impl_.command<uint64_t>(fmt::format("decrby {} {}", key, decrement));
}
/// @brief Get the string value stored at key.
///
/// Example:
/// @code{.cpp}
/// auto val = redis.get("key");
/// if (val)
/// std::cout << *val << std::endl;
/// else
/// std::cout << "key not exist" << std::endl;
/// @endcode
/// @param key Key.
/// @return The value stored at key.
/// @note If key does not exist, `get` returns `OptionalString{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/get
inline std::optional<std::string> get(std::string_view key) const {
return impl_.command<std::string>(fmt::format("get {}", key));
}
/// @brief Get the bit value at offset in the string.
/// @param key Key.
/// @param offset Offset.
/// @return The bit value.
/// @see https://redis.io/commands/getbit
inline std::optional<uint64_t> getbit(std::string_view key, uint64_t offset) {
return impl_.command<uint64_t>(fmt::format("getbit {} {}", key, offset));
}
/// @brief Get the substring of the string stored at key.
/// @param key Key.
/// @param start Start index (inclusive) of the range. 0 means the beginning
/// of the string.
/// @param end End index (inclusive) of the range. -1 means the end of the
/// string.
/// @return The substring in range [start, end]. If key does not exist, return
/// an empty string.
/// @see https://redis.io/commands/getrange
inline std::optional<std::string> getrange(std::string_view key, uint64_t start,
uint64_t end) {
return impl_.command<std::string>(
fmt::format("getrange {} {} {}", key, start, end));
}
/// @brief Atomically set the string stored at `key` to `val`, and return the
/// old value.
/// @param key Key.
/// @param val Value to be set.
/// @return The old value stored at key.
/// @note If key does not exist, `getset` returns `OptionalString{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/getset
/// @see `OptionalString`
inline std::optional<std::string> getset(std::string_view key,
std::string_view val) {
return impl_.command<std::string>(fmt::format("getset {} {}", key, val));
}
/// @brief Increment the integer stored at key by 1.
/// @param key Key.
/// @return The value after the increment.
/// @see https://redis.io/commands/incr
inline std::optional<uint64_t> incr(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("incr {}", key));
}
/// @brief Increment the integer stored at key by `increment`.
/// @param key Key.
/// @param increment Increment.
/// @return The value after the increment.
/// @see https://redis.io/commands/incrby
inline std::optional<uint64_t> incrby(std::string_view key, uint64_t increment) {
return impl_.command<uint64_t>(fmt::format("incrby {} {}", key, increment));
}
/// @brief Increment the floating point number stored at key by `increment`.
/// @param key Key.
/// @param increment Increment.
/// @return The value after the increment.
/// @see https://redis.io/commands/incrbyfloat
inline std::optional<std::string> incrbyfloat(std::string_view key,
double increment) {
return impl_.command<std::string>(
fmt::format("incrby {} {}", key, increment));
}
/// @brief Get the values of multiple keys atomically.
///
/// Example:
/// @code{.cpp}
/// std::vector<std::string> keys = {"k1", "k2", "k3"};
/// std::vector<OptionalString> vals;
/// redis.mget(keys.begin(), keys.end(), std::back_inserter(vals));
/// for (const auto &val : vals) {
/// if (val)
/// std::cout << *val << std::endl;
/// else
/// std::cout << "key does not exist" << std::endl;
/// }
/// @endcode
/// @param first Iterator to the first key of the given range.
/// @param last Off-the-end iterator to the given range.
/// @param output Output iterator to the destination where the values are
/// stored.
/// @note The destination should be a container of `OptionalString` type,
/// since the given key might not exist (in this case, the value of the
/// corresponding key is `OptionalString{}` (`std::nullopt`)).
/// @see https://redis.io/commands/mget
template <typename... Args>
inline std::optional<std::vector<std::string>> mget(Args && ... keys) {
std::string cmd("mget");
(cmd.append(" ").append(keys), ...);
return impl_.command<std::vector<std::string>>(std::move(cmd));
}
/// @brief Set multiple key-value pairs.
///
/// Example:
/// @code{.cpp}
/// redis.mset({std::make_pair("k1", "v1"), std::make_pair("k2", "v2")});
/// @endcode
/// @param il Initializer list of key-value pairs.
/// @see https://redis.io/commands/mset
template <typename... Args>
// requires requires (Args&&...keys) { ((std::string_view(keys)), ...);
// }
inline std::optional<std::string> mset(Args && ... keys) {
std::string cmd("mset");
(cmd.append(" ").append(keys), ...);
return impl_.command<std::string>(std::move(cmd));
}
/// @brief Set the given key-value pairs if all specified keys do not exist.
///
/// Example:
/// @code{.cpp}
/// std::vector<std::pair<std::string, std::string>> kvs1;
/// redis.msetnx(kvs1.begin(), kvs1.end());
/// std::unordered_map<std::string, std::string> kvs2;
/// redis.msetnx(kvs2.begin(), kvs2.end());
/// @endcode
/// @param first Iterator to the first key-value pair.
/// @param last Off-the-end iterator of the given range.
/// @return Whether all keys have been set.
/// @retval true If all keys have been set.
/// @retval false If no key was set, i.e. at least one key already exist.
/// @see https://redis.io/commands/msetnx
template <typename... Args>
// requires requires (Args&&...keys) { ((std::string_view(keys)), ...);
// }
inline std::optional<std::string> msetnx(Args && ... keys) {
std::string cmd("msetnx");
(cmd.append(" ").append(keys), ...);
return impl_.command<std::string>(std::move(cmd));
}
/// @brief Set key-value pair with the given timeout in milliseconds.
/// @param key Key.
/// @param ttl Time-To-Live in milliseconds.
/// @param val Value.
/// @see https://redis.io/commands/psetex
inline std::optional<std::string> psetex(std::string_view key, uint64_t ttl,
std::string_view val) {
return impl_.command<std::string>(
fmt::format("psetex {} {} {}", key, ttl, val));
}
/// @brief Set a key-value pair.
///
/// Example:
/// @code{.cpp}
/// // Set a key-value pair.
/// redis.set("key", "value");
/// // Set a key-value pair, and expire it after 10 seconds.
/// redis.set("key", "value", std::chrono::seconds(10));
/// // Set a key-value pair with a timeout, only if the key already exists.
/// if (redis.set("key", "value", std::chrono::seconds(10),
/// UpdateType::EXIST))
/// std::cout << "OK" << std::endl;
/// else
/// std::cout << "key does not exist" << std::endl;
/// @endcode
/// @param key Key.
/// @param val Value.
/// @param ttl Timeout on the key. If `ttl` is 0ms, do not set timeout.
/// @param type Options for set command:
/// - UpdateType::EXIST: Set the key only if it already exists.
/// - UpdateType::NOT_EXIST: Set the key only if it does not
/// exist.
/// - UpdateType::ALWAYS: Always set the key no matter whether it
/// exists.
/// @return Whether the key has been set.
/// @retval true If the key has been set.
/// @retval false If the key was not set, because of the given option.
/// @see https://redis.io/commands/set
// TODO: Support KEEPTTL option for Redis 6.0
template <RedisSetValueType T>
inline std::optional<std::string> set(std::string_view key, T val,
uint64_t ttl = 0,
RedisTTLType ttl_type = RedisTTLType::EX,
UpdateType type = UpdateType::ALWAYS) {
return impl_.set(key, val, ttl, ttl_type, type);
}
// TODO: add SETBIT command.
/// @brief Set key-value pair with the given timeout in seconds.
/// @param key Key.
/// @param ttl Time-To-Live in seconds.
/// @param val Value.
/// @see https://redis.io/commands/setex
inline std::optional<std::string> setex(std::string_view key, uint64_t ttl,
std::string_view val) {
return impl_.command<std::string>(
fmt::format("setex {} {} {}", key, ttl, val));
}
/// @brief Set the key if it does not exist.
/// @param key Key.
/// @param val Value.
/// @return Whether the key has been set.
/// @retval true If the key has been set.
/// @retval false If the key was not set, i.e. the key already exists.
/// @see https://redis.io/commands/setnx
inline std::optional<uint64_t> setnx(std::string_view key, std::string_view val) {
return impl_.command<uint64_t>(fmt::format("setnx {} {}", key, val));
}
/// @brief Set the substring starting from `offset` to the given value.
/// @param key Key.
/// @param offset Offset.
/// @param val Value.
/// @return The length of the string after this operation.
/// @see https://redis.io/commands/setrange
inline std::optional<uint64_t> setrange(std::string_view key, uint64_t offset,
std::string_view val) {
return impl_.command<uint64_t>(
fmt::format("setrange {} {} {}", key, offset, val));
}
/// @brief Get the length of the string stored at key.
/// @param key Key.
/// @return The length of the string.
/// @note If key does not exist, `strlen` returns 0.
/// @see https://redis.io/commands/strlen
inline std::optional<uint64_t> strlen(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("strlen {}", key));
}
/*
// LIST commands.
/// @brief Pop the first element of the list in a blocking way.
/// @param key Key where the list is stored.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If list is empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::lpop`
/// @see https://redis.io/commands/blpop
inline std::optional<std::vector<std::string>> blpop(std::string_view key,
uint64_t timeout = 0) { return
impl_.command<std::vector<std::string>>(fmt::format("blpop {} {}", key,
timeout));
}
/// @brief Pop the first element of the list in a blocking way.
/// @param key Key where the list is stored.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If list is empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::lpop`
/// @see https://redis.io/commands/blpop
OptionalStringPair blpop(std::string_view key,
const std::chrono::seconds& timeout = std::chrono::seconds{ 0
});
/// @brief Pop the first element of multiple lists in a blocking way.
/// @param first Iterator to the first key.
/// @param last Off-the-end iterator to the key range.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::lpop`
/// @see https://redis.io/commands/blpop
template <typename Input>
OptionalStringPair blpop(Input first, Input last, uint64_t timeout);
/// @brief Pop the first element of multiple lists in a blocking way.
/// @param il Initializer list of keys.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::lpop`
/// @see https://redis.io/commands/blpop
template <typename T>
OptionalStringPair blpop(std::initializer_list<T> il, uint64_t
timeout) { return blpop(il.begin(), il.end(), timeout);
}
/// @brief Pop the first element of multiple lists in a blocking way.
/// @param first Iterator to the first key.
/// @param last Off-the-end iterator to the key range.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::lpop`
/// @see https://redis.io/commands/blpop
template <typename Input>
OptionalStringPair blpop(Input first,
Input last,
const std::chrono::seconds& timeout = std::chrono::seconds{ 0
});
/// @brief Pop the first element of multiple lists in a blocking way.
/// @param il Initializer list of keys.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::lpop`
/// @see https://redis.io/commands/blpop
template <typename T>
OptionalStringPair blpop(std::initializer_list<T> il,
const std::chrono::seconds& timeout = std::chrono::seconds{ 0
}) { return blpop(il.begin(), il.end(), timeout);
}
/// @brief Pop the last element of the list in a blocking way.
/// @param key Key where the list is stored.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If list is empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::rpop`
/// @see https://redis.io/commands/brpop
OptionalStringPair brpop(std::string_view key, uint64_t timeout);
/// @brief Pop the last element of the list in a blocking way.
/// @param key Key where the list is stored.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If list is empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::rpop`
/// @see https://redis.io/commands/brpop
OptionalStringPair brpop(std::string_view key,
const std::chrono::seconds& timeout = std::chrono::seconds{ 0
});
/// @brief Pop the last element of multiple lists in a blocking way.
/// @param first Iterator to the first key.
/// @param last Off-the-end iterator to the key range.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::rpop`
/// @see https://redis.io/commands/brpop
template <typename Input>
OptionalStringPair brpop(Input first, Input last, uint64_t timeout);
/// @brief Pop the last element of multiple lists in a blocking way.
/// @param il Initializer list of lists.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::rpop`
/// @see https://redis.io/commands/brpop
template <typename T>
OptionalStringPair brpop(std::initializer_list<T> il, uint64_t
timeout) { return brpop(il.begin(), il.end(), timeout);
}
/// @brief Pop the last element of multiple lists in a blocking way.
/// @param first Iterator to the first list.
/// @param last Off-the-end iterator to the list range.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::rpop`
/// @see https://redis.io/commands/brpop
template <typename Input>
OptionalStringPair brpop(Input first,
Input last,
const std::chrono::seconds& timeout = std::chrono::seconds{ 0
});
/// @brief Pop the last element of multiple lists in a blocking way.
/// @param il Initializer list of list keys.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-element pair.
/// @note If all lists are empty and timeout reaches, return
`OptionalStringPair{}` (`std::nullopt`).
/// @see `Redis::rpop`
/// @see https://redis.io/commands/brpop
template <typename T>
OptionalStringPair brpop(std::initializer_list<T> il,
const std::chrono::seconds& timeout = std::chrono::seconds{ 0
}) { return brpop(il.begin(), il.end(), timeout);
}
/// @brief Pop last element of one list and push it to the left of
another list in blocking way.
/// @param source Key of the source list.
/// @param destination Key of the destination list.
/// @param timeout Timeout. 0 means block forever.
/// @return The popped element.
/// @note If the source list does not exist, `brpoplpush` returns
`OptionalString{}` (`std::nullopt`).
/// @see `Redis::rpoplpush`
/// @see https://redis.io/commands/brpoplpush
inline std::optional<std::string> brpoplpush(std::string_view source,
std::string_view destination,
uint64_t timeout);
/// @brief Pop last element of one list and push it to the left of
another list in blocking way.
/// @param source Key of the source list.
/// @param destination Key of the destination list.
/// @param timeout Timeout. 0 means block forever.
/// @return The popped element.
/// @note If the source list does not exist, `brpoplpush` returns
`OptionalString{}` (`std::nullopt`).
/// @see `Redis::rpoplpush`
/// @see https://redis.io/commands/brpoplpush
inline std::optional<std::string> brpoplpush(std::string_view source,
std::string_view destination,
const std::chrono::seconds& timeout = std::chrono::seconds{ 0
});
/// @brief Get the element at the given index of the list.
/// @param key Key where the list is stored.
/// @param index Zero-base index, and -1 means the last element.
/// @return The element at the given index.
/// @see https://redis.io/commands/lindex
inline std::optional<std::string> lindex(std::string_view key, uint64_t
index);
/// @brief Insert an element to a list before or after the pivot
element.
///
/// Example:
/// @code{.cpp}
/// // Insert 'hello' before 'world'
/// auto len = redis.linsert("list", InsertPosition::BEFORE, "world",
"hello");
/// if (len == -1)
/// std::cout << "there's no 'world' in the list" << std::endl;
/// else
/// std::cout << "after the operation, the length of the list is "
<< len << std::endl;
/// @endcode
/// @param key Key where the list is stored.
/// @param position Before or after the pivot element.
/// @param pivot The pivot value. The `pivot` is the value of the
element, not the index.
/// @param val Element to be inserted.
/// @return The length of the list after the operation.
/// @note If the pivot value is not found, `linsert` returns -1.
/// @see `InsertPosition`
/// @see https://redis.io/commands/linsert
inline std::optional<uint64_t> linsert(std::string_view key,
InsertPosition position,
std::string_view pivot,
std::string_view val);
*/
/// @brief Get the length of the list.
/// @param key Key where the list is stored.
/// @return The length of the list.
/// @see https://redis.io/commands/llen
inline std::optional<uint64_t> llen(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("llen {}", key));
}
/// @brief Pop the first element of the list.
///
/// Example:
/// @code{.cpp}
/// auto element = redis.lpop("list");
/// if (element)
/// std::cout << *element << std::endl;
/// else
/// std::cout << "list is empty, i.e. list does not exist" << std::endl;
/// @endcode
/// @param key Key where the list is stored.
/// @return The popped element.
/// @note If list is empty, i.e. key does not exist, return `OptionalString{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/lpop
std::optional<std::string> lpop(std::string_view key) {
return impl_.command<std::string>(fmt::format("lpop {}", key));
}
/// @brief Push an element to the beginning of the list.
/// @param key Key where the list is stored.
/// @param val Element to be pushed.
/// @return The length of the list after the operation.
/// @see https://redis.io/commands/lpush
inline std::optional<uint64_t> lpush(std::string_view key, std::string_view val) {
return impl_.command<uint64_t>(fmt::format("lpush {} {}", key, val));
}
/// @brief Push multiple elements to the beginning of the list.
///
/// Example:
/// @code{.cpp}
/// std::vector<std::string> elements = {"e1", "e2", "e3"};
/// redis.lpush("list", elements.begin(), elements.end());
/// @endcode
/// @param key Key where the list is stored.
/// @param first Iterator to the first element to be pushed.
/// @param last Off-the-end iterator to the given element range.
/// @return The length of the list after the operation.
/// @see https://redis.io/commands/lpush
template <typename... Args>
inline std::optional<uint64_t> lpush(std::string_view key, Args && ... keys) {
std::string cmd("lpush ");
cmd.append(key);
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Push an element to the beginning of the list, only if the list
/// already exists.
/// @param key Key where the list is stored.
/// @param val Element to be pushed.
/// @return The length of the list after the operation.
/// @see https://redis.io/commands/lpushx
// TODO: add a multiple elements overload.
inline std::optional<uint64_t> lpushx(std::string_view key,
std::string_view val) {
return impl_.command<uint64_t>(fmt::format("lpushx {} {}", key, val));
}
/// @brief Get elements in the given range of the given list.
///
/// Example:
/// @code{.cpp}
/// std::vector<std::string> elements;
/// // Save all elements of a Redis list to a vector of string.
/// redis.lrange("list", 0, -1, std::back_inserter(elements));
/// @endcode
/// @param key Key where the list is stored.
/// @param start Start index of the range. Index can be negative, which mean
/// index from the end.
/// @param stop End index of the range.
/// @param output Output iterator to the destination where the results are
/// saved.
/// @see https://redis.io/commands/lrange
inline std::optional<std::vector<std::string>> lrange(
std::string_view key, uint64_t start, uint64_t stop) {
return impl_.command<std::vector<std::string>>(
fmt::format("lrange {} {} {}", key, start, stop));
}
/// @brief Remove the first `count` occurrences of elements equal to `val`.
/// @param key Key where the list is stored.
/// @param count Number of occurrences to be removed.
/// @param val Value.
/// @return Number of elements removed.
/// @note `count` can be positive, negative and 0. Check the reference for
/// detail.
/// @see https://redis.io/commands/lrem
inline std::optional<uint64_t> lrem(std::string_view key, uint64_t count,
std::string_view val) {
return impl_.command<uint64_t>(
fmt::format("lrem {} {} {}", key, count, val));
}
/// @brief Set the element at the given index to the specified value.
/// @param key Key where the list is stored.
/// @param index Index of the element to be set.
/// @param val Value.
/// @see https://redis.io/commands/lset
inline std::optional<std::string> lset(std::string_view key, uint64_t index,
std::string_view val) {
return impl_.command<std::string>(
fmt::format("lset {} {} {}", key, index, val));
}
/// @brief Trim a list to keep only element in the given range.
/// @param key Key where the key is stored.
/// @param start Start of the index.
/// @param stop End of the index.
/// @see https://redis.io/commands/ltrim
inline std::optional<std::string> ltrim(std::string_view key, uint64_t start,
uint64_t stop) {
return impl_.command<std::string>(
fmt::format("ltrim {} {} {}", key, start, stop));
}
/// @brief Pop the last element of a list.
/// @param key Key where the list is stored.
/// @return The popped element.
/// @note If the list is empty, i.e. key does not exist, `rpop` returns
/// `OptionalString{}` (`std::nullopt`).
/// @see https://redis.io/commands/rpop
inline std::optional<std::string> rpop(std::string_view key) {
return impl_.command<std::string>(fmt::format("rpop {}", key));
}
/// @brief Pop last element of one list and push it to the left of another
/// list.
/// @param source Key of the source list.
/// @param destination Key of the destination list.
/// @return The popped element.
/// @note If the source list does not exist, `rpoplpush` returns
/// `OptionalString{}` (`std::nullopt`).
/// @see https://redis.io/commands/brpoplpush
inline std::optional<std::string> rpoplpush(std::string_view source,
std::string_view destination) {
return impl_.command<std::string>(
fmt::format("rpoplpush {} {}", source, destination));
}
/// @brief Push an element to the end of the list.
/// @param key Key where the list is stored.
/// @param val Element to be pushed.
/// @return The length of the list after the operation.
/// @see https://redis.io/commands/rpush
template <typename... Args>
inline std::optional<uint64_t> rpush(std::string_view key, std::string_view val,
Args && ... vals) {
std::string cmd("rpush ");
cmd.append(val);
(cmd.append(" ").append(vals), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Push an element to the end of the list, only if the list already
/// exists.
/// @param key Key where the list is stored.
/// @param val Element to be pushed.
/// @return The length of the list after the operation.
/// @see https://redis.io/commands/rpushx
inline std::optional<uint64_t> rpushx(std::string_view key,
std::string_view val) {
return impl_.command<uint64_t>(fmt::format("rpushx {} {}", key, val));
}
// HASH commands.
/// @brief Remove the given field from hash.
/// @param key Key where the hash is stored.
/// @param field Field to be removed.
/// @return Whether the field has been removed.
/// @retval 1 If the field exists, and has been removed.
/// @retval 0 If the field does not exist.
/// @see https://redis.io/commands/hdel
template <typename... Args>
inline std::optional<uint64_t> hdel(std::string_view key, std::string_view field,
Args && ... fields) {
std::string cmd("hdel");
cmd.append(" ").append(field);
(cmd.append(" ").append(fields), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Check if the given field exists in hash.
/// @param key Key where the hash is stored.
/// @param field Field.
/// @return Whether the field exists.
/// @retval true If the field exists in hash.
/// @retval false If the field does not exist.
/// @see https://redis.io/commands/hexists
inline std::optional<uint64_t> hexists(std::string_view key,
std::string_view field) {
return impl_.command<uint64_t>(fmt::format("hexists {} {}", key, field));
}
/// @brief Get the value of the given field.
/// @param key Key where the hash is stored.
/// @param field Field.
/// @return Value of the given field.
/// @note If field does not exist, `hget` returns `OptionalString{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/hget
inline std::optional<std::string> hget(std::string_view key,
std::string_view field) {
return impl_.command<std::string>(fmt::format("hget {} {}", key, field));
}
/// @brief Get all field-value pairs of the given hash.
///
/// Example:
/// @code{.cpp}
/// std::unordered_map<std::string, std::string> results;
/// // Save all field-value pairs of a Redis hash to an unordered_map<string,
/// string>. redis.hgetall("hash", std::inserter(results, results.begin()));
/// @endcode
/// @param key Key where the hash is stored.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note It's always a bad idea to call `hgetall` on a large hash, since it
/// will block Redis.
/// @see `Redis::hscan`
/// @see https://redis.io/commands/hgetall
inline std::optional<std::vector<std::string>> hgetall(std::string_view key) {
return impl_.command<std::vector<std::string>>(
fmt::format("hgetall {}", key));
}
/// @brief Increment the integer stored at the given field.
/// @param key Key where the hash is stored.
/// @param field Field.
/// @param increment Increment.
/// @return The value of the field after the increment.
/// @see https://redis.io/commands/hincrby
inline std::optional<uint64_t> hincrby(
std::string_view key, std::string_view field, uint64_t increment) {
return impl_.command<uint64_t>(
fmt::format("hincrby {} {} {}", key, field, increment));
}
/// @brief Increment the floating point number stored at the given field.
/// @param key Key where the hash is stored.
/// @param field Field.
/// @param increment Increment.
/// @return The value of the field after the increment.
/// @see https://redis.io/commands/hincrbyfloat
inline std::optional<double> hincrbyfloat(
std::string_view key, std::string_view field, double increment) {
return impl_.command<double>(
fmt::format("hincrbyfloat {} {} {}", key, field, increment));
}
/// @brief Get all fields of the given hash.
/// @param key Key where the hash is stored.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note It's always a bad idea to call `hkeys` on a large hash, since it
/// will block Redis.
/// @see `Redis::hscan`
/// @see https://redis.io/commands/hkeys
inline std::optional<std::vector<std::string>> hkeys(std::string_view key) {
return impl_.command<std::vector<std::string>>(
fmt::format("hkeys {}", key));
}
/// @brief Get the number of fields of the given hash.
/// @param key Key where the hash is stored.
/// @return Number of fields.
/// @see https://redis.io/commands/hlen
inline std::optional<uint64_t> hlen(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("hlen {}", key));
}
/// @brief Get values of multiple fields.
///
/// Example:
/// @code{.cpp}
/// std::vector<std::string> fields = {"f1", "f2"};
/// std::vector<OptionalString> vals;
/// redis.hmget("hash", fields.begin(), fields.end(),
/// std::back_inserter(vals)); for (const auto &val : vals) {
/// if (val)
/// std::cout << *val << std::endl;
/// else
/// std::cout << "field not exist" << std::endl;
/// }
/// @endcode
/// @param key Key where the hash is stored.
/// @param first Iterator to the first field.
/// @param last Off-the-end iterator to the given field range.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note The destination should be a container of `OptionalString` type,
/// since the given field might not exist (in this case, the value of
/// the corresponding field is `OptionalString{}` (`std::nullopt`)).
/// @see https://redis.io/commands/hmget
template <typename... Args>
inline std::optional<std::vector<std::string>> hmget(
std::string_view key, std::string_view field, Args && ... fields) {
std::string cmd("hmget ");
cmd.append(" ").append(key);
cmd.append(" ").append(field);
(cmd.append(" ").append(fields), ...);
return impl_.command<std::vector<std::string>>(std::move(cmd));
}
/// @brief Set multiple field-value pairs of the given hash.
///
/// Example:
/// @code{.cpp}
/// std::unordered_map<std::string, std::string> m = {{"f1", "v1"}, {"f2",
/// "v2"}}; redis.hmset("hash", m.begin(), m.end());
/// @endcode
/// @param key Key where the hash is stored.
/// @param first Iterator to the first field-value pair.
/// @param last Off-the-end iterator to the range.
/// @see https://redis.io/commands/hmset
template <typename... Args>
inline std::optional<std::vector<std::string>> hmset(
std::string_view key, std::string_view field, std::string_view value,
Args && ... args) {
std::string cmd("hmset ");
cmd.append(" ").append(key);
cmd.append(" ").append(field);
cmd.append(" ").append(value);
(cmd.append(" ").append(args), ...);
return impl_.command<std::vector<std::string>>(std::move(cmd));
}
/// @brief Scan fields of the given hash matching the given pattern.
///
/// Example:
/// @code{.cpp}
/// auto cursor = 0LL;
/// std::unordered_map<std::string, std::string> kvs;
/// while (true) {
/// cursor = redis.hscan("hash", cursor, "pattern:*", 10,
/// std::inserter(kvs, kvs.begin())); if (cursor == 0) {
/// break;
/// }
/// }
/// @endcode
/// @param key Key where the hash is stored.
/// @param cursor Cursor.
/// @param pattern Pattern of fields to be scanned.
/// @param count A hint for how many fields to be scanned.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @return The cursor to be used for the next scan operation.
/// @see https://redis.io/commands/hscan
inline std::optional<scan_ret_t> hscan(std::string_view key, uint64_t cursor,
uint64_t count) {
return hscan(key, cursor, "", count);
}
/// @brief Scan fields of the given hash matching the given pattern.
/// @param key Key where the hash is stored.
/// @param cursor Cursor.
/// @param pattern Pattern of fields to be scanned.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @return The cursor to be used for the next scan operation.
/// @see https://redis.io/commands/hscan
inline std::optional<scan_ret_t> hscan(std::string_view key, uint64_t cursor,
std::string_view pattern,
uint64_t count = 0) {
return impl_.hscan(key, cursor, pattern, count);
}
/// @brief Set hash field to value.
/// @param key Key where the hash is stored.
/// @param field Field.
/// @param val Value.
/// @return Whether the given field is a new field.
/// @retval true If the given field didn't exist, and a new field has been
/// added.
/// @retval false If the given field already exists, and its value has been
/// overwritten.
/// @note When `hset` returns false, it does not mean that the method failed
/// to set the field.
/// Instead, it means that the field already exists, and we've
/// overwritten its value. If `hset` fails, it will throw an exception
/// of `Exception` type.
/// @see https://github.com/sewenew/redis-plus-plus/issues/9
/// @see https://redis.io/commands/hset
template <typename... Args>
inline std::optional<uint64_t> hset(std::string_view key, std::string_view field,
std::string_view val, Args && ... args) {
std::string cmd("hset ");
cmd.append(" ").append(field);
cmd.append(" ").append(val);
(cmd.append(" ").append(args), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Set multiple fields of the given hash.
///
/// Example:
/// @code{.cpp}
/// std::unordered_map<std::string, std::string> m = {{"f1", "v1"}, {"f2",
/// "v2"}}; redis.hset("hash", m.begin(), m.end());
/// @endcode
/// @param key Key where the hash is stored.
/// @param first Iterator to the first field to be set.
/// @param last Off-the-end iterator to the given range.
/// @return Number of fields that have been added, i.e. fields that not
/// existed before.
/// @see https://redis.io/commands/hset
inline std::optional<uint64_t> hset(
std::string_view key,
const std::vector<std::pair<std::string_view, std::string_view>>& kvs);
/// @brief Set hash field to value, only if the given field does not exist.
/// @param key Key where the hash is stored.
/// @param field Field.
/// @param val Value.
/// @return Whether the field has been set.
/// @retval true If the field has been set.
/// @retval false If failed to set the field, i.e. the field already exists.
/// @see https://redis.io/commands/hsetnx
inline std::optional<uint64_t> hsetnx(
std::string_view key, std::string_view field, std::string_view val) {
return impl_.command<uint64_t>(
fmt::format("hsetnx {} {} {}", key, field, val));
}
/// @brief Get the length of the string stored at the given field.
/// @param key Key where the hash is stored.
/// @param field Field.
/// @return Length of the string.
/// @see https://redis.io/commands/hstrlen
inline std::optional<uint64_t> hstrlen(std::string_view key,
std::string_view field) {
return impl_.command<uint64_t>(fmt::format("hstrlen {} {}", key, field));
}
/// @brief Get values of all fields stored at the given hash.
/// @param key Key where the hash is stored.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note It's always a bad idea to call `hvals` on a large hash, since it
/// might block Redis.
/// @see `Redis::hscan`
/// @see https://redis.io/commands/hvals
inline std::optional<std::vector<std::string>> hvals(std::string_view key) {
return impl_.command<std::vector<std::string>>(
fmt::format("hvals {}", key));
}
// SET commands.
/// @brief Add a member to the given set.
/// @param key Key where the set is stored.
/// @param member Member to be added.
/// @return Whether the given member is a new member.
/// @retval 1 The member did not exist before, and it has been added now.
/// @retval 0 The member already exists before this operation.
/// @see https://redis.io/commands/sadd
template <typename... Args>
inline std::optional<uint64_t> sadd(std::string_view key, std::string_view member,
Args && ... members) {
std::string cmd("sadd");
cmd.append(" ").append(key);
cmd.append(" ").append(member);
(cmd.append(" ").append(members), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Get the number of members in the set.
/// @param key Key where the set is stored.
/// @return Number of members.
/// @see https://redis.io/commands/scard
inline std::optional<uint64_t> scard(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("scard {}", key));
}
/// @brief Get the difference between the first set and all successive sets.
/// @param first Iterator to the first set.
/// @param last Off-the-end iterator to the range.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @see https://redis.io/commands/sdiff
// TODO: `void sdiff(const StringView &key, Input first, Input last, Output
// output)` is better.
template <typename... Args>
inline std::optional<std::vector<std::string>> sdiff(std::string_view key,
Args && ... keys) {
std::string cmd("sdiff");
cmd.append(" ").append(key);
(cmd.append(" ").append(keys), ...);
return impl_.command<std::vector<std::string>>(std::move(cmd));
}
/// @brief Copy set stored at `key` to `destination`.
/// @param destination Key of the destination set.
/// @param key Key of the source set.
/// @return Number of members of the set.
/// @see https://redis.io/commands/sdiffstore
template <typename... Args>
inline std::optional<uint64_t> sdiffstore(
std::string_view destination, std::string_view key, Args && ... keys) {
std::string cmd("sdiffstore");
cmd.append(" ").append(destination);
cmd.append(" ").append(key);
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Get the intersection between the first set and all successive sets.
/// @param first Iterator to the first set.
/// @param last Off-the-end iterator to the range.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @see https://redis.io/commands/sinter
// TODO: `void sinter(const StringView &key, Input first, Input last, Output
// output)` is better.
template <typename... Args>
inline std::optional<std::vector<std::string>> sinter(std::string_view key,
Args && ... keys) {
std::string cmd("sinter");
cmd.append(" ").append(key);
(cmd.append(" ").append(keys), ...);
return impl_.command<std::vector<std::string>>(std::move(cmd));
}
/// @brief Copy set stored at `key` to `destination`.
/// @param destination Key of the destination set.
/// @param key Key of the source set.
/// @return Number of members of the set.
/// @see https://redis.io/commands/sinter
template <typename... Args>
inline std::optional<uint64_t> sinterstore(
std::string_view destination, std::string_view key, Args && ... keys) {
std::string cmd("sinterstore");
cmd.append(" ").append(destination);
cmd.append(" ").append(key);
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Test if `member` exists in the set stored at key.
/// @param key Key where the set is stored.
/// @param member Member to be checked.
/// @return Whether `member` exists in the set.
/// @retval true If it exists in the set.
/// @retval false If it does not exist in the set, or the given key does not
/// exist.
/// @see https://redis.io/commands/sismember
inline std::optional<uint64_t> sismember(std::string_view key,
std::string_view member) {
return impl_.command<uint64_t>(fmt::format("sismember {} {}", key, member));
}
/// @brief Get all members in the given set.
///
/// Example:
/// @code{.cpp}
/// std::unordered_set<std::string> members1;
/// redis.smembers("set", std::inserter(members1, members1.begin()));
/// std::vector<std::string> members2;
/// redis.smembers("set", std::back_inserter(members2));
/// @endcode
/// @param key Key where the set is stored.
/// @param output Iterator to the destination where the result is saved.
/// @see https://redis.io/commands/smembers
inline std::optional<std::vector<std::string>> smembers(std::string_view key) {
return impl_.command<std::vector<std::string>>(
fmt::format("smembers {}", key));
}
/// @brief Move `member` from one set to another.
/// @param source Key of the set in which the member currently exists.
/// @param destination Key of the destination set.
/// @return Whether the member has been moved.
/// @retval true If the member has been moved.
/// @retval false If `member` does not exist in `source`.
/// @see https://redis.io/commands/smove
inline std::optional<uint64_t> smove(std::string_view source,
std::string_view destination,
std::string_view member) {
return impl_.command<uint64_t>(
fmt::format("smove {} {} {}", source, destination, member));
}
/// @brief Remove a random member from the set.
/// @param key Key where the set is stored.
/// @return The popped member.
/// @note If the set is empty, `spop` returns `OptionalString{}`
/// (`std::nullopt`).
/// @see `Redis::srandmember`
/// @see https://redis.io/commands/spop
inline std::optional<std::vector<std::string>> spop(std::string_view key,
uint64_t count = 1) {
return impl_.command<std::vector<std::string>>(
fmt::format("spop {} {}", key, count));
}
/// @brief Get a random member of the given set.
/// @param key Key where the set is stored.
/// @return A random member.
/// @note If the set is empty, `srandmember` returns `OptionalString{}`
/// (`std::nullopt`).
/// @note This method won't remove the member from the set.
/// @see `Redis::spop`
/// @see https://redis.io/commands/srandmember
inline std::optional<std::string> srandmember(std::string_view key) {
return impl_.command<std::string>(fmt::format("srandmember {}", key));
}
/// @brief Get multiple random members of the given set.
/// @param key Key where the set is stored.
/// @param count Number of members to be returned.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note This method won't remove members from the set.
/// @see `Redis::spop`
/// @see https://redis.io/commands/srandmember
inline std::optional<std::vector<std::string>> srandmember(std::string_view key,
uint64_t count) {
return impl_.command<std::vector<std::string>>(
fmt::format("srandmember {} {}", key, count));
}
/// @brief Remove a member from set.
/// @param key Key where the set is stored.
/// @param member Member to be removed.
/// @return Whether the member has been removed.
/// @retval 1 If the given member exists, and has been removed.
/// @retval 0 If the given member does not exist.
/// @see https://redis.io/commands/srem
template <typename... Args>
inline std::optional<uint64_t> srem(std::string_view key, std::string_view member,
Args && ... members) {
std::string cmd("srem");
cmd.append(" ").append(key);
cmd.append(" ").append(member);
(cmd.append(" ").append(members), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Scan members of the set matching the given pattern.
///
/// Example:
/// @code{.cpp}
/// auto cursor = 0LL;
/// std::unordered_set<std::string> members;
/// while (true) {
/// cursor = redis.sscan("set", cursor, "pattern:*",
/// 10, std::inserter(members, members.begin()));
/// if (cursor == 0) {
/// break;
/// }
/// }
/// @endcode
/// @param key Key where the set is stored.
/// @param cursor Cursor.
/// @param pattern Pattern of fields to be scanned.
/// @param count A hint for how many fields to be scanned.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @return The cursor to be used for the next scan operation.
/// @see https://redis.io/commands/sscan
inline std::optional<scan_ret_t> sscan(std::string_view key, uint64_t cursor,
uint64_t count) {
return sscan(key, cursor, "", count);
}
inline std::optional<scan_ret_t> sscan(std::string_view key, uint64_t cursor,
std::string_view pattern,
uint64_t count = 0) {
return impl_.sscan(key, cursor, pattern, count);
}
/// @brief Get the union between the first set and all successive sets.
/// @param first Iterator to the first set.
/// @param last Off-the-end iterator to the range.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @see https://redis.io/commands/sunion
// TODO: `void sunion(const StringView &key, Input first, Input last, Output
// output)` is better.
template <typename... Args>
inline std::optional<uint64_t> sunion(std::string_view key, Args && ... keys) {
std::string cmd("sunion");
cmd.append(" ").append(key);
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Copy set stored at `key` to `destination`.
/// @param destination Key of the destination set.
/// @param key Key of the source set.
/// @return Number of members of the set.
/// @see https://redis.io/commands/sunionstore
template <typename... Args>
inline std::optional<uint64_t> sunionstore(
std::string_view destination, std::string_view key, Args && ... keys) {
std::string cmd("sunionstore");
cmd.append(" ").append(destination);
cmd.append(" ").append(key);
(cmd.append(" ").append(keys), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
// SORTED SET commands.
/// @brief Pop the member with highest score from sorted set in a blocking
/// way.
/// @param key Key where the sorted set is stored.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-member-score tuple with the highest score.
/// @see `Redis::zpopmax`
/// @see https://redis.io/commands/bzpopmax
inline std::optional<std::vector<std::string>> bzpopmax(
std::initializer_list<std::string_view> keys, uint64_t timeout = 0) {
if (keys.size() == 0) return {};
std::string cmd("bzpopmax");
for (const auto& key : keys) {
cmd.append(" ").append(key);
}
cmd.append(" ").append(std::to_string(timeout));
return impl_.command<std::vector<std::string>>(std::move(cmd));
}
/// @brief Pop the member with lowest score from sorted set in a blocking way.
/// @param key Key where the sorted set is stored.
/// @param timeout Timeout in seconds. 0 means block forever.
/// @return Key-member-score tuple with the lowest score.
/// @note If sorted set is empty and timeout reaches, `bzpopmin` returns
/// `Optional<std::tuple<std::string, std::string, double>>{}`
/// (`std::nullopt`).
/// @see `Redis::zpopmin`
/// @see https://redis.io/commands/bzpopmin
inline std::optional<std::vector<std::string>> bzpopmin(
std::initializer_list<std::string_view> keys, uint64_t timeout = 0) {
if (keys.size() == 0) return {};
std::string cmd("bzpopmin");
for (const auto& key : keys) {
cmd.append(" ").append(key);
}
cmd.append(" ").append(std::to_string(timeout));
return impl_.command<std::vector<std::string>>(std::move(cmd));
}
/// @brief Add or update a member with score to sorted set.
/// @param key Key where the sorted set is stored.
/// @param member Member to be added.
/// @param score Score of the member.
/// @param type Options for zadd command:
/// - UpdateType::EXIST: Add the member only if it already exists.
/// - UpdateType::NOT_EXIST: Add the member only if it does not
/// exist.
/// - UpdateType::ALWAYS: Always add the member no matter whether
/// it exists.
/// @param changed Whether change the return value from number of newly added
/// member to
/// number of members changed (i.e. added and updated).
/// @return Number of added members or number of added and updated members
/// depends on `changed`.
/// @note We don't support the INCR option, because in this case, the return
/// value of zadd
/// command is NOT of type uint64_t. However, you can always use the
/// generic interface to send zadd command with INCR option: `auto score
/// = redis.command<OptionalDouble>("ZADD", "key", "XX", "INCR", 10,
/// "mem");`
/// @see `UpdateType`
/// @see https://redis.io/commands/zadd
inline std::optional<uint64_t> zadd(std::string_view key, std::string_view member,
double score,
UpdateType type = UpdateType::ALWAYS) {
return impl_.zadd(key, member, score, type);
}
/// @brief Add or update multiple members with score to sorted set.
///
/// Example:
/// @code{.cpp}
/// std::unordered_map<std::string, double> m = {{"m1", 1.2}, {"m2", 2.3}};
/// redis.zadd("zset", m.begin(), m.end());
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param first Iterator to the first member-score pair.
/// @param last Off-the-end iterator to the member-score pairs range.
/// @param type Options for zadd command:
/// - UpdateType::EXIST: Add the member only if it already exists.
/// - UpdateType::NOT_EXIST: Add the member only if it does not
/// exist.
/// - UpdateType::ALWAYS: Always add the member no matter whether
/// it exists.
/// @param changed Whether change the return value from number of newly added
/// member to
/// number of members changed (i.e. added and updated).
/// @return Number of added members or number of added and updated members
/// depends on `changed`.
/// @note We don't support the INCR option, because in this case, the return
/// value of zadd
/// command is NOT of type uint64_t. However, you can always use the
/// generic interface to send zadd command with INCR option: `auto score
/// = redis.command<OptionalDouble>("ZADD", "key", "XX", "INCR", 10,
/// "mem");`
/// @see `UpdateType`
/// @see https://redis.io/commands/zadd
inline std::optional<uint64_t> zadd(
std::string_view key,
std::vector<std::pair<std::string_view, double>> kvs,
UpdateType type = UpdateType::ALWAYS) {
return impl_.zadd(key, kvs, type);
}
/// @brief Add or update multiple members with score to sorted set.
///
/// Example:
/// @code{.cpp}
/// redis.zadd("zset", {std::make_pair("m1", 1.4),
/// std::make_pair("m2", 2.3)});
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param first Iterator to the first member-score pair.
/// @param last Off-the-end iterator to the member-score pairs range.
/// @param type Options for zadd command:
/// - UpdateType::EXIST: Add the member only if it already exists.
/// - UpdateType::NOT_EXIST: Add the member only if it does not
/// exist.
/// - UpdateType::ALWAYS: Always add the member no matter whether
/// it exists.
/// @param changed Whether change the return value from number of newly added
/// member to
/// number of members changed (i.e. added and updated).
/// @return Number of added members or number of added and updated members
/// depends on `changed`.
/// @note We don't support the INCR option, because in this case, the return
/// value of zadd
/// command is NOT of type uint64_t. However, you can always use the
/// generic interface to send zadd command with INCR option: `auto score
/// = redis.command<OptionalDouble>("ZADD", "key", "XX", "INCR", 10,
/// "mem");`
/// @see `UpdateType`
/// @see https://redis.io/commands/zadd
template <typename T>
inline std::optional<uint64_t> zadd(
std::string_view key, std::initializer_list<T> il,
UpdateType type = UpdateType::ALWAYS, bool changed = false) {
return zadd(key, il.begin(), il.end(), type, changed);
}
/// @brief Get the number of members in the sorted set.
/// @param key Key where the sorted set is stored.
/// @return Number of members in the sorted set.
/// @see https://redis.io/commands/zcard
inline std::optional<uint64_t> zcard(std::string_view key) {
return impl_.command<uint64_t>(fmt::format("zcard {}", key));
}
/// @brief Get the number of members with score between a min-max score range.
///
/// Example:
/// @code{.cpp}
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param interval The min-max score range.
/// @return Number of members with score between a min-max score range.
/// @see `BoundedInterval`
/// @see `LeftBoundedInterval`
/// @see `RightBoundedInterval`
/// @see `UnboundedInterval`
/// @see `BoundType`
/// @see https://redis.io/commands/zcount
// TODO: add a string version of Interval: zcount("key", "2.3", "5").
inline std::optional<uint64_t> zcount(std::string_view key, std::string_view min,
std::string_view max) {
return impl_.command<uint64_t>(
fmt::format("zcount {} {} {}", key, min, max));
}
/// @brief Increment the score of given member.
/// @param key Key where the sorted set is stored.
/// @param increment Increment.
/// @param member Member.
/// @return The score of the member after the operation.
/// @see https://redis.io/commands/zincrby
inline std::optional<double> zincrby(std::string_view key, double increment,
std::string_view member) {
return impl_.command<double>(
fmt::format("zincrby {} {} {}", key, increment, member));
}
/*
/// @brief Copy a sorted set to another one with the scores being
multiplied by a factor.
/// @param destination Key of the destination sorted set.
/// @param key Key of the source sorted set.
/// @param weight Weight to be multiplied to the score of each member.
/// @return The number of members in the sorted set.
/// @note There's no aggregation type parameter for single key
overload, since these 3 types
/// have the same effect.
/// @see `Redis::zunionstore`
/// @see https://redis.io/commands/zinterstore
//inline std::optional<uint64_t> zinterstore(std::string_view destination,
std::string_view key, double weight) {
// return impl_.command<double>(fmt::format("zinterstore {} {} {}",
key, increment, member));
//}
/// @brief Get intersection of multiple sorted sets, and store the
result to another one.
///
/// Example:
/// @code{.cpp}
/// // Use the default weight, i.e. 1,
/// // and use the sum of the all scores as the score of the result:
/// redis.zinterstore("destination", {"k1", "k2"});
/// // Each sorted set has a different weight,
/// // and the score of the result is the min of all scores.
/// redis.zinterstore("destination",
/// {std::make_pair("k1", 1), std::make_pair("k2", 2)},
Aggregation::MIN);
/// @endcode
/// @param destination Key of the destination sorted set.
/// @param il Initializer list of sorted set.
/// @param type How the scores are aggregated.
/// - Aggregation::SUM: Score of a member is the sum of
all scores.
/// - Aggregation::MIN: Score of a member is the min of
all scores.
/// - Aggregation::MAX: Score of a member is the max of
all scores.
/// @return The number of members in the resulting sorted set.
/// @note The score of each member can be multiplied by a factor, i.e.
weight. If `T` is
/// of type `std::string`, we use the default weight, i.e. 1,
and send
/// *ZINTERSTORE dest numkeys key [key ...] [AGGREGATE
SUM|MIN|MAX]* command.
/// If `T` is of type `std::pair<std::string, double>`, i.e.
key-weight pair,
/// we send the command with the given weights:
/// *ZINTERSTORE dest numkeys key [key ...] [WEIGHTS weight
[weight ...]] [AGGREGATE SUM|MIN|MAX]*.
/// See the *Example* part for examples on how to use this
command.
/// @see `Redis::zunionstore`
/// @see https://redis.io/commands/zinterstore
template <typename T>
inline std::optional<uint64_t> zinterstore(std::string_view destination,
std::initializer_list<T> il,
Aggregation type = Aggregation::SUM) {
return zinterstore(destination, il.begin(), il.end(), type);
}
*/
/// @brief Get the number of members between a min-max range in
/// lexicographical order.
///
/// @param key Key where the sorted set is stored.
/// @param interval The min-max range in lexicographical order.
/// @return Number of members between a min-max range in lexicographical
/// order.
/// @see `BoundedInterval`
/// @see `LeftBoundedInterval`
/// @see `RightBoundedInterval`
/// @see `UnboundedInterval`
/// @see `BoundType`
/// @see https://redis.io/commands/zlexcount
// TODO: add a string version of Interval: zlexcount("key", "(abc", "abd").
inline std::optional<uint64_t> zlexcount(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<uint64_t>(
fmt::format("zlexcount {} {} {}", key, min, max));
}
/// @brief Pop the member with highest score from sorted set.
/// @param key Key where the sorted set is stored.
/// @return Member-score pair with the highest score.
/// @note If sorted set is empty `zpopmax` returns
/// `Optional<std::pair<std::string, double>>{}` (`std::nullopt`).
/// @see `Redis::bzpopmax`
/// @see https://redis.io/commands/zpopmax
inline std::optional<std::vector<std::string>> zpopmax(std::string_view key,
uint64_t count = 1) {
return impl_.command<std::vector<std::string>>(
fmt::format("zpopmax {} {}", key, count));
}
/// @brief Pop the member with lowest score from sorted set.
/// @param key Key where the sorted set is stored.
/// @return Member-score pair with the lowest score.
/// @note If sorted set is empty `zpopmin` returns
/// `Optional<std::pair<std::string, double>>{}` (`std::nullopt`).
/// @see `Redis::bzpopmin`
/// @see https://redis.io/commands/zpopmin
inline std::optional<std::vector<std::string>> zpopmin(std::string_view key) {
return impl_.command<std::vector<std::string>>(
fmt::format("zpopmin {}", key));
}
/// @brief Get a range of members by rank (ordered from lowest to highest).
///
/// Example:
/// @code{.cpp}
/// // send *ZRANGE* command without the *WITHSCORES* option:
/// std::vector<std::string> result;
/// redis.zrange("zset", 0, -1, std::back_inserter(result));
/// // send command with *WITHSCORES* option:
/// std::unordered_map<std::string, double> with_score;
/// redis.zrange("zset", 0, -1, std::inserter(with_score, with_score.end()));
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param start Start rank. Inclusive and can be negative.
/// @param stop Stop rank. Inclusive and can be negative.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note This method can also return the score of each member. If `output` is
/// an iterator
/// to a container of `std::string`, we send *ZRANGE key start stop*
/// command. If it's an iterator to a container of
/// `std::pair<std::string, double>`, we send *ZRANGE key start stop
/// WITHSCORES* command. See the *Example* part on how to use this
/// method.
/// @see `Redis::zrevrange`
/// @see https://redis.io/commands/zrange
inline std::optional<std::vector<std::string>> zrange(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<std::vector<std::string>>(
fmt::format("zrange {} {} {}", key, min, max));
}
/// @brief Get a range of members by lexicographical order (from lowest to
/// highest).
///
/// Example:
/// @code{.cpp}
/// std::vector<std::string> result;
/// // Get members between [abc, abd].
/// redis.zrangebylex("zset", BoundedInterval<std::string>("abc", "abd",
/// BoundType::CLOSED),
/// std::back_inserter(result));
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param interval the min-max range by lexicographical order.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note See `Redis::zlexcount`'s *Example* part for how to set `interval`
/// parameter.
/// @see `Redis::zlexcount`
/// @see `BoundedInterval`
/// @see `LeftBoundedInterval`
/// @see `RightBoundedInterval`
/// @see `UnboundedInterval`
/// @see `BoundType`
/// @see `Redis::zrevrangebylex`
/// @see https://redis.io/commands/zrangebylex
///
inline std::optional<std::vector<std::string>> zrangebylex(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<std::vector<std::string>>(
fmt::format("zrangebylex {} {} {}", key, min, max));
}
/// @brief Get a range of members by score (ordered from lowest to highest).
///
/// Example:
/// @code{.cpp}
/// // Send *ZRANGEBYSCORE* command without the *WITHSCORES* option:
/// std::vector<std::string> result;
/// // Get members whose score between (3, 6).
/// redis.zrangebyscore("zset", BoundedInterval<double>(3, 6,
/// BoundType::OPEN),
/// std::back_inserter(result));
/// // Send command with *WITHSCORES* option:
/// std::unordered_map<std::string, double> with_score;
/// // Get members whose score between [3, +inf).
/// redis.zrangebyscore("zset", LeftBoundedInterval<double>(3,
/// BoundType::RIGHT_OPEN),
/// std::inserter(with_score, with_score.end()));
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param interval the min-max range by score.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note This method can also return the score of each member. If `output` is
/// an iterator
/// to a container of `std::string`, we send *ZRANGEBYSCORE key min max*
/// command. If it's an iterator to a container of
/// `std::pair<std::string, double>`, we send *ZRANGEBYSCORE key min max
/// WITHSCORES* command. See the *Example* part on how to use this
/// method.
/// @note See `Redis::zcount`'s *Example* part for how to set the `interval`
/// parameter.
/// @see `Redis::zrevrangebyscore`
/// @see https://redis.io/commands/zrangebyscore
inline std::optional<std::vector<std::string>> zrangebyscore(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<std::vector<std::string>>(
fmt::format("zrangebyscore {} {} {}", key, min, max));
}
/// @brief Get the rank (from low to high) of the given member in the sorted
/// set.
/// @param key Key where the sorted set is stored.
/// @param member Member.
/// @return The rank of the given member.
/// @note If the member does not exist, `zrank` returns `OptionalLongLong{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/zrank
inline std::optional<uint64_t> zrank(std::string_view key,
std::string_view member) {
return impl_.command<uint64_t>(fmt::format("zrank {} {}", key, member));
}
/// @brief Remove the given member from sorted set.
/// @param key Key where the sorted set is stored.
/// @param member Member to be removed.
/// @return Whether the member has been removed.
/// @retval 1 If the member exists, and has been removed.
/// @retval 0 If the member does not exist.
/// @see https://redis.io/commands/zrem
template <typename... Args>
inline std::optional<uint64_t> zrem(std::string_view key, std::string_view member,
Args && ... members) {
std::string cmd("zrem");
cmd.append(" ").append(key);
cmd.append(" ").append(member);
(cmd.append(" ").append(members), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
/// @brief Remove members in the given range of lexicographical order.
/// @param key Key where the sorted set is stored.
/// @param interval the min-max range by lexicographical order.
/// @note See `Redis::zlexcount`'s *Example* part for how to set `interval`
/// parameter.
/// @return Number of members removed.
/// @see `Redis::zlexcount`
/// @see `BoundedInterval`
/// @see `LeftBoundedInterval`
/// @see `RightBoundedInterval`
/// @see `UnboundedInterval`
/// @see `BoundType`
/// @see https://redis.io/commands/zremrangebylex
inline std::optional<uint64_t> zremrangebylex(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<uint64_t>(
fmt::format("zremrangebylex {} {} {}", key, min, max));
}
/// @brief Remove members in the given range ordered by rank.
/// @param key Key where the sorted set is stored.
/// @param start Start rank.
/// @param stop Stop rank.
/// @return Number of members removed.
/// @see https://redis.io/commands/zremrangebyrank
inline std::optional<uint64_t> zremrangebyrank(std::string_view key,
uint64_t start, uint64_t stop) {
return impl_.command<uint64_t>(
fmt::format("zremrangebyrank {} {} {}", key, start, stop));
}
/// @brief Remove members in the given range ordered by score.
/// @param key Key where the sorted set is stored.
/// @param interval the min-max range by score.
/// @return Number of members removed.
/// @note See `Redis::zcount`'s *Example* part for how to set the `interval`
/// parameter.
/// @see https://redis.io/commands/zremrangebyscore
inline std::optional<uint64_t> zremrangebyscore(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<uint64_t>(
fmt::format("zremrangebyscore {} {} {}", key, min, max));
}
/// @brief Get a range of members by rank (ordered from highest to lowest).
///
/// Example:
/// @code{.cpp}
/// // send *ZREVRANGE* command without the *WITHSCORES* option:
/// std::vector<std::string> result;
/// redis.zrevrange("key", 0, -1, std::back_inserter(result));
/// // send command with *WITHSCORES* option:
/// std::unordered_map<std::string, double> with_score;
/// redis.zrevrange("key", 0, -1, std::inserter(with_score,
/// with_score.end()));
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param start Start rank. Inclusive and can be negative.
/// @param stop Stop rank. Inclusive and can be negative.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note This method can also return the score of each member. If `output` is
/// an iterator
/// to a container of `std::string`, we send *ZREVRANGE key start stop*
/// command. If it's an iterator to a container of
/// `std::pair<std::string, double>`, we send *ZREVRANGE key start stop
/// WITHSCORES* command. See the *Example* part on how to use this
/// method.
/// @see `Redis::zrange`
/// @see https://redis.io/commands/zrevrange
inline std::optional<std::string> zrevrange(std::string_view key, uint64_t start,
uint64_t stop,
bool withscores = false) {
return impl_.command<std::string>(
fmt::format("zrevrange {} {} {} {}", key, start, stop,
(withscores ? "WITHSCORES" : "")));
}
/// @brief Get a range of members by lexicographical order (from highest to
/// lowest).
///
/// Example:
/// @code{.cpp}
/// std::vector<std::string> result;
/// // Get members between [abc, abd] in reverse order.
/// redis.zrevrangebylex("zset", BoundedInterval<std::string>("abc", "abd",
/// BoundType::CLOSED),
/// std::back_inserter(result));
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param interval the min-max range by lexicographical order.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note See `Redis::zlexcount`'s *Example* part for how to set `interval`
/// parameter.
/// @see `Redis::zlexcount`
/// @see `BoundedInterval`
/// @see `LeftBoundedInterval`
/// @see `RightBoundedInterval`
/// @see `UnboundedInterval`
/// @see `BoundType`
/// @see `Redis::zrangebylex`
/// @see https://redis.io/commands/zrevrangebylex
inline std::optional<std::string> zrevrangebylex(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<std::string>(
fmt::format("zrevrangebylex {} {} {}", key, min, max));
}
/// @brief Get a range of members by score (ordered from highest to lowest).
///
/// Example:
/// @code{.cpp}
/// // Send *ZREVRANGEBYSCORE* command without the *WITHSCORES* option:
/// std::vector<std::string> result;
/// // Get members whose score between (3, 6) in reverse order.
/// redis.zrevrangebyscore("zset", BoundedInterval<double>(3, 6,
/// BoundType::OPEN),
/// std::back_inserter(result));
/// // Send command with *WITHSCORES* option:
/// std::unordered_map<std::string, double> with_score;
/// // Get members whose score between [3, +inf) in reverse order.
/// redis.zrevrangebyscore("zset", LeftBoundedInterval<double>(3,
/// BoundType::RIGHT_OPEN),
/// std::inserter(with_score, with_score.end()));
/// @endcode
/// @param key Key where the sorted set is stored.
/// @param interval the min-max range by score.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @note This method can also return the score of each member. If `output` is
/// an iterator
/// to a container of `std::string`, we send *ZREVRANGEBYSCORE key min
/// max* command. If it's an iterator to a container of
/// `std::pair<std::string, double>`, we send *ZREVRANGEBYSCORE key min
/// max WITHSCORES* command. See the *Example* part on how to use this
/// method.
/// @note See `Redis::zcount`'s *Example* part for how to set the `interval`
/// parameter.
/// @see `Redis::zrangebyscore`
/// @see https://redis.io/commands/zrevrangebyscore
template <typename Interval, typename Output>
inline std::optional<std::string> zrevrangebyscore(
std::string_view key, std::string_view min, std::string_view max) {
return impl_.command<std::string>(
fmt::format("zrevrangebyscore {} {} {}", key, min, max));
}
/// @brief Get the rank (from high to low) of the given member in the sorted
/// set.
/// @param key Key where the sorted set is stored.
/// @param member Member.
/// @return The rank of the given member.
/// @note If the member does not exist, `zrevrank` returns
/// `OptionalLongLong{}` (`std::nullopt`).
/// @see https://redis.io/commands/zrevrank
inline std::optional<uint64_t> zrevrank(std::string_view key,
std::string_view member) {
return impl_.command<uint64_t>(fmt::format("zrevrank {} {}", key, member));
}
/// @brief Scan all members of the given sorted set.
/// @param key Key where the sorted set is stored.
/// @param cursor Cursor.
/// @param count A hint for how many members to be scanned.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @return The cursor to be used for the next scan operation.
/// @see https://redis.io/commands/zscan
inline std::optional<uint64_t> zscan(std::string_view key, uint64_t cursor,
uint64_t count) {
return zscan(key, cursor, count);
}
/// @brief Scan all members of the given sorted set.
/// @param key Key where the sorted set is stored.
/// @param cursor Cursor.
/// @param output Output iterator to the destination where the result is
/// saved.
/// @return The cursor to be used for the next scan operation.
/// @see https://redis.io/commands/zscan
inline std::optional<scan_ret_t> zscan(std::string_view key, uint64_t cursor,
std::string_view pattern, uint64_t count) {
return impl_.zscan(key, cursor, pattern, count);
}
/// @brief Get the score of the given member.
/// @param key Key where the sorted set is stored.
/// @param member Member.
/// @return The score of the member.
/// @note If member does not exist, `zscore` returns `OptionalDouble{}`
/// (`std::nullopt`).
/// @see https://redis.io/commands/zscore
inline std::optional<double> zscore(std::string_view key,
std::string_view member) {
return impl_.command<double>(fmt::format("zscore {} {}", key, member));
}
/// @brief Copy a sorted set to another one with the scores being multiplied
/// by a factor.
/// @param destination Key of the destination sorted set.
/// @param key Key of the source sorted set.
/// @param weight Weight to be multiplied to the score of each member.
/// @return The number of members in the sorted set.
/// @note There's no aggregation type parameter for single key overload,
/// since these 3 types
/// have the same effect.
/// @see `Redis::zinterstore`
/// @see https://redis.io/commands/zinterstore
inline std::optional<uint64_t> zunionstore(
std::string_view destination,
std::initializer_list<std::string_view> keys,
std::string_view aggregate = "SUM") {
return impl_.zunionstore(destination, keys, aggregate);
}
/// @brief Get union of multiple sorted sets, and store the result to another
/// one.
///
/// Example:
/// @code{.cpp}
/// // Use the default weight, i.e. 1,
/// // and use the sum of the all scores as the score of the result:
/// std::vector<std::string> keys = {"k1", "k2", "k3"};
/// redis.zunionstore("destination", keys.begin(), keys.end());
/// // Each sorted set has a different weight,
/// // and the score of the result is the min of all scores.
/// std::vector<std::pair<std::string, double>> keys_with_weights = {{"k1",
/// 1}, {"k2", 2}}; redis.zunionstore("destination",
/// keys_with_weights.begin(),
/// keys_with_weights.end(), Aggregation::MIN);
/// // NOTE: `keys_with_weights` can also be of type
/// `std::unordered_map<std::string, double>`.
/// // However, it will be slower than std::vector<std::pair<std::string,
/// double>>, since we use
/// // `std::distance(first, last)` to calculate the *numkeys* parameter.
/// @endcode
/// @param destination Key of the destination sorted set.
/// @param first Iterator to the first sorted set (might with weight).
/// @param last Off-the-end iterator to the sorted set range.
/// @param type How the scores are aggregated.
/// - Aggregation::SUM: Score of a member is the sum of all
/// scores.
/// - Aggregation::MIN: Score of a member is the min of all
/// scores.
/// - Aggregation::MAX: Score of a member is the max of all
/// scores.
/// @return The number of members in the resulting sorted set.
/// @note The score of each member can be multiplied by a factor, i.e. weight.
/// If `Input` is an
/// iterator to a container of `std::string`, we use the default weight,
/// i.e. 1, and send *ZUNIONSTORE dest numkeys key [key ...] [AGGREGATE
/// SUM|MIN|MAX]* command.
/// If `Input` is an iterator to a container of `std::pair<std::string,
/// double>`, i.e. key-weight pair, we send the command with the given
/// weights:
/// *ZUNIONSTORE dest numkeys key [key ...] [WEIGHTS weight [weight
/// ...]] [AGGREGATE SUM|MIN|MAX]*. See the *Example* part for examples
/// on how to use this command.
/// @see `Redis::zinterstore`
/// @see https://redis.io/commands/zunionstore
inline std::optional<uint64_t> zunionstore(
std::string_view destination,
std::vector<std::pair<std::string_view, double>> kvs,
std::string_view aggregate = "SUM") {
return impl_.zunionstore(destination, kvs, aggregate);
}
// HYPERLOGLOG commands.
/// @brief Add the given element to a hyperloglog.
/// @param key Key of the hyperloglog.
/// @param element Element to be added.
/// @return Whether any of hyperloglog's internal register has been altered.
/// @retval true If at least one internal register has been altered.
/// @retval false If none of internal registers has been altered.
/// @note When `pfadd` returns false, it does not mean that this method failed
/// to add
/// an element to the hyperloglog. Instead it means that the internal
/// registers were not altered. If `pfadd` fails, it will throw an
/// exception of `Exception` type.
/// @see https://redis.io/commands/pfadd
template <typename... Args>
inline std::optional<uint64_t> pfadd(std::string_view key, Args && ... elements) {
std::string cmd("pfadd");
cmd.append(" ").append(key);
(cmd.append(" ").append(elements), ...);
return impl_.command<uint64_t>(std::move(cmd));
}
private:
impl::sync_connection_impl impl_;
};
} // namespace coro_redis |
; A195028: a(n) = n*(14*n + 13).
; 0,27,82,165,276,415,582,777,1000,1251,1530,1837,2172,2535,2926,3345,3792,4267,4770,5301,5860,6447,7062,7705,8376,9075,9802,10557,11340,12151,12990,13857,14752,15675,16626,17605,18612,19647,20710,21801,22920,24067,25242,26445,27676,28935,30222,31537,32880,34251,35650,37077,38532,40015,41526,43065,44632,46227,47850,49501,51180,52887,54622,56385,58176,59995,61842,63717,65620,67551,69510,71497,73512,75555,77626,79725,81852,84007,86190,88401,90640,92907,95202,97525,99876,102255,104662,107097,109560
mov $1,14
mul $1,$0
add $1,13
mul $1,$0
mov $0,$1
|
; A023576: Greatest prime divisor of prime(n)+3.
; Submitted by Jon Maiga
; 5,3,2,5,7,2,5,11,13,2,17,5,11,23,5,7,31,2,7,37,19,41,43,23,5,13,53,11,7,29,13,67,7,71,19,11,5,83,17,11,13,23,97,7,5,101,107,113,23,29,59,11,61,127,13,19,17,137,7,71,13,37,31,157,79,5,167,17,7,11,89,181,37,47,191,193,7,5,101,103,211,53,31,109,17,223,113,23,29,233,47,241,7,19,251,23,2,131,263,17
seq $0,6005 ; The odd prime numbers together with 1.
trn $0,2
add $0,4
seq $0,6530 ; Gpf(n): greatest prime dividing n, for n >= 2; a(1)=1.
|
; A019445: Form a permutation of the positive integers, p_1, p_2, ..., such that the average of each initial segment is an integer, using the greedy algorithm to define p_n; sequence gives p_1+..+p_n.
; Submitted by Jon Maiga
; 1,4,6,12,20,24,35,40,54,70,77,96,117,126,150,160,187,216,228,260,273,308,345,360,400,442,459,504,522,570,620,640,693,748,770,828,851,912,975,1000,1066,1092,1161,1232,1260,1334,1410,1440,1519,1550
mov $1,$0
seq $0,19446 ; a(n) = ceiling(n/tau), where tau = (1+sqrt(5))/2.
mul $1,$0
add $0,$1
|
; A162964: a(n) = sigma(sigma(sigma(sigma(sigma(n))))).
; Submitted by Jon Maiga
; 1,15,24,60,120,360,168,480,168,360,360,1170,480,1512,1512,210,360,1170,728,1680,576,480,1512,4800,210,1680,1344,3276,992,2016,576,1651,1560,3276,1560,1512,1512,4800,3276,4064,1680,5952,1560,5040,4800,2016,1560,5040,1020,1240,2016,1596,3276,10192,2016,10192,3024,4064,4800,15748,1680,5952,1792,1240,5040,1920,2880,9906,5952,1920,2016,6552,1920,6120,5040,6552,5952,15748,3024,9920,960,9906,5040,19344,5376,6552,10192,8064,4064,8064,4800,15748,2880,1920,10192,16256,1596,4480,5040,1178
mov $2,49
lpb $2
seq $0,203 ; a(n) = sigma(n), the sum of the divisors of n. Also called sigma_1(n).
sub $0,1
mul $2,5
div $2,12
lpe
add $0,1
|
INCLUDE "hardware.inc"
SECTION "Header", rom0[$100]
EntryPoint:
di
jp Start
REPT $150 - $104
db 0
ENDR
SECTION "Game Code", rom0
Start:
.waitVBlank
ld a, [rLY]
cp a, 144
jr c, .waitVBlank
xor a; ld a, 0
ld [rLCDC], a
ld hl, $9000
ld de, FontTiles
ld bc, FontTilesEnd - FontTiles
.copyFont
ld a, [de]
ld [hli], a
inc de
dec bc
ld a, b
or a, c
jr nz, .copyFont
ld hl, $9900; print sentence on top screen
ld de, HelloWorldStr
.copyString
ld a, [de]
ld [hli], a
inc de
and a
jr nz, .copyString
ld a, %11100100
ld [rBGP], a
xor a; ld a, 0
ld [rSCY], a
ld [rSCX], a
ld [rNR52], a
ld a, %10000001
ld [rLCDC], a
.lockup
jr .lockup
SECTION "Font", ROM0
FontTiles:
INCBIN "font.chr"
FontTilesEnd:
SECTION "Hello World string", ROM0
HelloWorldStr:
db "Hello Github !", 0 |
;
; Copyright (C) 2021 by Intel Corporation
;
; Permission to use, copy, modify, and/or distribute this software for any
; purpose with or without fee is hereby granted.
;
; THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
; REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
; AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
; INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
; LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
; OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
; PERFORMANCE OF THIS SOFTWARE.
;
; .globl decompress_novbmi
; void decompress_novbmi(int len, uint8_t *out, const uint8_t *in);
; On entry:
; ecx = len
; rdx = out
; r8 = in
.code
decompress_novbmi PROC public
; mov rdx, compressedData
mov r9, rdx ; mov r9, decompressedData
mov eax, ecx ; mov eax, numOfElements
shr eax, 3
xor rdx, rdx
lp:
mov rcx, qword ptr [r8]
mov r10, rcx
and r10, 1fh
mov r11, rcx
mov byte ptr [r9+rdx*8], r10b
mov r10, rcx
shr r10, 0ah
add r8, 5h
and r10, 1fh
mov byte ptr [r9+rdx*8+2h], r10b
mov r10, rcx
shr r10, 0fh
and r10, 1fh
mov byte ptr [r9+rdx*8+3h], r10b
mov r10, rcx
shr r10, 14h
and r10, 1fh
mov byte ptr [r9+rdx*8+4h], r10b
mov r10, rcx
shr r10, 19h
and r10, 1fh
mov byte ptr [r9+rdx*8+5h], r10b
mov r10, rcx
shr r11, 5h
shr r10, 1eh
and r11, 1fh
shr rcx, 23h
and r10, 1fh
and rcx, 1fh
mov byte ptr [r9+rdx*8+1h], r11b
mov byte ptr [r9+rdx*8+6h], r10b
mov byte ptr [r9+rdx*8+7h], cl
inc rdx
cmp rdx, rax
jb lp
ret
decompress_novbmi ENDP
end |
#include <dirent.h>
#include <unistd.h>
#include <sstream>
#include <string>
#include <vector>
#include "linux_parser.h"
using std::stof;
using std::string;
using std::to_string;
using std::vector;
// DONE: An example of how to read data from the filesystem
string LinuxParser::OperatingSystem() {
string line;
string key;
string value;
std::ifstream filestream(kOSPath);
if (filestream.is_open()) {
while (std::getline(filestream, line)) {
std::replace(line.begin(), line.end(), ' ', '_');
std::replace(line.begin(), line.end(), '=', ' ');
std::replace(line.begin(), line.end(), '"', ' ');
std::istringstream linestream(line);
while (linestream >> key >> value) {
if (key == "PRETTY_NAME") {
std::replace(value.begin(), value.end(), '_', ' ');
return value;
}
}
}
}
return value;
}
// DONE: An example of how to read data from the filesystem
string LinuxParser::Kernel() {
string os, kernel, version;
string line;
std::ifstream stream(kProcDirectory + kVersionFilename);
if (stream.is_open()) {
std::getline(stream, line);
std::istringstream linestream(line);
linestream >> os >> version >> kernel;
}
return kernel;
}
// BONUS: Update this to use std::filesystem
vector<int> LinuxParser::Pids() {
vector<int> pids;
DIR* directory = opendir(kProcDirectory.c_str());
struct dirent* file;
while ((file = readdir(directory)) != nullptr) {
// Is this a directory?
if (file->d_type == DT_DIR) {
// Is every character of the name a digit?
string filename(file->d_name);
if (std::all_of(filename.begin(), filename.end(), isdigit)) {
int pid = stoi(filename);
pids.push_back(pid);
}
}
}
closedir(directory);
return pids;
}
float LinuxParser::MemoryUtilization(){
std::ifstream filesteam(kProcDirectory + kMeminfoFilename);
string key , line,value ;
float memtotal, memfree,buffers; //memavilable,
if(filesteam.is_open()) {
while (std::getline(filesteam, line)) {
std::istringstream lineStream(line);
while(lineStream >> key >> value){
if(key == "MemTotal:") memtotal = stof(value);
else if(key == "MemFree:") memfree =stof(value);
// else if(key == "MemAvilable:") memavilable = stof(value);
else if(key == "Buffers:") buffers = stof(value);
}
}
}
return ((memtotal - memfree + buffers ) / memtotal );
}
long LinuxParser::UpTime() {
long uptime;
string idle;
string line;
std::ifstream filestream(kProcDirectory + kUptimeFilename);
if (filestream.is_open()) {
std::getline(filestream, line);
std::istringstream linestream(line);
linestream >> uptime >> idle;
}
return uptime;
}
// for Process::CpuUtilization()
float LinuxParser::ProcessTime(int pid) {
string line, value;
std::ifstream filestream(kProcDirectory + to_string(pid) + kStatFilename);
float utime, stime, cutime, cstime, total_time , seconds;
vector<string> values;
if (filestream.is_open()) {
std::getline(filestream, line);
std::istringstream linestream(line);
while (linestream >> value) {
values.push_back(value);
}
}
//get all values needed
utime = stof( values[13]);
stime = stof( values[14]);
cutime = stof( values[15]);
cstime = stof( values[16]);
//apply formula
total_time = utime + stime;
total_time = total_time + cutime + cstime;
seconds = UpTime(pid) ;
float f = (total_time/100 / seconds);
return f;
}
//for processor
vector<string> LinuxParser::CpuUtilization() {
string line, value;
std::ifstream filestream(kProcDirectory + kStatFilename);
vector<string> tem;
if (filestream.is_open()) {
std::getline(filestream, line);
std::istringstream linestream(line);
while (linestream >> value) {
tem.emplace_back(value);
};
}
return tem;
}
// Read and return the total number of processes
int LinuxParser::TotalProcesses() {
string line, key;
int value;
std::ifstream filestream(kProcDirectory + kStatFilename);
if (filestream.is_open()) {
while (std::getline(filestream, line)) {
std::istringstream linestream(line);
while (linestream >> key >> value) {
if (key == "processes") return value;
}
}
}
return 0;
}
// Read and return the number of running processes
int LinuxParser::RunningProcesses() {
string line, key;
int value;
std::ifstream filestream(kProcDirectory + kStatFilename);
if (filestream.is_open()) {
while (std::getline(filestream, line)) {
std::istringstream linestream(line);
while (linestream >> key >> value) {
if (key == "procs_running") return value;
}
}
}
return 0;
}
// Read and return the command associated with a process
string LinuxParser::Command(int pid){
string line, key, value;
std::ifstream filestream(kProcDirectory + to_string(pid) + kCmdlineFilename);
if(filestream.is_open()) {
while (std::getline(filestream, line)) {
std::istringstream linestream(line);
while (linestream >> value) {
key = key + value + " ";
}
}
}
return key;
}
// Read and return the memory used by a process
string LinuxParser::Ram(int pid) {
string line, key, value;
int mb;
std::ifstream filestream(kProcDirectory + std::to_string(pid) +
kStatusFilename);
if (filestream.is_open()) {
while (std::getline(filestream, line)) {
std::replace(line.begin(), line.end(), ':', ' ');
std::istringstream linestream(line);
while (linestream >> key >> value) {
if (key == "VmRSS") { // I have used VmRSS instead of VmSize as per Udacity guideline: https://man7.org/linux/man-pages/man5/proc.5.html
mb = stoi(value);
mb=mb/1024; //kb to mb
value = to_string(mb);
return value;
}
}
}
}
return "0";
}
string LinuxParser::Uid(int pid) {
string line, key, value;
std::ifstream filestream(kProcDirectory + std::to_string(pid) +
kStatusFilename);
if (filestream.is_open()) {
while (std::getline(filestream, line)) {
std::replace(line.begin(), line.end(), ':', ' ');
std::istringstream linestream(line);
while (linestream >> key >> value) {
if (key == "Uid")
return value;
}
}
}
return 0;
}
string LinuxParser::User(int pid) {
string line;
string key, value, mb;
std::ifstream stream(kPasswordPath);
if (stream.is_open()) {
while (std::getline(stream, line)) {
std::replace(line.begin(), line.end(), ':', ' ');
std::istringstream linestream(line);
while (linestream >> value >> key>> mb) {
if (mb == LinuxParser::Uid(pid))
return value;
}
}
}
return 0;
}
// Read and return the uptime of a process
long int LinuxParser::UpTime(int PID)
{
string line, value;
vector<string> tem;
long mb;
std::ifstream stream(kProcDirectory + to_string(PID) + kStatFilename);
if (stream.is_open()) {
std::getline(stream, line);
std::stringstream linestream(line);
while (linestream >> value)
{
tem.push_back(value);
}
mb = stol(tem[21]);
}
return UpTime() - mb/sysconf(_SC_CLK_TCK);
} |
section .data
msg db "Hello world!",10
section .text
global _start
_start:
mov rax, 1
mov rdi, 1
mov rsi, msg
mov rdx, 13
syscall
mov rax, 60
mov rdi, 0
syscall
|
; A169374: Number of reduced words of length n in Coxeter group on 25 generators S_i with relations (S_i)^2 = (S_i S_j)^31 = I.
; 1,25,600,14400,345600,8294400,199065600,4777574400,114661785600,2751882854400,66045188505600,1585084524134400,38042028579225600,913008685901414400,21912208461633945600,525893003079214694400
add $0,1
mov $3,1
lpb $0
sub $0,1
add $2,$3
div $3,$2
mul $2,24
lpe
mov $0,$2
div $0,24
|
; You may customize this and other start-up templates;
; The location of this template is c:\emu8086\inc\0_com_template.txt
org 100h
.DATA
NUM1 DB ?
NUM2 DB ?
RESULT DB ?
MSG1 DB 10,13,"ENTER FIRST NUMBER TO MULTIPLY : $"
MSG2 DB 10,13,"ENTER SECOND NUMBER TO MULTIPLY : $"
MSG3 DB 10,13,"RESULT OF MULTIPLICATION IS : $"
MSG4 DB DB 0DH,0AH,'VALUE : $'
ENDS
.CODE
START:
MOV AX,@DATA
MOV DS,AX
LEA DX,MSG1
MOV AH,9
INT 21H
MOV AH,1
INT 21H
SUB AL,30H
MOV NUM1,AL
LEA DX,MSG2
MOV AH,9
INT 21H
MOV AH,1
INT 21H
SUB AL,30H
MOV NUM2,AL
MUL NUM1
MOV RESULT,AL
AAM
ADD AH,30H
ADD AL,30H
MOV BX,AX
LEA DX,MSG3
MOV AH,9
INT 21H
MOV AH,2
MOV DL,BH
INT 21H
MOV AH,2
MOV DL,BL
INT 21H
MOV AH,4CH
INT 21H
ENDS
GREATER:
CMP AH,16
JLE LESS
JGE MORE
MORE: MOV MSG4,1
LESS: MOV MSG4,0
END START
ret
|
; A304605: a(n) = 48*2^n + 26 (n>=1).
; 122,218,410,794,1562,3098,6170,12314,24602,49178,98330,196634,393242,786458,1572890,3145754,6291482,12582938,25165850,50331674,100663322,201326618,402653210,805306394,1610612762,3221225498,6442450970,12884901914,25769803802,51539607578,103079215130,206158430234,412316860442,824633720858,1649267441690,3298534883354,6597069766682,13194139533338,26388279066650,52776558133274,105553116266522,211106232533018,422212465066010,844424930131994,1688849860263962,3377699720527898,6755399441055770
mov $1,2
pow $1,$0
sub $1,1
mul $1,96
add $1,122
mov $0,$1
|
%ifdef CONFIG
{
"RegData": {
"RAX": "0x4142434445464748",
"RDX": "0x0",
"RDI": "0xE0000018",
"RSI": "0xE0000008"
},
"MemoryRegions": {
"0x100000000": "4096"
}
}
%endif
mov rdx, 0xe0000000
mov rax, 0x4142434445464748
mov [rdx + 8 * 0], rax
mov rax, 0x5152535455565758
mov [rdx + 8 * 1], rax
mov rax, 0x0
mov [rdx + 8 * 2], rax
mov [rdx + 8 * 3], rax
lea rdi, [rdx + 8 * 2]
lea rsi, [rdx + 8 * 0]
cld
mov rcx, 4
rep movsw ; rdi <- rsi
mov rax, [rdx + 8 * 2]
mov rdx, [rdx + 8 * 3]
hlt
|
#include "widgets/dialogs/ColorPickerDialog.hpp"
#include "providers/colors/ColorProvider.hpp"
#include "singletons/Theme.hpp"
namespace chatterino {
ColorPickerDialog::ColorPickerDialog(const QColor &initial, QWidget *parent)
: BasePopup(BaseWindow::EnableCustomFrame, parent)
, color_()
, dialogConfirmed_(false)
{
// This hosts the "business logic" and the dialog button box
LayoutCreator<QWidget> layoutWidget(this->getLayoutContainer());
auto layout = layoutWidget.setLayoutType<QVBoxLayout>().withoutMargin();
// This hosts the business logic: color picker and predefined colors
LayoutCreator<QWidget> contentCreator(new QWidget());
auto contents = contentCreator.setLayoutType<QHBoxLayout>();
// This hosts the predefined colors (and also the currently selected color)
LayoutCreator<QWidget> predefCreator(new QWidget());
auto predef = predefCreator.setLayoutType<QVBoxLayout>();
// Recently used colors
{
LayoutCreator<QWidget> gridCreator(new QWidget());
this->initRecentColors(gridCreator);
predef.append(gridCreator.getElement());
}
// Default colors
{
LayoutCreator<QWidget> gridCreator(new QWidget());
this->initDefaultColors(gridCreator);
predef.append(gridCreator.getElement());
}
// Currently selected color
{
LayoutCreator<QWidget> curColorCreator(new QWidget());
auto curColor = curColorCreator.setLayoutType<QHBoxLayout>();
curColor.emplace<QLabel>("Selected:").assign(&this->ui_.selected.label);
curColor.emplace<ColorButton>(initial).assign(
&this->ui_.selected.color);
predef.append(curColor.getElement());
}
contents.append(predef.getElement());
// Color picker
{
LayoutCreator<QWidget> obj(new QWidget());
auto vbox = obj.setLayoutType<QVBoxLayout>();
// The actual color picker
{
LayoutCreator<QWidget> cpCreator(new QWidget());
this->initColorPicker(cpCreator);
vbox.append(cpCreator.getElement());
}
// Spin boxes
{
LayoutCreator<QWidget> sbCreator(new QWidget());
this->initSpinBoxes(sbCreator);
vbox.append(sbCreator.getElement());
}
// HTML color
{
LayoutCreator<QWidget> htmlCreator(new QWidget());
this->initHtmlColor(htmlCreator);
vbox.append(htmlCreator.getElement());
}
contents.append(obj.getElement());
}
layout.append(contents.getElement());
// Dialog buttons
auto buttons =
layout.emplace<QHBoxLayout>().emplace<QDialogButtonBox>(this);
{
auto *button_ok = buttons->addButton(QDialogButtonBox::Ok);
QObject::connect(button_ok, &QPushButton::clicked,
[=](bool) { this->ok(); });
auto *button_cancel = buttons->addButton(QDialogButtonBox::Cancel);
QObject::connect(button_cancel, &QAbstractButton::clicked,
[=](bool) { this->close(); });
}
this->themeChangedEvent();
this->selectColor(initial, false);
}
ColorPickerDialog::~ColorPickerDialog()
{
if (this->htmlColorValidator_)
{
this->htmlColorValidator_->deleteLater();
this->htmlColorValidator_ = nullptr;
}
}
QColor ColorPickerDialog::selectedColor() const
{
if (!this->dialogConfirmed_)
{
// If the Cancel button was clicked, return the invalid color
return QColor();
}
return this->color_;
}
void ColorPickerDialog::closeEvent(QCloseEvent *)
{
this->closed.invoke();
}
void ColorPickerDialog::themeChangedEvent()
{
BaseWindow::themeChangedEvent();
QString textCol = this->theme->splits.input.text.name(QColor::HexRgb);
QString bgCol = this->theme->splits.input.background.name(QColor::HexRgb);
// Labels
QString labelStyle = QString("color: %1;").arg(textCol);
this->ui_.recent.label->setStyleSheet(labelStyle);
this->ui_.def.label->setStyleSheet(labelStyle);
this->ui_.selected.label->setStyleSheet(labelStyle);
this->ui_.picker.htmlLabel->setStyleSheet(labelStyle);
for (auto spinBoxLabel : this->ui_.picker.spinBoxLabels)
{
spinBoxLabel->setStyleSheet(labelStyle);
}
this->ui_.picker.htmlEdit->setStyleSheet(
this->theme->splits.input.styleSheet);
// Styling spin boxes is too much effort
}
void ColorPickerDialog::selectColor(const QColor &color, bool fromColorPicker)
{
if (color == this->color_)
return;
this->color_ = color;
// Update UI elements
this->ui_.selected.color->setColor(this->color_);
/*
* Somewhat "ugly" hack to prevent feedback loop between widgets. Since
* this method is private, I'm okay with this being ugly.
*/
if (!fromColorPicker)
{
this->ui_.picker.colorPicker->setCol(this->color_.hslHue(),
this->color_.hslSaturation());
this->ui_.picker.luminancePicker->setCol(this->color_.hsvHue(),
this->color_.hsvSaturation(),
this->color_.value());
}
this->ui_.picker.spinBoxes[SpinBox::RED]->setValue(this->color_.red());
this->ui_.picker.spinBoxes[SpinBox::GREEN]->setValue(this->color_.green());
this->ui_.picker.spinBoxes[SpinBox::BLUE]->setValue(this->color_.blue());
this->ui_.picker.spinBoxes[SpinBox::ALPHA]->setValue(this->color_.alpha());
/*
* Here, we are intentionally using HexRgb instead of HexArgb. Most online
* sites (or other applications) will likely not include the alpha channel
* in their output.
*/
this->ui_.picker.htmlEdit->setText(this->color_.name(QColor::HexRgb));
}
void ColorPickerDialog::ok()
{
this->dialogConfirmed_ = true;
this->close();
}
void ColorPickerDialog::initRecentColors(LayoutCreator<QWidget> &creator)
{
auto grid = creator.setLayoutType<QGridLayout>();
auto label = this->ui_.recent.label = new QLabel("Recently used:");
grid->addWidget(label, 0, 0, 1, -1);
const auto recentColors = ColorProvider::instance().recentColors();
auto it = recentColors.begin();
size_t ind = 0;
while (it != recentColors.end() && ind < MAX_RECENT_COLORS)
{
this->ui_.recent.colors.push_back(new ColorButton(*it, this));
auto *button = this->ui_.recent.colors[ind];
static_assert(RECENT_COLORS_PER_ROW != 0);
const int rowInd = (ind / RECENT_COLORS_PER_ROW) + 1;
const int columnInd = ind % RECENT_COLORS_PER_ROW;
grid->addWidget(button, rowInd, columnInd);
QObject::connect(button, &QPushButton::clicked,
[=] { this->selectColor(button->color(), false); });
++it;
++ind;
}
auto spacer =
new QSpacerItem(40, 20, QSizePolicy::Minimum, QSizePolicy::Expanding);
grid->addItem(spacer, (ind / RECENT_COLORS_PER_ROW) + 2, 0, 1, 1,
Qt::AlignTop);
}
void ColorPickerDialog::initDefaultColors(LayoutCreator<QWidget> &creator)
{
auto grid = creator.setLayoutType<QGridLayout>();
auto label = this->ui_.def.label = new QLabel("Default colors:");
grid->addWidget(label, 0, 0, 1, -1);
const auto defaultColors = ColorProvider::instance().defaultColors();
auto it = defaultColors.begin();
size_t ind = 0;
while (it != defaultColors.end())
{
this->ui_.def.colors.push_back(new ColorButton(*it, this));
auto *button = this->ui_.def.colors[ind];
const int rowInd = (ind / DEFAULT_COLORS_PER_ROW) + 1;
const int columnInd = ind % DEFAULT_COLORS_PER_ROW;
grid->addWidget(button, rowInd, columnInd);
QObject::connect(button, &QPushButton::clicked,
[=] { this->selectColor(button->color(), false); });
++it;
++ind;
}
auto spacer =
new QSpacerItem(40, 20, QSizePolicy::Minimum, QSizePolicy::Expanding);
grid->addItem(spacer, (ind / DEFAULT_COLORS_PER_ROW) + 2, 0, 1, 1,
Qt::AlignTop);
}
void ColorPickerDialog::initColorPicker(LayoutCreator<QWidget> &creator)
{
auto cpPanel = creator.setLayoutType<QHBoxLayout>();
/*
* For some reason, LayoutCreator::emplace didn't work for these.
* (Or maybe I was too dense to make it work.)
* After trying to debug for 4 hours or so, I gave up and settled
* for this solution.
*/
auto *colorPicker = new QColorPicker(this);
this->ui_.picker.colorPicker = colorPicker;
auto *luminancePicker = new QColorLuminancePicker(this);
this->ui_.picker.luminancePicker = luminancePicker;
cpPanel.append(colorPicker);
cpPanel.append(luminancePicker);
QObject::connect(colorPicker, SIGNAL(newCol(int, int)), luminancePicker,
SLOT(setCol(int, int)));
QObject::connect(
luminancePicker, &QColorLuminancePicker::newHsv,
[=](int h, int s, int v) {
int alpha = this->ui_.picker.spinBoxes[SpinBox::ALPHA]->value();
this->selectColor(QColor::fromHsv(h, s, v, alpha), true);
});
}
void ColorPickerDialog::initSpinBoxes(LayoutCreator<QWidget> &creator)
{
auto spinBoxes = creator.setLayoutType<QGridLayout>();
auto *red = this->ui_.picker.spinBoxes[SpinBox::RED] =
new QColSpinBox(this);
auto *green = this->ui_.picker.spinBoxes[SpinBox::GREEN] =
new QColSpinBox(this);
auto *blue = this->ui_.picker.spinBoxes[SpinBox::BLUE] =
new QColSpinBox(this);
auto *alpha = this->ui_.picker.spinBoxes[SpinBox::ALPHA] =
new QColSpinBox(this);
// We need pointers to these for theme changes
auto *redLbl = this->ui_.picker.spinBoxLabels[SpinBox::RED] =
new QLabel("Red:");
auto *greenLbl = this->ui_.picker.spinBoxLabels[SpinBox::GREEN] =
new QLabel("Green:");
auto *blueLbl = this->ui_.picker.spinBoxLabels[SpinBox::BLUE] =
new QLabel("Blue:");
auto *alphaLbl = this->ui_.picker.spinBoxLabels[SpinBox::ALPHA] =
new QLabel("Alpha:");
spinBoxes->addWidget(redLbl, 0, 0);
spinBoxes->addWidget(red, 0, 1);
spinBoxes->addWidget(greenLbl, 1, 0);
spinBoxes->addWidget(green, 1, 1);
spinBoxes->addWidget(blueLbl, 2, 0);
spinBoxes->addWidget(blue, 2, 1);
spinBoxes->addWidget(alphaLbl, 3, 0);
spinBoxes->addWidget(alpha, 3, 1);
for (size_t i = 0; i < SpinBox::END; ++i)
{
QObject::connect(
this->ui_.picker.spinBoxes[i],
QOverload<int>::of(&QSpinBox::valueChanged), [=](int value) {
this->selectColor(QColor(red->value(), green->value(),
blue->value(), alpha->value()),
false);
});
}
}
void ColorPickerDialog::initHtmlColor(LayoutCreator<QWidget> &creator)
{
auto html = creator.setLayoutType<QGridLayout>();
// Copied from Qt source for QColorShower
static QRegularExpression regExp(
QStringLiteral("#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})"));
auto *validator = this->htmlColorValidator_ =
new QRegularExpressionValidator(regExp, this);
auto *htmlLabel = this->ui_.picker.htmlLabel = new QLabel("HTML:");
auto *htmlEdit = this->ui_.picker.htmlEdit = new QLineEdit(this);
htmlEdit->setValidator(validator);
html->addWidget(htmlLabel, 0, 0);
html->addWidget(htmlEdit, 0, 1);
QObject::connect(htmlEdit, &QLineEdit::textEdited,
[=](const QString &text) {
QColor col(text);
if (col.isValid())
this->selectColor(col, false);
});
}
} // namespace chatterino
|
/* $Id: UIDnDMIMEData.cpp 69500 2017-10-28 15:14:05Z vboxsync $ */
/** @file
* VBox Qt GUI - UIDnDMIMEData class implementation.
*/
/*
* Copyright (C) 2011-2017 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#ifdef VBOX_WITH_PRECOMPILED_HEADERS
# include <precomp.h>
#else /* !VBOX_WITH_PRECOMPILED_HEADERS */
/* Qt includes: */
# include <QFileInfo>
# include <QMimeData>
# include <QStringList>
# include <QUrl>
/* GUI includes: */
# include "UIDnDMIMEData.h"
#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
#undef LOG_GROUP
#define LOG_GROUP LOG_GROUP_GUEST_DND
#include <VBox/log.h>
UIDnDMIMEData::UIDnDMIMEData(UIDnDHandler *pDnDHandler,
QStringList lstFormats, Qt::DropAction defAction, Qt::DropActions actions)
: m_pDnDHandler(pDnDHandler)
, m_lstFormats(lstFormats)
, m_defAction(defAction)
, m_curAction(Qt::IgnoreAction)
, m_actions(actions)
, m_enmState(Dragging)
{
LogFlowThisFuncEnter();
#ifdef DEBUG
LogFlowFunc(("Number of formats: %d\n", m_lstFormats.size()));
for (int i = 0; i < m_lstFormats.size(); i++)
LogFlowFunc(("\tFormat %d: %s\n", i, m_lstFormats.at(i).toUtf8().constData()));
#endif
}
QStringList UIDnDMIMEData::formats(void) const
{
LogFlowFuncEnter();
#ifdef DEBUG
for (int i = 0; i < m_lstFormats.size(); i++)
LogFlowFunc(("\tFormat %d: %s\n", i, m_lstFormats.at(i).toUtf8().constData()));
#endif
return m_lstFormats;
}
bool UIDnDMIMEData::hasFormat(const QString &strMIMEType) const
{
RT_NOREF(strMIMEType);
bool fRc;
#ifdef RT_OS_DARWIN
fRc = m_lstFormats.contains(strMIMEType);
#else
fRc = m_curAction != Qt::IgnoreAction;
#endif
LogFlowFunc(("%s: %RTbool (QtMimeData: %RTbool, curAction=0x%x)\n",
strMIMEType.toStdString().c_str(), fRc, QMimeData::hasFormat(strMIMEType), m_curAction));
return fRc;
}
/**
* Called by Qt's drag'n drop operation (QDrag) for retrieving the actual drag'n drop
* data in case of a successful drag'n drop operation.
*
* @param strMIMEType MIME type string.
* @param vaType Variant containing the actual data based on the MIME type.
*
* @return QVariant
*/
QVariant UIDnDMIMEData::retrieveData(const QString &strMIMEType, QVariant::Type vaType) const
{
LogFlowFunc(("state=%RU32, curAction=0x%x, defAction=0x%x, mimeType=%s, type=%d (%s)\n",
m_enmState, m_curAction, m_defAction, strMIMEType.toStdString().c_str(), vaType, QVariant::typeToName(vaType)));
int rc = VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
/*
* On Windows this function will be called several times by Qt's
* OLE-specific internals to figure out which data formats we have
* to offer. So just assume we can drop data here for a start.
*/
#elif defined(RT_OS_DARWIN)
# ifndef VBOX_WITH_DRAG_AND_DROP_PROMISES
/*
* Without VBOX_WITH_DRAG_AND_DROP_PROMISES being set in VBox *and* in our (patched) Qt
* libraries there's no reliable way to get this working on OS X. So just deny any dropping.
*/
rc = VERR_NOT_IMPLEMENTED;
/* Let the user know. */
LogRel(("DnD: Drag and drop support for OS X is not available in this version\n"));
# endif /* VBOX_WITH_DRAG_AND_DROP_PROMISES */
#else /* !RT_OS_DARWIN */
/*
* On Linux/Solaris our state gets updated if the drop target has been
* changed. So query the current status if we're at the moment are able
* to drop something on the current target.
*/
if (m_curAction == Qt::IgnoreAction)
{
LogFlowFunc(("Current drop action is 0x%x, so can't drop yet\n", m_curAction));
rc = VERR_NOT_FOUND;
}
#endif
if (RT_SUCCESS(rc))
{
/* Silently ignore internal Qt types / converters. */
if (!strMIMEType.compare("application/x-qt-mime-type-name", Qt::CaseInsensitive))
{
rc = VERR_NOT_FOUND;
}
/* Do we support the requested MIME type? */
else if (!m_lstFormats.contains(strMIMEType))
{
LogRel(("DnD: Unsupported MIME type '%s'\n", strMIMEType.toStdString().c_str()));
rc = VERR_NOT_SUPPORTED;
}
#ifndef RT_OS_DARWIN /* On OS X QVariant::Invalid can happen for drag and drop "promises" for "lazy requests". */
/* Check supported variant types. */
else if (!(
/* Plain text. */
vaType == QVariant::String
/* Binary data. */
|| vaType == QVariant::ByteArray
/* URI list. */
|| vaType == QVariant::List
|| vaType == QVariant::StringList))
{
LogRel(("DnD: Unsupported data type '%s'\n", QVariant::typeToName(vaType)));
rc = VERR_NOT_SUPPORTED;
}
#endif
}
LogRel3(("DnD: Retrieved data state is %ld (action=0x%x), rc=%Rrc\n", m_enmState, m_curAction, rc));
if (RT_SUCCESS(rc))
{
QVariant vaData;
rc = emit sigGetData(Qt::CopyAction, strMIMEType, vaType, vaData);
if (RT_SUCCESS(rc))
{
LogRel3(("DnD: Returning data for MIME type=%s, variant type=%s, rc=%Rrc\n",
strMIMEType.toStdString().c_str(), QVariant::typeToName(vaData.type()), rc));
return vaData;
}
}
else if (rc == VERR_NOT_FOUND) /* Silently skip internal entries. */
rc = VINF_SUCCESS;
if (RT_FAILURE(rc))
LogRel2(("DnD: Retrieving data failed with %Rrc\n", rc));
return QVariant(QVariant::Invalid);
}
/* static */
QVariant::Type UIDnDMIMEData::getVariantType(const QString &strMIMEType)
{
QVariant::Type vaType;
if ( !strMIMEType.compare("text/html")
|| !strMIMEType.compare("text/plain;charset=utf-8")
|| !strMIMEType.compare("text/plain;charset=utf-16")
|| !strMIMEType.compare("text/plain")
|| !strMIMEType.compare("text/richtext")
|| !strMIMEType.compare("UTF8_STRING")
|| !strMIMEType.compare("TEXT")
|| !strMIMEType.compare("STRING"))
{
vaType = QVariant::String;
}
else if (!strMIMEType.compare("text/uri-list", Qt::CaseInsensitive))
vaType = QVariant::List;
else
vaType = QVariant::Invalid;
LogFlowFunc(("strMIMEType=%s -> vaType=%s\n", qPrintable(strMIMEType), QVariant::typeToName(vaType)));
return vaType;
}
/* static */
int UIDnDMIMEData::getDataAsVariant(const QVector<uint8_t> &vecData,
const QString &strMIMEType,
QVariant::Type vaType,
QVariant &vaData)
{
RT_NOREF(strMIMEType);
LogFlowFunc(("vecDataSize=%d, strMIMEType=%s vaType=%s\n",
vecData.size(), qPrintable(strMIMEType), QVariant::typeToName(vaType)));
int rc = VINF_SUCCESS;
switch (vaType)
{
case QVariant::String:
{
vaData = QVariant::fromValue(QString(reinterpret_cast<const char *>(vecData.constData())));
Assert(vaData.type() == QVariant::String);
break;
}
case QVariant::ByteArray:
{
QByteArray ba(reinterpret_cast<const char*>(vecData.constData()), vecData.size());
vaData = QVariant::fromValue(ba);
Assert(vaData.type() == QVariant::ByteArray);
break;
}
/* See: https://developer.apple.com/library/ios/documentation/Miscellaneous/Reference/UTIRef/Articles/System-DeclaredUniformTypeIdentifiers.html */
case QVariant::List: /* Used on OS X for representing URI lists. */
{
QString strData = QString(reinterpret_cast<const char*>(vecData.constData()));
QStringList lstString = strData.split("\r\n", QString::SkipEmptyParts);
QVariantList lstVariant;
Q_FOREACH(const QString& strCur, lstString)
{
QVariant vaURL = QVariant::fromValue(QUrl(strCur));
Assert(vaURL.type() == QVariant::Url);
lstVariant.append(vaURL);
}
vaData = QVariant::fromValue(lstVariant);
Assert(vaData.type() == QVariant::List);
break;
}
case QVariant::StringList:
{
QString strData = QString(reinterpret_cast<const char*>(vecData.constData()));
QStringList lstString = strData.split("\r\n", QString::SkipEmptyParts);
LogFlowFunc(("\tStringList has %d entries\n", lstString.size()));
# ifdef DEBUG
Q_FOREACH(const QString& strCur, lstString)
LogFlowFunc(("\t\tString: %s\n", qPrintable(strCur)));
# endif
vaData = QVariant::fromValue(lstString);
Assert(vaData.type() == QVariant::StringList);
break;
}
default:
{
LogRel2(("DnD: Converting data (%d bytes) from guest to variant type '%s' not supported\n",
vecData.size(), QVariant::typeToName(vaType) ? QVariant::typeToName(vaType) : "<Invalid>"));
rc = VERR_NOT_SUPPORTED;
break;
}
}
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* Issued by the QDrag object as soon as the current drop action has changed.
*
* @param dropAction New drop action to use.
*/
void UIDnDMIMEData::sltDropActionChanged(Qt::DropAction dropAction)
{
LogFlowFunc(("dropAction=0x%x\n", dropAction));
m_curAction = dropAction;
}
|
/**
* Copyright (c) 2017-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "logdevice/admin/settings/AdminServerSettings.h"
#include "logdevice/common/commandline_util_chrono.h"
#include "logdevice/common/settings/Validators.h"
using namespace facebook::logdevice::setting_validators;
namespace facebook { namespace logdevice {
void AdminServerSettings::defineSettings(SettingEasyInit& init) {
using namespace SettingFlag;
// clang-format off
init
("admin-port", &admin_port, "6440", validate_port,
"TCP port on which the server listens to for admin commands, supports "
"commands over SSL",
SERVER | REQUIRES_RESTART,
SettingsCategory::AdminAPI)
("admin-unix-socket", &admin_unix_socket, "", validate_unix_socket,
"Path to the unix domain socket the server will use to listen for admin "
"thrift interface",
SERVER | REQUIRES_RESTART,
SettingsCategory::AdminAPI)
("safety-check-max-logs-in-flight", &safety_max_logs_in_flight, "1000",
[](int x) -> void {
if (x <= 0) {
throw boost::program_options::error(
"safety-check-max-logs-in-flight must be a positive integer"
);
}
},
"The number of concurrent logs that we runs checks against during execution"
" of the CheckImpact operation either internally during a maintenance or "
"through the Admin API's checkImpact() call",
SERVER,
SettingsCategory::AdminAPI)
("safety-check-failure-sample-size", &safety_check_failure_sample_size, "10",
[](int x) -> void {
if (x <= 0) {
throw boost::program_options::error(
"safety-check-failure-sample-size must be a positive integer"
);
}
},
"The number of sample epochs returned by the Maintenance API for each "
"maintenance if safety check blocks the operation.",
SERVER,
SettingsCategory::AdminAPI)
("safety-check-max-batch-size", &safety_check_max_batch_size, "15000",
[](int x) -> void {
if (x <= 0) {
throw boost::program_options::error(
"safety-check-max-batch-size must be a positive integer"
);
}
},
"The maximum number of logs to be checked in a single batch. Larger "
"batches mean faster performance but means blocking the CPU thread pool "
"for longer (not yielding often enough)",
SERVER,
SettingsCategory::AdminAPI)
("max-unavailable-storage-capacity-pct",
&max_unavailable_storage_capacity_pct,
"25",
[](int x) -> void {
if (x < 0 || x > 100) {
throw boost::program_options::error(
"max-unavailable-storage-capacity-pct must be a valid "
"percentage, between 0 and 100."
);
}
},
"The percentage of the storage that is allowed to be taken down by "
"operations, safety checker will take into account DEAD nodes as well. "
"This means that if this value is 25, then safety checker will deny "
"maintenances that will may take down more storage nodes. The percentage "
"takes into account the weight of shards in the storage nodes, so does "
"not necessarily equals 25% of the number of storage nodes",
SERVER,
SettingsCategory::AdminAPI)
("max-unavailable-sequencing-capacity-pct",
&max_unavailable_sequencing_capacity_pct,
"25",
[](int x) -> void {
if (x < 0 || x > 100) {
throw boost::program_options::error(
"max-unavailable-sequencing-capacity-pct must be a valid "
"percentage, between 0 and 100."
);
}
},
"The percentage of the sequencing capacity that is allowed to be taken "
"down by operations, safety checker will take into account DEAD nodes as "
"well. This means that if this value is 25, then safety checker will deny "
"maintenances that will may take down more sequencer nodes. The percentage "
"takes into account the weight of the sequencer nodes, so does not "
"necessarily equals 25% of the number of sequencer nodes",
SERVER,
SettingsCategory::AdminAPI)
("enable-cluster-maintenance-state-machine",
&enable_cluster_maintenance_state_machine,
"false",
nullptr,
"Enables the internal state replicated state machine that holds the "
"maintenance definitions requested by the rebuilding supervisor or via the "
" admin API. Enabling the state machine will also enable posting internal "
"maintenance requests instead of writing to event log directly",
SERVER | REQUIRES_RESTART,
SettingsCategory::AdminAPI)
("maintenance-log-snapshotting",
&maintenance_log_snapshotting,
"false",
nullptr,
"Allow the maintenance log to be snapshotted onto a snapshot log. This "
"requires the maintenance log group to contain two logs, the first one "
"being the snapshot log and the second one being the delta log.",
SERVER,
SettingsCategory::AdminAPI)
("maintenance-log-snapshotting-period",
&maintenance_log_snapshotting_period,
"1h",
validate_positive<ssize_t>(),
"Controls time based snapshotting. New maintenancelog snapshot will be "
"created after this period if there are new deltas",
SERVER,
SettingsCategory::AdminAPI)
("maintenance-log-max-delta-records",
&maintenance_log_max_delta_records,
"5000",
nullptr,
"How many delta records to keep in the maintenance log before we "
"snapshot it.",
SERVER,
SettingsCategory::AdminAPI)
("maintenance-log-max-delta-bytes",
&maintenance_log_max_delta_bytes,
"10485760", // 10MB
parse_nonnegative<ssize_t>(),
"How many bytes of deltas to keep in the maintenance log before "
"we snapshot it.",
SERVER,
SettingsCategory::AdminAPI)
("disable-maintenance-log-trimming",
&disable_maintenance_log_trimming,
"false",
nullptr,
"Disable trimming of the maintenance log",
SERVER,
SettingsCategory::AdminAPI)
("read-metadata-from-sequencers", &read_metadata_from_sequencers, "true",
nullptr,
"Safety checker to read the metadata of logs directly from sequencers.",
SERVER,
SettingsCategory::AdminAPI)
("enable-maintenance-manager",
&enable_maintenance_manager,
"false",
nullptr,
"Start Maintenance Manager. This will automatically enable the maintenance "
"state machine as well (--enable-cluster-maintenance-state-machine).",
SERVER | REQUIRES_RESTART,
SettingsCategory::AdminAPI)
("maintenance-manager-reevaluation-timeout",
&maintenance_manager_reevaluation_timeout,
"2min",
[](std::chrono::milliseconds val) -> void {
if (val.count() <= 0) {
throw boost::program_options::error(
"maintenance-manager-reevaluation-timeout must be positive"
);
}
},
"Timeout after which a new run is scheduled in MaintenanceManager. Used for "
"periodic reevaluation of the state in the absence of any state changes",
SERVER,
SettingsCategory::AdminAPI)
("maintenance-manager-metadata-nodeset-update-period",
&maintenance_manager_metadata_nodeset_update_period,
"2min",
[](std::chrono::milliseconds val) -> void {
if (val.count() <= 0) {
throw boost::program_options::error(
"maintenance-manager-metadata-nodeset-update-period must be positive"
);
}
},
"The period of how often to check if metadata nodeset update is required",
SERVER,
SettingsCategory::AdminAPI)
("enable-safety-check-periodic-metadata-update",
&enable_safety_check_periodic_metadata_update,
"false",
nullptr,
"Safety check to update its metadata cache periodically",
SERVER,
SettingsCategory::AdminAPI)
("safety-check-metadata-update-period",
&safety_check_metadata_update_period,
"10min",
[](std::chrono::milliseconds val) -> void {
if (val.count() <= 0) {
throw boost::program_options::error(
"safety-check-metadata-update-period must be positive"
);
}
},
"The period between automatic metadata updates for safety checker internal "
"cache",
SERVER,
SettingsCategory::AdminAPI)
("block-maintenance-rsm",
&block_maintenance_rsm,
"false",
nullptr,
"If true, the Maintenance replicated state machine will not publish any "
"state updates. This simulates the case where we cannot finish loading "
"the state on startup. Changing the value will cause the RSM to publish "
"the state immediately if it can.",
SERVER,
SettingsCategory::Testing)
("safety-margin-medium-pri-scopes" ,
&safety_margin_medium_pri_scopes,
"0",
parse_nonnegative<ssize_t>(),
"This is the extra safety margin that will be accounted for when evaluating"
"maintenances with MEDIUM priority. The value represents how many extra "
"failure domains that the system can still lose in addition to the impact "
"of the requested maintenance before losing availability",
SERVER,
SettingsCategory::AdminAPI)
("safety-margin-low-pri-scopes" ,
&safety_margin_low_pri_scopes,
"1",
parse_nonnegative<ssize_t>(),
"This is the extra safety margin that will be accounted for when evaluating"
"maintenances with LOW priority. The value represents how many extra "
"failure domains that the system can still lose in addition to the impact "
"of the requested maintenance before losing availability",
SERVER,
SettingsCategory::AdminAPI)
;
// clang-format on
};
}} // namespace facebook::logdevice
|
global _start
section .data
msg db 'The Sum is: '
msgLen equ $ - msg
num1 db '12345' ; ASCII number1
num2 db '23456' ; ASCII number2
sum db ' ' ; To store result with 5 space
section .text
_start:
mov ecx, 5 ; Loop 5 times
mov esi, 4 ; Pointing to the right most digit, shift 4
clc ; Clean carry flag
add_loop:
mov al, [num1 + esi] ; Move the right most number1(Not calculate) to al
adc al, [num2 + esi] ; Add the right most nmuber2(Not calculate) with al, and with carry
aaa ; ASCII Adjust After Add
pushf ; Push flag to stack to protect flag
or al, 30H ; Convert number to ASCII
popf ; Restore flag
mov [sum + esi], al ; Store al to sum in the associate position
dec esi ; Calculate next position in the next loop
loop add_loop ; Loop 5 times
; Print msg
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, msgLen
int 0x80
; Print sum
mov eax, 4
mov ebx, 1
mov ecx, sum
mov edx, 5
int 0x80
; Exit
mov eax, 1
mov ebx, 0
int 0x80
|
lui $1,11300
ori $1,$1,42846
lui $2,5464
ori $2,$2,3696
lui $3,58166
ori $3,$3,23012
lui $4,35539
ori $4,$4,5233
lui $5,6923
ori $5,$5,35366
lui $6,11700
ori $6,$6,9508
mthi $1
mtlo $2
sec0:
nop
nop
nop
and $5,$6,$6
sec1:
nop
nop
nor $6,$3,$5
and $1,$6,$6
sec2:
nop
nop
slti $6,$3,-31666
and $0,$6,$6
sec3:
nop
nop
mfhi $6
and $0,$6,$6
sec4:
nop
nop
lh $6,8($0)
and $3,$6,$6
sec5:
nop
slt $6,$3,$3
nop
and $6,$6,$6
sec6:
nop
sltu $6,$1,$3
addu $6,$2,$4
and $1,$6,$6
sec7:
nop
addu $6,$5,$3
addiu $6,$2,-29787
and $4,$6,$6
sec8:
nop
and $6,$3,$6
mfhi $6
and $3,$6,$6
sec9:
nop
and $6,$0,$3
lh $6,16($0)
and $5,$6,$6
sec10:
nop
xori $6,$4,23752
nop
and $4,$6,$6
sec11:
nop
slti $6,$2,12266
subu $6,$4,$3
and $0,$6,$6
sec12:
nop
ori $6,$5,1746
addiu $6,$2,-5600
and $1,$6,$6
sec13:
nop
lui $6,51233
mflo $6
and $3,$6,$6
sec14:
nop
addiu $6,$2,-12942
lb $6,8($0)
and $1,$6,$6
sec15:
nop
mflo $6
nop
and $3,$6,$6
sec16:
nop
mfhi $6
subu $6,$2,$3
and $4,$6,$6
sec17:
nop
mfhi $6
xori $6,$5,50860
and $2,$6,$6
sec18:
nop
mflo $6
mflo $6
and $1,$6,$6
sec19:
nop
mfhi $6
lw $6,8($0)
and $1,$6,$6
sec20:
nop
lhu $6,10($0)
nop
and $5,$6,$6
sec21:
nop
lb $6,13($0)
nor $6,$5,$2
and $2,$6,$6
sec22:
nop
lw $6,0($0)
xori $6,$4,12915
and $5,$6,$6
sec23:
nop
lhu $6,0($0)
mflo $6
and $2,$6,$6
sec24:
nop
lb $6,15($0)
lb $6,16($0)
and $1,$6,$6
sec25:
or $6,$5,$6
nop
nop
and $5,$6,$6
sec26:
slt $6,$5,$3
nop
and $6,$4,$3
and $4,$6,$6
sec27:
and $6,$2,$6
nop
ori $6,$3,8251
and $1,$6,$6
sec28:
and $6,$5,$3
nop
mfhi $6
and $3,$6,$6
sec29:
sltu $6,$3,$2
nop
lb $6,3($0)
and $3,$6,$6
sec30:
and $6,$1,$4
and $6,$4,$6
nop
and $4,$6,$6
sec31:
xor $6,$2,$4
sltu $6,$4,$5
sltu $6,$3,$5
and $2,$6,$6
sec32:
subu $6,$3,$4
subu $6,$4,$2
addiu $6,$2,-20919
and $4,$6,$6
sec33:
sltu $6,$3,$1
or $6,$3,$1
mfhi $6
and $6,$6,$6
sec34:
sltu $6,$3,$2
addu $6,$4,$3
lw $6,8($0)
and $3,$6,$6
sec35:
nor $6,$2,$1
slti $6,$3,4558
nop
and $4,$6,$6
sec36:
or $6,$5,$2
andi $6,$2,59267
sltu $6,$1,$4
and $0,$6,$6
sec37:
slt $6,$4,$2
sltiu $6,$4,21514
andi $6,$6,22086
and $2,$6,$6
sec38:
and $6,$3,$5
xori $6,$0,48191
mfhi $6
and $3,$6,$6
sec39:
addu $6,$3,$4
andi $6,$4,8720
lh $6,14($0)
and $4,$6,$6
sec40:
addu $6,$3,$2
mflo $6
nop
and $5,$6,$6
sec41:
or $6,$5,$2
mfhi $6
sltu $6,$0,$3
and $0,$6,$6
sec42:
subu $6,$4,$2
mfhi $6
andi $6,$2,12183
and $6,$6,$6
sec43:
xor $6,$3,$4
mflo $6
mfhi $6
and $3,$6,$6
sec44:
xor $6,$2,$2
mflo $6
lh $6,0($0)
and $3,$6,$6
sec45:
xor $6,$4,$5
lb $6,13($0)
nop
and $1,$6,$6
sec46:
subu $6,$4,$2
lw $6,0($0)
subu $6,$3,$5
and $6,$6,$6
sec47:
nor $6,$6,$3
lw $6,0($0)
lui $6,27153
and $4,$6,$6
sec48:
nor $6,$4,$3
lb $6,0($0)
mfhi $6
and $6,$6,$6
sec49:
subu $6,$3,$5
lw $6,8($0)
lw $6,4($0)
and $3,$6,$6
sec50:
andi $6,$3,21929
nop
nop
and $3,$6,$6
sec51:
xori $6,$4,51797
nop
xor $6,$6,$2
and $2,$6,$6
sec52:
xori $6,$4,28175
nop
sltiu $6,$1,1716
and $5,$6,$6
sec53:
ori $6,$3,20932
nop
mfhi $6
and $0,$6,$6
sec54:
sltiu $6,$3,-197
nop
lh $6,8($0)
and $3,$6,$6
sec55:
andi $6,$2,27381
subu $6,$1,$2
nop
and $3,$6,$6
sec56:
lui $6,40153
xor $6,$0,$2
addu $6,$2,$1
and $2,$6,$6
sec57:
slti $6,$3,21116
and $6,$3,$2
andi $6,$1,14656
and $4,$6,$6
sec58:
lui $6,17054
addu $6,$2,$3
mfhi $6
and $5,$6,$6
sec59:
sltiu $6,$3,20605
addu $6,$3,$4
lh $6,4($0)
and $1,$6,$6
sec60:
addiu $6,$1,-26604
slti $6,$0,-2677
nop
and $4,$6,$6
sec61:
andi $6,$3,23959
slti $6,$4,-27631
and $6,$6,$1
and $4,$6,$6
sec62:
andi $6,$5,63929
xori $6,$6,38286
addiu $6,$3,-25645
and $3,$6,$6
sec63:
slti $6,$2,17844
sltiu $6,$5,29577
mfhi $6
and $6,$6,$6
sec64:
slti $6,$5,-23332
addiu $6,$1,27804
lb $6,6($0)
and $6,$6,$6
sec65:
slti $6,$4,-22128
mflo $6
nop
and $3,$6,$6
sec66:
slti $6,$4,1531
mflo $6
addu $6,$4,$4
and $6,$6,$6
sec67:
addiu $6,$1,-15118
mfhi $6
sltiu $6,$3,2123
and $3,$6,$6
sec68:
sltiu $6,$6,-24319
mfhi $6
mfhi $6
and $1,$6,$6
sec69:
slti $6,$2,31914
mflo $6
lh $6,14($0)
and $1,$6,$6
sec70:
slti $6,$4,9251
lh $6,4($0)
nop
and $3,$6,$6
sec71:
xori $6,$1,34364
lw $6,0($0)
addu $6,$5,$4
and $2,$6,$6
sec72:
andi $6,$5,31451
lb $6,6($0)
slti $6,$5,24723
and $6,$6,$6
sec73:
ori $6,$2,41772
lbu $6,10($0)
mflo $6
and $1,$6,$6
sec74:
lui $6,22654
lw $6,0($0)
lbu $6,13($0)
and $1,$6,$6
sec75:
mfhi $6
nop
nop
and $0,$6,$6
sec76:
mfhi $6
nop
or $6,$5,$1
and $5,$6,$6
sec77:
mflo $6
nop
lui $6,54079
and $1,$6,$6
sec78:
mfhi $6
nop
mfhi $6
and $4,$6,$6
sec79:
mflo $6
nop
lw $6,0($0)
and $2,$6,$6
sec80:
mfhi $6
subu $6,$3,$2
nop
and $4,$6,$6
sec81:
mflo $6
addu $6,$3,$5
and $6,$3,$1
and $6,$6,$6
sec82:
mflo $6
or $6,$6,$5
slti $6,$0,-31899
and $2,$6,$6
sec83:
mfhi $6
addu $6,$1,$4
mfhi $6
and $5,$6,$6
sec84:
mflo $6
slt $6,$3,$6
lbu $6,6($0)
and $2,$6,$6
sec85:
mflo $6
sltiu $6,$2,13582
nop
and $3,$6,$6
sec86:
mfhi $6
ori $6,$3,17469
nor $6,$0,$4
and $2,$6,$6
sec87:
mflo $6
ori $6,$3,43410
addiu $6,$3,-14360
and $4,$6,$6
sec88:
mflo $6
addiu $6,$0,32668
mfhi $6
and $3,$6,$6
sec89:
mflo $6
slti $6,$0,-18022
lb $6,13($0)
and $4,$6,$6
sec90:
mflo $6
mfhi $6
nop
and $2,$6,$6
sec91:
mflo $6
mflo $6
addu $6,$1,$5
and $6,$6,$6
sec92:
mfhi $6
mflo $6
addiu $6,$0,-13333
and $1,$6,$6
sec93:
mfhi $6
mfhi $6
mflo $6
and $0,$6,$6
sec94:
mflo $6
mfhi $6
lw $6,0($0)
and $5,$6,$6
sec95:
mflo $6
lh $6,10($0)
nop
and $3,$6,$6
sec96:
mflo $6
lb $6,6($0)
sltu $6,$5,$5
and $2,$6,$6
sec97:
mflo $6
lbu $6,9($0)
xori $6,$3,63673
and $3,$6,$6
sec98:
mfhi $6
lh $6,16($0)
mflo $6
and $5,$6,$6
sec99:
mfhi $6
lbu $6,6($0)
lhu $6,16($0)
and $5,$6,$6
sec100:
lb $6,3($0)
nop
nop
and $3,$6,$6
sec101:
lbu $6,2($0)
nop
slt $6,$2,$2
and $2,$6,$6
sec102:
lw $6,8($0)
nop
lui $6,3889
and $4,$6,$6
sec103:
lw $6,16($0)
nop
mfhi $6
and $3,$6,$6
sec104:
lhu $6,8($0)
nop
lw $6,16($0)
and $4,$6,$6
sec105:
lbu $6,6($0)
nor $6,$4,$4
nop
and $2,$6,$6
sec106:
lb $6,5($0)
slt $6,$0,$6
or $6,$3,$3
and $1,$6,$6
sec107:
lw $6,0($0)
addu $6,$4,$2
lui $6,39081
and $4,$6,$6
sec108:
lw $6,8($0)
and $6,$3,$3
mflo $6
and $4,$6,$6
sec109:
lhu $6,8($0)
slt $6,$3,$5
lb $6,16($0)
and $2,$6,$6
sec110:
lh $6,16($0)
andi $6,$4,3625
nop
and $3,$6,$6
sec111:
lb $6,2($0)
ori $6,$3,1333
or $6,$3,$5
and $3,$6,$6
sec112:
lh $6,8($0)
lui $6,527
lui $6,14856
and $2,$6,$6
sec113:
lhu $6,8($0)
sltiu $6,$4,6667
mflo $6
and $4,$6,$6
sec114:
lbu $6,13($0)
sltiu $6,$4,-15700
lh $6,10($0)
and $3,$6,$6
sec115:
lbu $6,1($0)
mfhi $6
nop
and $2,$6,$6
sec116:
lbu $6,12($0)
mflo $6
subu $6,$2,$6
and $1,$6,$6
sec117:
lbu $6,11($0)
mflo $6
lui $6,26396
and $5,$6,$6
sec118:
lhu $6,10($0)
mflo $6
mflo $6
and $4,$6,$6
sec119:
lw $6,0($0)
mflo $6
lw $6,8($0)
and $5,$6,$6
sec120:
lh $6,0($0)
lhu $6,12($0)
nop
and $2,$6,$6
sec121:
lb $6,10($0)
lh $6,0($0)
xor $6,$2,$1
and $1,$6,$6
sec122:
lw $6,16($0)
lb $6,0($0)
slti $6,$4,-21428
and $6,$6,$6
sec123:
lh $6,16($0)
lbu $6,3($0)
mflo $6
and $5,$6,$6
sec124:
lb $6,5($0)
lb $6,1($0)
lb $6,2($0)
and $2,$6,$6
|
INCLUDE "config_private.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF __CLIB_OPT_ERROR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; verbose mode
SECTION code_clib
SECTION code_error
PUBLIC error_eoverflow_mc
EXTERN __EOVERFLOW, errno_mc
pop hl
error_eoverflow_mc:
; set hl = -1
; set carry flag
; set errno = EOVERFLOW
ld l,__EOVERFLOW
jp errno_mc
SECTION rodata_clib
SECTION rodata_error_strings
IF __CLIB_OPT_ERROR & $02
defb __EOVERFLOW
defm "EOVERFLOW - Value too large for data type"
defb 0
ELSE
defb __EOVERFLOW
defm "EOVERFLOW"
defb 0
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ELSE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION code_clib
SECTION code_error
PUBLIC error_eoverflow_mc
EXTERN errno_mc
defc error_eoverflow_mc = errno_mc - 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
; A274604: Running sum of Noergaard's "infinity sequence" A004718.
; Submitted by Jon Maiga
; 0,1,0,2,3,3,1,4,3,5,5,6,8,7,4,8,9,9,7,10,10,11,10,12,10,13,14,14,17,15,11,16,15,17,17,18,20,19,16,20,20,21,20,22,23,23,21,24,26,25,22,26,25,27,27,28,25,29,31,30,34,31,26,32,33,33,31,34,34,35,34,36,34,37,38,38,41,39,35,40,40,41,40,42,43,43,41,44,43,45,45,46,48,47,44,48,46,49,50,50
lpb $0
mov $2,$0
sub $0,1
seq $2,4718 ; The Danish composer Per Nørgård's "infinity sequence", invented in an attempt to unify in a perfect way repetition and variation: a(2n) = -a(n), a(2n+1) = a(n) + 1, a(0) = 0.
add $1,$2
lpe
mov $0,$1
|
.include "m328pdef.inc"
; 512-word TFTP ethernet bootloader
; written by mitxela
; mitxela.com/projects/kiloboot
; For ATmega328p and ENC28J60
; Wiring:
; SPI pins are enforced by hardware and cannot be changed.
; PB3 MOSI
; PB4 MISO
; PB5 SCK
; CS, INT pins can be trivially changed here to any unused pin on PORTB
#define CS_PIN PB2
; Leave INT_PIN undefined to detect received packets by polling EPKTCNT
;#define INT_PIN PB1
; First byte of the MAC address must be an even number
; (LSB of MAC0 is a flag for "broadcast address")
.equ myMAC0 = @mac.0@
.equ myMAC1 = @mac.1@
.equ myMAC2 = @mac.2@
.equ myMAC3 = @mac.3@
.equ myMAC4 = @mac.4@
.equ myMAC5 = @mac.5@
#define FILENAME "@file.bin@"
#define MAX_REATTEMPTS 3
; Hard coded fallback addresses. If EEPROM is empty, use these instead.
; Note: comma separated, not dots!
#define myIP @device.ip@
#define serverIP @server.ip@
#define gatewayIP @gateway.ip@
#define subnetMask @subnetmask@
;//////////////////////////////////////////////////////////////
; My IP
.def rMyIP0 = r0
.def rMyIP1 = r1
.def rMyIP2 = r2
.def rMyIP3 = r3
; TFTP server address
.def rSvIP0 = r4
.def rSvIP1 = r5
.def rSvIP2 = r6
.def rSvIP3 = r7
; Default Gateway IP
.def rGwIP0 = r8
.def rGwIP1 = r9
.def rGwIP2 = r10
.def rGwIP3 = r11
; Subnet Mask
.def rSubMask0 = r12
.def rSubMask1 = r13
.def rSubMask2 = r14
.def rSubMask3 = r15
; ENC28J60 definitions
; SPI operation codes
.equ ENC28J60_READ_CTRL_REG = 0x00
.equ ENC28J60_READ_BUF_MEM = 0x3A
.equ ENC28J60_WRITE_CTRL_REG = 0x40
.equ ENC28J60_WRITE_BUF_MEM = 0x7A
.equ ENC28J60_BIT_FIELD_SET = 0x80
.equ ENC28J60_BIT_FIELD_CLR = 0xA0
.equ ENC28J60_SOFT_RESET = 0xFF
; All-bank registers
.equ EIE = 0x1B
.equ EIR = 0x1C
.equ ESTAT = 0x1D
.equ ECON2 = 0x1E
.equ ECON1 = 0x1F
; Bank 0 registers
.equ ERDPTL = (0x00|0x00)
.equ ERDPTH = (0x01|0x00)
.equ EWRPTL = (0x02|0x00)
.equ EWRPTH = (0x03|0x00)
.equ ETXSTL = (0x04|0x00)
.equ ETXSTH = (0x05|0x00)
.equ ETXNDL = (0x06|0x00)
.equ ETXNDH = (0x07|0x00)
.equ ERXSTL = (0x08|0x00)
.equ ERXSTH = (0x09|0x00)
.equ ERXNDL = (0x0A|0x00)
.equ ERXNDH = (0x0B|0x00)
.equ ERXRDPTL = (0x0C|0x00)
.equ ERXRDPTH = (0x0D|0x00)
.equ ERXWRPTL = (0x0E|0x00)
.equ ERXWRPTH = (0x0F|0x00)
.equ EDMASTL = (0x10|0x00)
.equ EDMASTH = (0x11|0x00)
.equ EDMANDL = (0x12|0x00)
.equ EDMANDH = (0x13|0x00)
.equ EDMADSTL = (0x14|0x00)
.equ EDMADSTH = (0x15|0x00)
.equ EDMACSL = (0x16|0x00)
.equ EDMACSH = (0x17|0x00)
; Bank 1 registers
.equ EHT0 = (0x00|0x20)
.equ EHT1 = (0x01|0x20)
.equ EHT2 = (0x02|0x20)
.equ EHT3 = (0x03|0x20)
.equ EHT4 = (0x04|0x20)
.equ EHT5 = (0x05|0x20)
.equ EHT6 = (0x06|0x20)
.equ EHT7 = (0x07|0x20)
.equ EPMM0 = (0x08|0x20)
.equ EPMM1 = (0x09|0x20)
.equ EPMM2 = (0x0A|0x20)
.equ EPMM3 = (0x0B|0x20)
.equ EPMM4 = (0x0C|0x20)
.equ EPMM5 = (0x0D|0x20)
.equ EPMM6 = (0x0E|0x20)
.equ EPMM7 = (0x0F|0x20)
.equ EPMCSL = (0x10|0x20)
.equ EPMCSH = (0x11|0x20)
.equ EPMOL = (0x14|0x20)
.equ EPMOH = (0x15|0x20)
.equ EWOLIE = (0x16|0x20)
.equ EWOLIR = (0x17|0x20)
.equ ERXFCON = (0x18|0x20)
.equ EPKTCNT = (0x19|0x20)
; Bank 2 registers
.equ MACON1 = (0x00|0x40|0x80)
.equ MACON2 = (0x01|0x40|0x80)
.equ MACON3 = (0x02|0x40|0x80)
.equ MACON4 = (0x03|0x40|0x80)
.equ MABBIPG = (0x04|0x40|0x80)
.equ MAIPGL = (0x06|0x40|0x80)
.equ MAIPGH = (0x07|0x40|0x80)
.equ MACLCON1 = (0x08|0x40|0x80)
.equ MACLCON2 = (0x09|0x40|0x80)
.equ MAMXFLL = (0x0A|0x40|0x80)
.equ MAMXFLH = (0x0B|0x40|0x80)
.equ MAPHSUP = (0x0D|0x40|0x80)
.equ MICON = (0x11|0x40|0x80)
.equ MICMD = (0x12|0x40|0x80)
.equ MIREGADR = (0x14|0x40|0x80)
.equ MIWRL = (0x16|0x40|0x80)
.equ MIWRH = (0x17|0x40|0x80)
.equ MIRDL = (0x18|0x40|0x80)
.equ MIRDH = (0x19|0x40|0x80)
; Bank 3 registers
.equ MAADR1 = (0x00|0x60|0x80)
.equ MAADR0 = (0x01|0x60|0x80)
.equ MAADR3 = (0x02|0x60|0x80)
.equ MAADR2 = (0x03|0x60|0x80)
.equ MAADR5 = (0x04|0x60|0x80)
.equ MAADR4 = (0x05|0x60|0x80)
.equ EBSTSD = (0x06|0x60)
.equ EBSTCON = (0x07|0x60)
.equ EBSTCSL = (0x08|0x60)
.equ EBSTCSH = (0x09|0x60)
.equ MISTAT = (0x0A|0x60|0x80)
.equ EREVID = (0x12|0x60)
.equ ECOCON = (0x15|0x60)
.equ EFLOCON = (0x17|0x60)
.equ EPAUSL = (0x18|0x60)
.equ EPAUSH = (0x19|0x60)
; PHY registers
.equ PHCON1 = 0x00
.equ PHSTAT1 = 0x01
.equ PHHID1 = 0x02
.equ PHHID2 = 0x03
.equ PHCON2 = 0x10
.equ PHSTAT2 = 0x11
.equ PHIE = 0x12
.equ PHIR = 0x13
.equ PHLCON = 0x14
; ENC28J60 ERXFCON Register Bit Definitions
.equ ERXFCON_UCEN = 0x80
.equ ERXFCON_ANDOR = 0x40
.equ ERXFCON_CRCEN = 0x20
.equ ERXFCON_PMEN = 0x10
.equ ERXFCON_MPEN = 0x08
.equ ERXFCON_HTEN = 0x04
.equ ERXFCON_MCEN = 0x02
.equ ERXFCON_BCEN = 0x01
; ENC28J60 EIE Register Bit Definitions
.equ EIE_INTIE = 0x80
.equ EIE_PKTIE = 0x40
.equ EIE_DMAIE = 0x20
.equ EIE_LINKIE = 0x10
.equ EIE_TXIE = 0x08
.equ EIE_WOLIE = 0x04
.equ EIE_TXERIE = 0x02
.equ EIE_RXERIE = 0x01
; ENC28J60 EIR Register Bit Definitions
.equ EIR_PKTIF = 0x40
.equ EIR_DMAIF = 0x20
.equ EIR_LINKIF = 0x10
.equ EIR_TXIF = 0x08
.equ EIR_WOLIF = 0x04
.equ EIR_TXERIF = 0x02
.equ EIR_RXERIF = 0x01
; ENC28J60 ESTAT Register Bit Definitions
.equ ESTAT_INT = 0x80
.equ ESTAT_LATECOL = 0x10
.equ ESTAT_RXBUSY = 0x04
.equ ESTAT_TXABRT = 0x02
.equ ESTAT_CLKRDY = 0x01
; ENC28J60 ECON2 Register Bit Definitions
.equ ECON2_AUTOINC = 0x80
.equ ECON2_PKTDEC = 0x40
.equ ECON2_PWRSV = 0x20
.equ ECON2_VRPS = 0x08
; ENC28J60 ECON1 Register Bit Definitions
.equ ECON1_TXRST = 0x80
.equ ECON1_RXRST = 0x40
.equ ECON1_DMAST = 0x20
.equ ECON1_CSUMEN = 0x10
.equ ECON1_TXRTS = 0x08
.equ ECON1_RXEN = 0x04
.equ ECON1_BSEL1 = 0x02
.equ ECON1_BSEL0 = 0x01
; ENC28J60 MACON1 Register Bit Definitions
.equ MACON1_LOOPBK = 0x10
.equ MACON1_TXPAUS = 0x08
.equ MACON1_RXPAUS = 0x04
.equ MACON1_PASSALL = 0x02
.equ MACON1_MARXEN = 0x01
; ENC28J60 MACON2 Register Bit Definitions
.equ MACON2_MARST = 0x80
.equ MACON2_RNDRST = 0x40
.equ MACON2_MARXRST = 0x08
.equ MACON2_RFUNRST = 0x04
.equ MACON2_MATXRST = 0x02
.equ MACON2_TFUNRST = 0x01
; ENC28J60 MACON3 Register Bit Definitions
.equ MACON3_PADCFG2 = 0x80
.equ MACON3_PADCFG1 = 0x40
.equ MACON3_PADCFG0 = 0x20
.equ MACON3_TXCRCEN = 0x10
.equ MACON3_PHDRLEN = 0x08
.equ MACON3_HFRMLEN = 0x04
.equ MACON3_FRMLNEN = 0x02
.equ MACON3_FULDPX = 0x01
; ENC28J60 MICMD Regster Bit Definitions
.equ MICMD_MIISCAN = 0x02
.equ MICMD_MIIRD = 0x01
; ENC28J60 MISTAT Register Bit Definitions
.equ MISTAT_NVALID = 0x04
.equ MISTAT_SCAN = 0x02
.equ MISTAT_BUSY = 0x01
; ENC28J60 PHY PHCON1 Register Bit Definitions
.equ PHCON1_PRST = 0x8000
.equ PHCON1_PLOOPBK = 0x4000
.equ PHCON1_PPWRSV = 0x0800
.equ PHCON1_PDPXMD = 0x0100
; ENC28J60 PHY PHSTAT1 Register Bit Definitions
.equ PHSTAT1_PFDPX = 0x1000
.equ PHSTAT1_PHDPX = 0x0800
.equ PHSTAT1_LLSTAT = 0x0004
.equ PHSTAT1_JBSTAT = 0x0002
; ENC28J60 PHY PHCON2 Register Bit Definitions
.equ PHCON2_FRCLINK = 0x4000
.equ PHCON2_TXDIS = 0x2000
.equ PHCON2_JABBER = 0x0400
.equ PHCON2_HDLDIS = 0x0100
; ENC28J60 Packet Control Byte Bit Definitions
.equ PKTCTRL_PHUGEEN = 0x08
.equ PKTCTRL_PPADEN = 0x04
.equ PKTCTRL_PCRCEN = 0x02
.equ PKTCTRL_POVERRIDE = 0x01
.equ MAX_FRAMELEN = 580
#define ctrlReg(addr) ENC28J60_WRITE_CTRL_REG | (addr & 0x1F)
#define readCtrlReg(addr) ENC28J60_READ_CTRL_REG | (addr & 0x1F)
#define setBF(addr) ENC28J60_BIT_FIELD_SET | (addr & 0x1F)
#define clrBF(addr) ENC28J60_BIT_FIELD_CLR | (addr & 0x1F)
.dseg
packetBuffer:
destMAC: .byte 6
sourceMAC: .byte 6
ethType: .byte 2
ethPayload: .byte 568
.cseg
.org 0x3e00 ; 1kB from the end
; Mostly redunant reset code. The bootloader may be started by a jump from
; the main application, so disable interrupts and reset the stack.
; Power-on and watchdog reset does this automatically
cli
ldi r16,low(RAMEND)
out SPL,r16
ldi r16,high(RAMEND)
out SPH,r16
rcall loadIPs
; is the server on same subnet as me?
and rMyIP0, rSubMask0
and rMyIP1, rSubMask1
and rMyIP2, rSubMask2
and rMyIP3, rSubMask3
and rSvIP0, rSubMask0
and rSvIP1, rSubMask1
and rSvIP2, rSubMask2
and rSvIP3, rSubMask3
cp rMyIP0, rSvIP0
cpc rMyIP1, rSvIP1
cpc rMyIP2, rSvIP2
cpc rMyIP3, rSvIP3
in r19, SREG ; store result of comparison
rcall loadIPs ; undo the ANDing
out SREG, r19
brne differentSubnets
; rGwIP is the IP we send ARP request for
; If on the same subnet, send ARP for server IP instead
movw rGwIP1:rGwIP0,rSvIP1:rSvIP0
movw rGwIP3:rGwIP2,rSvIP3:rSvIP2
differentSubnets:
; ephemeral port counter. Don't initialize, will hold value after reset.
.def ephReg = r22
.def attempts = r23
.undef rSubMask0
.undef rSubMask1
.undef rSubMask2
.undef rSubMask3
.def nextPacketL = r14
.def nextPacketH = r15
.def zeroReg = r13
clr nextPacketL
clr nextPacketH
clr zeroReg
; Limit range to avoid having to do 16bit calcs where possible
andi ephReg, $3F
#ifdef DEBUG
ldi r16, 1<<PD1
out DDRD,r16
ldi r16,0
sts UBRR0H, r16
ldi r16,3
sts UBRR0L, r16
ldi r16, (1<<TXEN0)
sts UCSR0B,r16
ldi r16, (3<<UCSZ00)
sts UCSR0C,r16
ldi r16, 'X'
rcall UARTsend
#endif
in r16, MCUSR
sbrs r16,WDRF
clr attempts ; this will only run on power on / external reset
handleWatchdog:
wdr
out MCUSR, zeroReg
ldi r18, MAX_REATTEMPTS
clr r17 ; disable watchdog if about to give up
ldi r16, (1<<WDCE) | (1<<WDE)
cpse attempts, r18
ldi r17, (1<<WDE) | (1<<WDP3) ; 4s
sts WDTCSR, r16
sts WDTCSR, r17
cpi attempts, MAX_REATTEMPTS
brne dontgiveup
; t: rjmp t ;hang
; Run application, run!
jmp 0
dontgiveup:
inc attempts
inc ephReg ; Count number of resets since power on
ldi r16, (1<<CS_PIN)|(1<<PB2)|(1<<PB3)|(1<<PB5)
out DDRB,r16
sbi PORTB,CS_PIN
#ifdef INT_PIN
sbi PORTB,INT_PIN
#endif
; Init SPI
ldi r16,(1<<SPE)|(1<<MSTR)
out SPCR,r16
ldi r16,(1<<SPI2X)
out SPSR,r16
; enc28j60 startup
ldi r16,ENC28J60_SOFT_RESET
ldi r17,0
rcall enc28j60write
; wait for startup time ~300ms
ldi xh, 32
waitStartupTime:
rcall wait2
sbiw x,1
brne waitStartupTime
ldi ZL, low(initCode*2)
ldi ZH, high(initCode*2)
ldi r20, (initCodeEnd - initCode) ;length in words
loadParams:
lpm r16,Z+
lpm r17,Z+
rcall enc28j60write
rcall wait2
dec r20
brne loadParams
;findGateway:
ldi YH, HIGH(packetBuffer)
ldi YL, LOW(packetBuffer)
ldi r16,12
ldi r17,$ff ; FFReg?
arpBroadcastFill:
std Y+32, zeroReg
st Y+,r17
dec r16
brne arpBroadcastFill
;ldi ZL, LOW()
;ldi ZH, HIGH() ; data is immediately after loadparams
ldi r17, 16
rcall loadPMtoSRAM
rcall writeIPtoSram
adiw Y,6
; now load gateway IP
st Y+,rGwIP0
st Y+,rGwIP1
st Y+,rGwIP2
st Y+,rGwIP3
ldi r19, 42
rcall transmitPacket
waitForArpResponse:
rcall readPacket
cpi r19, $08 ; maybe put brne readPacket in the subroutine?
brne waitForArpResponse
cpi r20, $06
brne waitForArpResponse
adiw Y,14
movw r17:r16, rGwIP1:rGwIP0
rcall cpMem2
movw r17:r16, rGwIP3:rGwIP2
rcall cpMem2c
brne waitForArpResponse
; note - this may have been an ARP request from the gateway looking for someone else, but it's still valid
; We now have the mac address for the gateway IP.
; last z operation was loading myMAC, in transmit subroutine
; z is now pointing at IPprototype
; Y needs to rewind to eth type
sbiw Y, 20
ldi r17, 12
rcall loadPMtoSRAM
; Work out the constant part of the checksum
#define IPmsg1ChecksumA (($45+$e6+$40+$40)<<8) + $11 + low(37+strlen(FILENAME))
#define IPmsg1ChecksumB (lwrd(IPmsg1ChecksumA) + byte3(IPmsg1ChecksumA))
#define IPmsg1Checksum ~(lwrd(IPmsg1ChecksumB) + byte3(IPmsg1ChecksumB))
ldi r25, high(IPmsg1Checksum)
ldi r24, low(IPmsg1Checksum)
sub r24, rMyIP1
sbc r25, rMyIP0
sbc r24, rMyIP3
sbc r25, rMyIP2
sbc r24, rSvIP1
sbc r25, rSvIP0
sbc r24, rSvIP3
sbc r25, rSvIP2
sbc r24, ephReg ; 0:ephReg is IP ID field
sbc r25, zeroReg
sbc r24, zeroReg
st Y+, r25
st Y+, r24
rcall writeIPtoSram ; source IP
st Y+,rSvIP0 ; destination IP
st Y+,rSvIP1
st Y+,rSvIP2
st Y+,rSvIP3
ldi r17, (17+strlen(FILENAME)) ; rest of the preformed packet
rcall loadPMtoSRAM
sbiw Y, (32+strlen(FILENAME)) ; move to IP ID low byte
st Y, ephReg
std Y+16, ephReg ; UDP source port (is also transaction ID for tftp)
ldi r19, (51 + strlen(FILENAME))
rcall transmitPacket
main:
rcall readPacket
; check packet length? otherwise, no point filtering for packet length in readPacket
; ARP eth type is 0x0806
; IPv4 eth type is 0x0800
cpi r19, $08
brne main ; Not Arp or Ip - ignore completely.
cpi r20,$06
brne packetIsNotARP
;Should we check the hardware and protocol type and length bytes?
adiw Y,24 ; move ahead to dest ip field
rcall isItMyIP
brne main
sbiw Y, 21 ; rewind to the req/resp field
ld r16,Y
cpi r16, 1 ; 1=request, 2=reply
brne main
ldi r16,2
st Y+,r16 ; write response
; Swap source/dest mac & ip addresses
ldi XH, HIGH(ethPayload + 18)
ldi XL, LOW(ethPayload + 18)
ldi r18,10
rcall swapData
sbiw Y, 10
rcall writeMacToSram
ldi r19,42-1
rcall transmitPacket
backToMain:
rjmp main
packetIsNotARP:
cpi r20,$00
brne backToMain ; not IPv4
adiw Y,16 ; move ahead to dest ip field
rcall isItMyIP
brne backToMain
; Swap source/dest ip addresses
sbiw Y, 4
ldi XH, HIGH(ethPayload + 12)
ldi XL, LOW(ethPayload + 12)
ldi r18,4
rcall swapData
;ip type
sbiw X,7
ld r16,X
/*
////// uncomment for ICMP echo ///////
cpi r16,$01
brne notICMP
;is it echo request?
ld r16,Y
cpi r16,$08
brne backToMain
; zero the type to turn it into a response
st Y, zeroReg
;checksum will only have changed by 8, so add it on.
ldd XL, Y+2 ; high byte
ldd XH, Y+3 ; low byte, for wrapping carry
adiw X, 8
adc XL, zeroReg ; carry again, in case checksum was near 0xffff
std Y+2, XL
std Y+3, XH
mov r19, r24 ; packet length
rcall transmitPacket ; or rjmp?
rjmp main
notICMP:*/
cpi r16,$11
brne backToMain ; not UDP
ldd r16, Y+9
cpi r16,$03 ; is it tftp opcode 03 = data?
ldd r16,Y+3
cpc r16,ephReg ;is it our current port number?
brne backToMain
; It's a UDP message with the right port number/transaction id.
; should we check it's from the right source IP?
; swap port numbers
adiw X, 13
ldi r18,2
rcall swapData
; X is now pointing to the UDP length field
ld r25,X+
ld r24,X+
sbiw r25:r24, 12 ; remove UDP header
; send ACK
;opcode = 04
ldi r16,$04
std Y+7,r16
;udp length = 0c
ldi r16,$0c
std Y+3,r16
std Y+2,zeroReg
;zero udp checksum
std Y+4,zeroReg
std Y+5,zeroReg
;ip length = $00,$20
sbiw Y,20
st Y,zeroReg
ldi r16, $20
std Y+1, r16
;correct ip checksum (add r25:r24)
ldd XH, Y+8
ldd XL, Y+9
add XL, r24
adc XH, r25
adc XL, zeroReg
std Y+9, XL
std Y+8, XH
adiw Y,29
ld ZH,Y+;block number
; Y now points to first byte of data.
cpi ZH, 63 ; ignore block numbers above 62 = 31kB
brcc skipSPM
dec ZH ; block number starts at 1
lsl ZH ; blocks are 512 bytes
clr ZL
; Z now points to the first page of this block
sbiw r25:r24, 0 ; test zero
breq skipSPM
; check existing data against new data, avoid rewriting if possible
mov r19,ZH
subi r19,-2 ; count 512 bytes
checkDataLoop:
lpm r20, Z+
ld r17, Y+
cpse r17,r20
ldi r16,0 ; we know that r16 is non-zero at this point
cp ZH,r19
brne checkDataLoop
tst r16
breq dataDifferent
rjmp skipSPM
dataDifferent:
subi ZH,2
subi YH,2
; One we've started writing to PM, we don't want
; to give up, even if it times out
ldi attempts, MAX_REATTEMPTS+1
rcall SPMfourpages
skipSPM:
; send ACK
ldi r19,46
rcall transmitPacket
; if r25:r24 != 512, end loading seq
cpi r25, $02
cpc r24, zeroReg
;brne tftpDataEnd
brne noMoreData
rjmp main
noMoreData:
; reuse attempt code to disable watchdog and jmp 0.
ldi attempts, MAX_REATTEMPTS
rjmp handleWatchdog
; the end!
SPMfourpages:
rcall SPMtwopages
SPMtwopages:
rcall SPMwritePage
; Z = page of PM to write
; Y = SRAM with data to write
SPMwritePage:
; Page Erase
ldi r16, (1<<PGERS)|(1<<SPMEN)
rcall doSPM
rcall SPMenableRWW
; ATmega328p page size = 64 words = 128 bytes
ldi r18, 64
movw XH:XL, r1:r0 ; save r0,r1
SPMwritePageLoop:
ld r0, Y+
ld r1, Y+
ldi r16, (1<<SPMEN)
rcall doSPM
adiw ZH:ZL, 2
dec r18
brne SPMwritePageLoop
subi ZL, 128
sbci ZH, 0
; Execute page write
ldi r16, (1<<PGWRT)|(1<<SPMEN)
rcall doSPM
subi ZL, -128
sbci ZH, -1
movw r1:r0, XH:XL ;restore r0,r1
SPMenableRWW:
ldi r16, (1<<RWWSRE)|(1<<SPMEN)
rcall doSPM
ret
doSPM:
in r17, SPMCSR
sbrc r17, SPMEN
rjmp doSPM
out SPMCSR, r16
spm
ret
; length = r19+1... will we want to transmit bigger packets than 255 bytes?
transmitPacket:
wdr
#ifdef DEBUG
ldi r16,13
rcall UARTsend
ldi r16,'T'
rcall UARTsend
ldi r16,' '
rcall UARTsend
#endif
;Check no transmit in progress
waitForTransmitReady:
clr r17 ; write zero does a read
ldi r16, readCtrlReg(ECON1)
rcall enc28j60write
sbrs r16, 3 ; ECON1_TXRTS
rjmp startTransmit
ldi r16, readCtrlReg(EIR)
rcall enc28j60write
sbrs r16, 1 ;EIR_TXERIF
rjmp waitForTransmitReady
; Reset transmit logic
ldi r16, setBF(ECON1)
ldi r17, ECON1_TXRST
rcall enc28j60write
ldi r16, clrBF(ECON1)
;ldi r17, ECON1_TXRST
rcall enc28j60write
rjmp waitForTransmitReady
startTransmit:
; Set the write pointer to start of transmit buffer area
ldi r16, ctrlReg(EWRPTL)
ldi r17, LOW(0x1FFF-0x0600)
ldi r18, HIGH(0x1FFF-0x0600)
rcall enc28j60writeWord
; Set the TXND pointer to correspond to the packet size given
ldi r16, ctrlReg(ETXNDL)
mov r17, r19
dec r17
ldi r18, HIGH((0x1FFF-0x0600) +1) ; Align to page to save adding length
rcall enc28j60writeWord
; copy the packet into the transmit buffer
cbi PORTB,CS_PIN ;keep cs low for entire write
ldi r16,ENC28J60_WRITE_BUF_MEM
rcall doSPI
; packet control byte = 0
rcall doSPIzero
inc r19
ldi YH, HIGH(packetBuffer+6)
ldi YL, LOW(packetBuffer+6)
rcall writeMacToSram
sbiw Y,12
txLoop:
ld r16,Y+
#ifdef DEBUG
rcall sendHex
#endif
rcall doSPI
dec r19
brne txLoop
sbi PORTB,CS_PIN
; transmit!
ldi r16,setBF(ECON1)
ldi r17,ECON1_TXRTS
;rcall enc28j60write
;ret
rjmp enc28j60write
readPacket:
#ifdef INT_PIN
sbic PINB, INT_PIN
rjmp readPacket
#else
; Set bank 1
ldi r16, setBF(ECON1)
ldi r17, ECON1_BSEL0
rcall enc28j60write
ldi r16, readCtrlReg(EPKTCNT)
;clr r17 ;probably not needed
rcall enc28j60write
tst r16
breq readPacket
; Set bank 0
ldi r16, clrBF(ECON1)
ldi r17, ECON1_BSEL0
rcall enc28j60write
#endif
#ifdef DEBUG
ldi r16,13
rcall UARTsend
ldi r16,'R'
rcall UARTsend
ldi r16,' '
rcall UARTsend
#endif
; After init code, we are left on bank 0
; Set the read pointer to the start of the received packet
ldi r16, ctrlReg(ERDPTL)
mov r17, nextPacketL
mov r18, nextPacketH
rcall enc28j60writeWord
cbi PORTB,CS_PIN ;keep cs low for entire read
ldi r16,ENC28J60_READ_BUF_MEM
rcall doSPI
; read the next packet pointer
rcall doSPIzero
mov nextPacketL,r16
rcall doSPIzero
mov nextPacketH,r16
; read packet length
rcall doSPIzero
mov XL,r16
rcall doSPIzero
mov XH,r16
sbiw X,4 ; remove CRC
movw r25:r24, XH:XL ; Store length for later
; ignore zero-length messages
;cpi XL, 0
;cpc XH, XL
sbiw X, 0
breq rxDone
;limit to 768 bytes
ldi YH, HIGH(768)
ldi YL, LOW(768)
cp XH, YH
cpc XL, YL
brcc under768
movw X, Y
under768:
ldi YH, HIGH(packetBuffer)
ldi YL, LOW(packetBuffer)
; read the receive status (see datasheet page 43)
rcall doSPIzero
rcall doSPIzero
rxLoop:
rcall doSPIzero
#ifdef DEBUG
rcall sendHex
#endif
st Y+,r16
sbiw X,1
brne rxLoop
rxDone:
sbi PORTB,CS_PIN
; Is there any situation where we wouldn't want to swap the mac addresses?
ldi YH, HIGH(sourceMAC)
ldi YL, LOW(sourceMAC)
ldi XH, HIGH(destMAC)
ldi XL, LOW(destMAC)
ldi r18,6
rcall swapData
;ldi YH, HIGH(ethType) ; already set as a result of swapping macs
;ldi YL, LOW(ethType)
ld r19,Y+ ;
ld r20,Y+
ldi r16, ctrlReg(ERXRDPTL)
mov r17, nextPacketL
mov r18, nextPacketH
rcall enc28j60writeWord
; decrease packet count
ldi r16,setBF(ECON2)
ldi r17,ECON2_PKTDEC
; rcall enc28j60write
;ret
rjmp enc28j60write
doSPIzero:
clr r16
doSPI:
out SPDR,r16
SPIwait:
in r16, SPSR
sbrs r16, SPIF
rjmp SPIwait
in r16, SPDR
ret
; r16 = op | (address & 0x1F) [L register]
; r17 = dataL
; r18 = dataH
enc28j60writeWord:
push r16
rcall enc28j60write
pop r16
inc r16
mov r17, r18
;rcall enc28j60write
; r16 = op | (address & 0x1F)
; r17 = data
enc28j60write:
cbi PORTB,CS_PIN
rcall doSPI
mov r16,r17
rcall doSPI
sbi PORTB,CS_PIN
ret
; X = somewhere in sram
; Y = another bit of sram
; r18 = amount to copy
swapData:
ld r16, X
ld r17, Y
st Y+,r16
st X+,r17
dec r18
brne swapData
ret
; compare Y,Y+1 against r16,r17
cpMem2:
sez
; compare Y,Y+1 against r16,r17, with carry
cpMem2c:
ld r18,Y+
cpc r18, r16
ld r18,Y+
cpc r18, r17
ret
; check Y against my IP
isItMyIP:
movw r17:r16, rMyIP1:rMyIP0
rcall cpMem2
movw r17:r16, rMyIP3:rMyIP2
;rcall cpMem2c
;ret
rjmp cpMem2c
writeIPtoSram:
st Y+,rMyIP0
st Y+,rMyIP1
st Y+,rMyIP2
st Y+,rMyIP3
ret
writeMacToSram:
ldi ZL, low(myMAC*2)
ldi ZH, high(myMAC*2)
ldi r17, 6
loadPMtoSRAM:
lpm r16, Z+
st Y+,r16
dec r17
brne loadPMtoSRAM
ret
wait2:
dec zeroReg
brne wait2
ret
loadIPs:
clr XL
clr XH
movw Y, X
EEPROM_read:
; Wait for completion of previous write
sbic EECR,EEPE
rjmp EEPROM_read
; Set up address
out EEARH, XH
out EEARL, XL
; Start eeprom read by writing EERE
sbi EECR,EERE
; Read data from Data Register
in r16,EEDR
st X+,r16 ; store in r0...r15
cpi XL, 16
brne EEPROM_read
; The last byte of the subnet mask will never be 255
; if it read 255, assume eeprom data is invalid and resort to pm
cpi r16, 255
breq loadIpsFromPm
ret
loadIpsFromPm:
ldi ZL, low(hardIPs*2)
ldi ZH, high(hardIPs*2)
ldi r17, 16
rjmp loadPMtoSRAM
; debug functions
#ifdef DEBUG
UARTsend:
lds r17, UCSR0A
sbrs r17, UDRE0
rjmp UARTsend
sts UDR0,r16
ret
sendHex:
push r16
swap r16
mov r18,r16
rcall sendHalfHex
swap r18
rcall sendHalfHex
ldi r16,' '
rcall UARTsend
pop r16
ret
sendHalfHex:
mov r16, r18
andi r16, $0F
subi r16,10
brcc sHHA
subi r16,-'0'-10
rcall UARTsend
ret
sHHA:
subi r16,-'A'
rcall UARTsend
ret
#endif
hardIPs:
.db myIP, serverIP, gatewayIP, subnetMask
initCode:
; select bank 0
.db clrBF(ECON1), (ECON1_BSEL1|ECON1_BSEL0)
.db ctrlReg(ERXSTL), 0
.db ctrlReg(ERXSTH), 0
.db ctrlReg(ERXRDPTL), low(0x1FFF-0x0600-1)
.db ctrlReg(ERXRDPTH), high(0x1FFF-0x0600-1)
.db ctrlReg(ERXNDL), low(0x1FFF-0x0600-1)
.db ctrlReg(ERXNDH), high(0x1FFF-0x0600-1)
.db ctrlReg(ETXSTL), low(0x1FFF-0x0600)
.db ctrlReg(ETXSTH), high(0x1FFF-0x0600)
.db ctrlReg(ETXNDL), low(0x1FFF) ; redundant?
.db ctrlReg(ETXNDH), high(0x1FFF)
;select bank 1
.db setBF(ECON1), ECON1_BSEL0
; packet filter stuff
.db ctrlReg(ERXFCON), ERXFCON_UCEN|ERXFCON_CRCEN|ERXFCON_PMEN
.db ctrlReg(EPMM0), 0x3f
.db ctrlReg(EPMM1), 0x30
.db ctrlReg(EPMCSL), 0xf9
.db ctrlReg(EPMCSH), 0xf7
; select bank 3 (minimize bit changes)
.db setBF(ECON1), ECON1_BSEL1
; NOTE: MAC address in ENC28J60 is byte-backward
.db ctrlReg(MAADR5) , myMAC0
.db ctrlReg(MAADR4) , myMAC1
.db ctrlReg(MAADR3) , myMAC2
.db ctrlReg(MAADR2) , myMAC3
.db ctrlReg(MAADR1) , myMAC4
.db ctrlReg(MAADR0) , myMAC5
;select bank 2
.db clrBF(ECON1), ECON1_BSEL0
; enable MAC receive
.db ctrlReg(MACON1), MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS
; bring MAC out of reset
.db ctrlReg(MACON2), 0x00
; enable automatic padding to 60bytes and CRC operations
.db setBF(MACON3), MACON3_PADCFG0|MACON3_TXCRCEN ;|MACON3_FRMLNEN
; set inter-frame gap (non-back-to-back)
.db ctrlReg(MAIPGL), 0x12
.db ctrlReg(MAIPGH), 0x0C
; set inter-frame gap (back-to-back)
.db ctrlReg(MABBIPG), 0x12
; Set the maximum packet size which the controller will accept
; Do not send packets longer than MAX_FRAMELEN:
.db ctrlReg(MAMXFLL), low(MAX_FRAMELEN)
.db ctrlReg(MAMXFLH),high(MAX_FRAMELEN)
; set PHY register
.db ctrlReg(MIREGADR),PHCON2
.db ctrlReg(MIWRL), low(PHCON2_HDLDIS)
.db ctrlReg(MIWRH),high(PHCON2_HDLDIS)
;LEDs: flash orange on receive, flash green on transmit
.db ctrlReg(MIREGADR),PHLCON
.db ctrlReg(MIWRL),0b00100010
.db ctrlReg(MIWRH),0b00110001
; then wait 10.24us until the PHY write completes... can we still do other stuff though?
;enable interrupts - needed?
.db setBF(EIE), EIE_INTIE|EIE_PKTIE
;enable packet reception
.db setBF(ECON1), ECON1_RXEN
; select bank 0
.db clrBF(ECON1), (ECON1_BSEL1|ECON1_BSEL0)
; select bank 1
;.db setBF(ECON1), (ECON1_BSEL0)
initCodeEnd:
ARPprototype:
;.db $FF,$FF,$FF,$FF,$FF,$FF, myMAC0..5
.db $08, $06, $00, $01, $08, $00, $06, $04, $00, $01
myMAC:
.db myMAC0, myMAC1, myMAC2, myMAC3, myMAC4, myMAC5
myMACend:
;.db myIP0, myIP1, myIP2, myIP3
; six zeros
; gateway ip
;.db gwIP0, gwIP1, gwIP2, gwIP3
IPprototype:
; t e m p . t x t o c t e t
;TFTP read request: a44e313cc814 28f36626f64b 08 00 45 00 00 2d e6 97 40 00 40 11 d0 27 c0a8015d c0a80153 e2bd 0045 00 19 46 a1 00 01 74 65 6d 70 2e 74 78 74 00 6f 63 74 65 74 00
; need to generate: IP id, checksum, source port
.db $08, $00 ; eth type
.db $45, $00 ; ipv4, header length 20 bytes
.db 0, low(37+strlen(FILENAME)) ; total length (filename length<31 chars)
IPprotoID:
.db $e6, $97 ; identification
.db $40, $00 ; flags, fragment offset - don't fragment.
.db $40, $11 ; TTL, protocol = udp (17)
;IPprotoChecksum:
;.db high(IPmsg1Checksum), low(IPmsg1Checksum) ; header checksum
;source IP
;.db myIP0, myIP1, myIP2, myIP3 ; duplicate again...
;dest IP
;.db svIP0, svIP1, svIP2, svIP3
;options (none)
;UDPheader:
.db $e2, $bd ;source port (ephemeral)
.db $00, $45 ;dest port
.db $00, $11+strlen(FILENAME) ;length (header+data)
.db $00, $00 ;checksum (0 = don't use)
;tftp
.db $00, $01 ; opcode = read request
.db FILENAME, 0, "octet",0
|
; A024050: a(n) = 5^n - n.
; 1,4,23,122,621,3120,15619,78118,390617,1953116,9765615,48828114,244140613,1220703112,6103515611,30517578110,152587890609,762939453108,3814697265607,19073486328106,95367431640605,476837158203104,2384185791015603,11920928955078102,59604644775390601,298023223876953100,1490116119384765599,7450580596923828098,37252902984619140597,186264514923095703096,931322574615478515595,4656612873077392578094,23283064365386962890593,116415321826934814453092,582076609134674072265591,2910383045673370361328090
mov $1,5
pow $1,$0
sub $1,$0
mov $0,$1
|
copyright zengfr site:http://github.com/zengfr/romhack
00B82E move.b #$10, ($31,A6) [base+65C]
00B834 move.l #$0, ($32,A6) [base+65D]
00B866 subq.b #1, ($31,A6)
00B86A bmi $b8a6 [base+65D]
copyright zengfr site:http://github.com/zengfr/romhack
|
CODE SEGMENT
ASSUME CS:CODE,DS:CODE,ES:CODE,SS:CODE
org 1000h
CODE ENDS
END |
.size 8000
.text@100
jp lbegin
.text@150
lbegin:
ld c, 41
ld b, 03
lbegin_waitm3:
ldff a, (c)
and a, b
cmp a, b
jrnz lbegin_waitm3
ld a, 20
ldff(c), a
ld a, 02
ldff(ff), a
xor a, a
ld c, 44
halt
nop
nop
nop
nop
jp l1000
.text@1000
l1000:
nop
.text@1068
ldff a, (c)
and a, b
jp lprint_a
.text@7000
lprint_a:
push af
ld b, 91
call lwaitly_b
xor a, a
ldff(40), a
pop af
ld(9800), a
ld bc, 7a00
ld hl, 8000
ld d, a0
lprint_copytiles:
ld a, (bc)
inc bc
ld(hl++), a
dec d
jrnz lprint_copytiles
ld a, c0
ldff(47), a
ld a, 80
ldff(68), a
ld a, ff
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
xor a, a
ldff(69), a
ldff(69), a
ldff(43), a
ld a, 91
ldff(40), a
lprint_limbo:
jr lprint_limbo
.text@7400
lwaitly_b:
ld c, 44
lwaitly_b_loop:
ldff a, (c)
cmp a, b
jrnz lwaitly_b_loop
ret
.data@7a00
00 00 7f 7f 41 41 41 41
41 41 41 41 41 41 7f 7f
00 00 08 08 08 08 08 08
08 08 08 08 08 08 08 08
00 00 7f 7f 01 01 01 01
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 01 01 01 01
3f 3f 01 01 01 01 7f 7f
00 00 41 41 41 41 41 41
7f 7f 01 01 01 01 01 01
00 00 7f 7f 40 40 40 40
7e 7e 01 01 01 01 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 41 41 41 41 7f 7f
00 00 7f 7f 01 01 02 02
04 04 08 08 10 10 10 10
00 00 3e 3e 41 41 41 41
3e 3e 41 41 41 41 3e 3e
00 00 7f 7f 41 41 41 41
7f 7f 01 01 01 01 7f 7f
|
CinnabarMart_Object:
db $0 ; border block
db 2 ; warps
warp 3, 7, 4, -1
warp 4, 7, 4, -1
db 0 ; signs
db 3 ; objects
object SPRITE_MART_GUY, 0, 5, STAY, RIGHT, 1 ; person
object SPRITE_ERIKA, 6, 2, STAY, NONE, 2 ; person
object SPRITE_OAK_AIDE, 3, 4, STAY, NONE, 3 ; person
; warp-to
warp_to 3, 7, CINNABAR_MART_WIDTH
warp_to 4, 7, CINNABAR_MART_WIDTH
|
;********************************************************************************************************
; uC/TCP-IP
; The Embedded TCP/IP Suite
;
; Copyright 2004-2020 Silicon Laboratories Inc. www.silabs.com
;
; SPDX-License-Identifier: APACHE-2.0
;
; This software is subject to an open source license and is distributed by
; Silicon Laboratories Inc. pursuant to the terms of the Apache License,
; Version 2.0 available at www.apache.org/licenses/LICENSE-2.0.
;
;********************************************************************************************************
;********************************************************************************************************
;
; NETWORK UTILITY LIBRARY
;
; ARM-Cortex-M3
; IAR Compiler
;
; Filename : net_util_a.asm
; Version : V3.06.00
;********************************************************************************************************
; Note(s) : (1) Assumes ARM CPU mode configured for Little Endian.
;********************************************************************************************************
;********************************************************************************************************
; PUBLIC FUNCTIONS
;********************************************************************************************************
PUBLIC NetUtil_16BitSumDataCalcAlign_32
;********************************************************************************************************
; CODE GENERATION DIRECTIVES
;********************************************************************************************************
RSEG CODE:CODE:NOROOT(2)
;********************************************************************************************************
; NetUtil_16BitSumDataCalcAlign_32()
;
; Description : Calculate 16-bit sum on 32-bit word-aligned data.
;
; Argument(s) : pdata_32 Pointer to 32-bit word-aligned data (see Note #2).
;
; size Size of data.
;
; Return(s) : 16-bit sum (see Notes #1 & #3).
;
; Caller(s) : NetUtil_16BitSumDataCalc().
;
; This function is an INTERNAL network protocol suite function & SHOULD NOT be called by
; application function(s).
;
; Note(s) : (1) Computes the sum of consecutive 16-bit values.
;
; (2) Since many word-aligned processors REQUIRE that multi-octet words be located on word-
; aligned addresses, sum calculation REQUIREs that 32-bit words are accessed on addresses
; that are multiples of 4 octets.
;
; (3) The 16-bit sum MUST be returned in Big Endian/Network order.
;
; See 'net_util.c NetUtil_16BitSumDataCalc() Note #5b'.
;
; (a) Assumes Little Endian CPU Mode (see 'net_util_a.asm Note #1') thus requiring the
; 16-bit octets of the 32-bit data to be swapped.
;
; #### However, the 16-bit octets COULD be swapped after the 16-bit sum is fully
; calculated.
;
; (4) (a) A "straightforward" assembly implementation would do the following for each
; 32-bit word:
;
; (1) Extract the lower 16-bit half-word from the 32-bit word.
; (2) Swap the lower 16-bit half-word's bytes.
; (3) Add the lower 16-bit half-word to the sum.
; (4) Extract the higher 16-bit half-word from the 32-bit word.
; (5) Swap the higher 16-bit half-word's bytes.
; (6) Add the higher 16-bit half-word to the sum.
;
; If the initial 32-bit word were 0x11223344, then 0x2211 and 0x4433 would be the
; two 16-bit half-words that eventually get added to the sum.
;
; (b) A faster assembly implementation which can accelerate this process would do the
; following for each 32-bit word:
;
; (1) Rotate the 32-bit word right 8 bits.
; (2) Extract the lower 16-bit half-word from the rotated 32-bit word.
; (3) Add the lower 16-bit half-word to the sum.
; (4) Extract the higher 16-bit half-word from the rotated 32-bit word.
; (5) Add the higher 16-bit half-word to the sum.
;
; If the initial 32-bit word were 0x11223344, then 0x4411 and 0x2233 would be the
; two 16-bit half-words that eventually get added to the sum. Notice these
; half-words are equal to those formed in the straightforward implementation with
; the lower octets swapped. Since the algorithm does not care about the order in
; which the bytes are accumulated (only the position of the bytes), this does not
; affect the outcome.
;********************************************************************************************************
; CPU_INT32U NetUtil_16BitSumDataCalcAlign_32 (void *pdata_32, @ ==> R0
; CPU_INT32U size) @ ==> R1
; @ sum ==> R2
NetUtil_16BitSumDataCalcAlign_32:
STMFD SP!, {R2-R12}
MOV R2, #0
B NetUtil_16BitSumDataCalcAlign_32_0
NetUtil_16BitSumDataCalcAlign_32_1:
LDMIA R0!, {R5-R12} ; Calc sum of sixteen 16-bit words ...
; ... using eight 32-bit CPU regs.
MOV R3, R5, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
MOV R3, R6, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
MOV R3, R7, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
MOV R3, R8, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
MOV R3, R9, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
MOV R3, R10, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
MOV R3, R11, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
MOV R3, R12, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
SUB R1, R1, #(4*8*1)
NetUtil_16BitSumDataCalcAlign_32_0:
CMP R1, #(4*8*1) ; end of loop
BCS NetUtil_16BitSumDataCalcAlign_32_1
B NetUtil_16BitSumDataCalcAlign_32_2
NetUtil_16BitSumDataCalcAlign_32_3:
LDMIA R0!, {R5} ; Calc sum of two 16-bit words ...
; ... using one 32-bit CPU reg.
MOV R3, R5, ROR #8
MOV R4, R3, LSL #16
ADD R2, R2, R4, LSR #16
ADD R2, R2, R3, LSR #16
SUB R1, R1, #(4*1*1)
NetUtil_16BitSumDataCalcAlign_32_2:
CMP R1, #(4*1*1) ; end of loop
BCS NetUtil_16BitSumDataCalcAlign_32_3
MOV R0, R2
LDMFD SP!, {R2-R12}
BX LR ; return
END
|
/**
* @author Jonathan Cardoso Machado
* @license MIT
* @copyright 2015-2016, Jonathan Cardoso Machado
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <iostream>
#include "Multi.h"
//85233 was allocated on Win64
#define MEMORY_PER_HANDLE 60000
namespace NodeLibcurl {
Nan::Persistent<v8::FunctionTemplate> Multi::constructor;
Multi::Multi()
{
// init uv timer to be used with HandleTimeout
this->timeout = deleted_unique_ptr<uv_timer_t>( new uv_timer_t, [&]( uv_timer_t *timerhandl ) {
uv_close( reinterpret_cast<uv_handle_t *>( timerhandl ), Multi::OnTimerClose );
});
int timerStatus = uv_timer_init( uv_default_loop(), this->timeout.get() );
assert( timerStatus == 0 && "Could not initialize libuv timer" );
this->timeout->data = this;
this->mh = curl_multi_init();
assert( this->mh && "Could not initialize libcurl multi handle." );
NODE_LIBCURL_ADJUST_MEM( MEMORY_PER_HANDLE );
// set curl_multi cb to use libuv
curl_multi_setopt( this->mh, CURLMOPT_SOCKETFUNCTION, Multi::HandleSocket );
curl_multi_setopt( this->mh, CURLMOPT_SOCKETDATA, this );
curl_multi_setopt( this->mh, CURLMOPT_TIMERFUNCTION, Multi::HandleTimeout );
curl_multi_setopt( this->mh, CURLMOPT_TIMERDATA, this );
}
Multi::~Multi()
{
if ( this->isOpen ) {
this->Dispose();
}
}
void Multi::Dispose()
{
assert( this->isOpen );
this->isOpen = false;
if ( this->mh ) {
CURLMcode code = curl_multi_cleanup( this->mh );
assert( code == CURLM_OK );
NODE_LIBCURL_ADJUST_MEM( -MEMORY_PER_HANDLE );
}
uv_timer_stop( this->timeout.get() );
}
//The curl_multi_socket_action(3) function informs the application about updates
// in the socket (file descriptor) status by doing none, one, or multiple calls to this function
int Multi::HandleSocket( CURL *easy, curl_socket_t s, int action, void *userp, void *socketp )
{
CurlSocketContext *ctx = nullptr;
Multi *obj = static_cast<Multi*>( userp );
if ( action == CURL_POLL_IN || action == CURL_POLL_OUT || action == CURL_POLL_INOUT || action == CURL_POLL_NONE ) {
//create ctx if it doesn't exists and assign it to the current socket,
if ( socketp ) {
ctx = static_cast<Multi::CurlSocketContext*>( socketp );
}
else {
ctx = Multi::CreateCurlSocketContext( s, obj );
curl_multi_assign( obj->mh, s, static_cast<void*>( ctx ) );
}
//set event based on the current action
int events = 0;
switch ( action ) {
case CURL_POLL_IN:
events |= UV_READABLE;
break;
case CURL_POLL_OUT:
events |= UV_WRITABLE;
break;
case CURL_POLL_INOUT:
events |= UV_READABLE | UV_WRITABLE;
break;
}
//start polling the socket.
return uv_poll_start( &ctx->pollHandle, events, Multi::OnSocket );
}
if ( action == CURL_POLL_REMOVE && socketp ) {
ctx = static_cast<CurlSocketContext*>( socketp );
uv_poll_stop( &ctx->pollHandle );
Multi::DestroyCurlSocketContext( ctx );
curl_multi_assign( obj->mh, s, NULL );
return 0;
}
return -1;
}
// This function will be called when the timeout value changes from libcurl.
// The timeout value is at what latest time the application should call one of
// the "performing" functions of the multi interface (curl_multi_socket_action and curl_multi_perform) - to allow libcurl to keep timeouts and retries etc to work.
int Multi::HandleTimeout( CURLM *multi, long timeoutMs, void *userp )
{
Multi *obj = static_cast<Multi*>( userp );
uv_timer_stop( obj->timeout.get() );
if ( timeoutMs > 0 ) {
uv_timer_start( obj->timeout.get(), Multi::OnTimeout, timeoutMs, 0 );
}
else {
//should we call one last time? (if timeoutMS == -1)
UV_CALL_TIMER_CB( Multi::OnTimeout, obj->timeout.get(), 0 );
}
return 0;
}
// called when there is activity in the socket.
void Multi::OnSocket( uv_poll_t* handle, int status, int events )
{
int flags = 0;
CURLMcode code;
if ( status < 0 ) flags = CURL_CSELECT_ERR;
if ( events & UV_READABLE ) flags |= CURL_CSELECT_IN;
if ( events & UV_WRITABLE ) flags |= CURL_CSELECT_OUT;
Multi::CurlSocketContext *ctx = static_cast<Multi::CurlSocketContext*>( handle->data );
//Before version 7.20.0: If you receive CURLM_CALL_MULTI_PERFORM, this basically means that you should call curl_multi_socket_action again
// before you wait for more actions on libcurl's sockets.
// You don't have to do it immediately, but the return code means that libcurl
// may have more data available to return or that there may be more data to send off before it is "satisfied".
do {
code = curl_multi_socket_action( ctx->multi->mh, ctx->sockfd, flags, &ctx->multi->runningHandles );
} while ( code == CURLM_CALL_MULTI_PERFORM );
if ( code != CURLM_OK ) {
std::string errorMsg;
errorMsg += std::string( "curl_multi_socket_action failed. Reason: " ) + curl_multi_strerror( code );
Nan::ThrowError( errorMsg.c_str() );
return;
}
ctx->multi->ProcessMessages();
}
// function called when the previous timeout set reaches 0
UV_TIMER_CB( Multi::OnTimeout )
{
Multi *obj = static_cast<Multi*>( timer->data );
CURLMcode code = curl_multi_socket_action( obj->mh, CURL_SOCKET_TIMEOUT, 0, &obj->runningHandles );
if ( code != CURLM_OK ) {
std::string errorMsg;
errorMsg += std::string( "curl_multi_socket_action failed. Reason: " ) + curl_multi_strerror( code );
Nan::ThrowError( errorMsg.c_str() );
return;
}
obj->ProcessMessages();
}
void Multi::OnTimerClose( uv_handle_t *handle )
{
delete handle;
}
void Multi::ProcessMessages()
{
CURLMsg *msg = NULL;
int pending = 0;
while ( ( msg = curl_multi_info_read( this->mh, &pending ) ) ) {
if ( msg->msg == CURLMSG_DONE ) {
CURLcode statusCode = msg->data.result;
this->CallOnMessageCallback( msg->easy_handle, statusCode );
}
}
}
// Creates a Context to be used to store data between events
Multi::CurlSocketContext* Multi::CreateCurlSocketContext( curl_socket_t sockfd, Multi *multi )
{
int r;
Multi::CurlSocketContext *ctx = NULL;
ctx = static_cast<Multi::CurlSocketContext*>( malloc( sizeof( *ctx ) ) );
assert( ctx && "Not enough memory to allocate a new Multi::CurlSocketContext." );
ctx->sockfd = sockfd;
ctx->multi = multi;
// uv_poll simply watches file descriptors using the operating system notification mechanism
// whenever the OS notices a change of state in file descriptors being polled, libuv will invoke the associated callback.
r = uv_poll_init_socket( uv_default_loop(), &ctx->pollHandle, sockfd );
assert( r == 0 );
ctx->pollHandle.data = ctx;
return ctx;
}
// called when libcurl thinks the socket can be destroyed
void Multi::DestroyCurlSocketContext( Multi::CurlSocketContext* ctx )
{
uv_handle_t *handle = (uv_handle_t*) &ctx->pollHandle;
uv_close( handle, Multi::OnSocketClose );
}
void Multi::OnSocketClose( uv_handle_t *handle )
{
Multi::CurlSocketContext *ctx = static_cast<Multi::CurlSocketContext*>( handle->data );
free( ctx );
}
void Multi::CallOnMessageCallback( CURL *easy, CURLcode statusCode )
{
Nan::HandleScope scope;
// we don't have an on message callback, just return.
if ( this->cbOnMessage == nullptr ) {
return;
}
// From https://curl.haxx.se/libcurl/c/CURLINFO_PRIVATE.html
// > Please note that for internal reasons, the value is returned as a char pointer, although effectively being a 'void *'.
char *ptr = nullptr;
CURLcode code = curl_easy_getinfo( easy, CURLINFO_PRIVATE, &ptr );
assert( ptr != nullptr && "Invalid handle returned from CURLINFO_PRIVATE." );
Easy *obj = reinterpret_cast<Easy *>( ptr );
if ( code != CURLE_OK ) {
Nan::ThrowError( "Error retrieving current handle instance." );
return;
}
v8::Local<v8::Object> easyArg = obj->handle();
v8::Local<v8::Value> err = Nan::Null();
v8::Local<v8::Int32> errCode = Nan::New( static_cast<int32_t>( statusCode ) );
if ( statusCode != CURLE_OK ) {
err = Nan::Error( curl_easy_strerror( statusCode ) );
}
v8::Local<v8::Value> argv[] = { err, easyArg, errCode };
this->cbOnMessage->Call( this->handle(), 3, argv );
}
// Add Curl constructor to the module exports
NODE_LIBCURL_MODULE_INIT( Multi::Initialize )
{
Nan::HandleScope scope;
// Multi js "class" function template initialization
v8::Local<v8::FunctionTemplate> tmpl = Nan::New<v8::FunctionTemplate>( Multi::New );
tmpl->SetClassName( Nan::New( "Multi" ).ToLocalChecked() );
tmpl->InstanceTemplate()->SetInternalFieldCount( 1 );
// prototype methods
Nan::SetPrototypeMethod( tmpl, "setOpt", Multi::SetOpt );
Nan::SetPrototypeMethod( tmpl, "addHandle", Multi::AddHandle );
Nan::SetPrototypeMethod( tmpl, "onMessage", Multi::OnMessage );
Nan::SetPrototypeMethod( tmpl, "removeHandle", Multi::RemoveHandle );
Nan::SetPrototypeMethod( tmpl, "getCount", Multi::GetCount );
Nan::SetPrototypeMethod( tmpl, "close", Multi::Close );
// static methods
Nan::SetMethod( tmpl, "strError", Multi::StrError );
Multi::constructor.Reset( tmpl );
Nan::Set( exports, Nan::New( "Multi" ).ToLocalChecked(), tmpl->GetFunction() );
}
NAN_METHOD( Multi::New )
{
if ( !info.IsConstructCall() ) {
Nan::ThrowError( "You must use \"new\" to instantiate this object." );
}
Multi *obj = new Multi();
obj->Wrap( info.This() );
info.GetReturnValue().Set( info.This() );
}
NAN_METHOD( Multi::SetOpt )
{
Nan::HandleScope scope;
Multi *obj = Nan::ObjectWrap::Unwrap<Multi>( info.This() );
if ( !obj->isOpen ) {
Nan::ThrowError( "Multi handle is closed." );
return;
}
v8::Local<v8::Value> opt = info[0];
v8::Local<v8::Value> value = info[1];
CURLMcode setOptRetCode = CURLM_UNKNOWN_OPTION;
int optionId;
// array of strings option
if ( ( optionId = IsInsideCurlConstantStruct( curlMultiOptionNotImplemented, opt ) ) ) {
Nan::ThrowError( "Unsupported option, probably because it's too complex to implement using javascript or unecessary when using javascript." );
return;
}
else if ( ( optionId = IsInsideCurlConstantStruct( curlMultiOptionStringArray, opt ) ) ) {
if ( value->IsNull() ) {
setOptRetCode = curl_multi_setopt( obj->mh, static_cast<CURLMoption>( optionId ), NULL );
}
else {
if ( !value->IsArray() ) {
Nan::ThrowTypeError( "Option value must be an Array." );
return;
}
v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast( value );
uint32_t arrayLength = array->Length();
std::vector<char*> strings;
for ( uint32_t i = 0; i < arrayLength; ++i )
{
strings.push_back( *Nan::Utf8String( array->Get( i ) ) );
}
strings.push_back( NULL );
setOptRetCode = curl_multi_setopt( obj->mh, static_cast<CURLMoption>( optionId ), &strings[0] );
}
} //check if option is integer, and the value is correct
else if ( ( optionId = IsInsideCurlConstantStruct( curlMultiOptionInteger, opt ) ) ) {
int32_t val = value->Int32Value();
//If not an integer, get the boolean value of it.
if ( !value->IsInt32() ) {
val = value->BooleanValue();
}
setOptRetCode = curl_multi_setopt( obj->mh, static_cast<CURLMoption>( optionId ), val );
}
info.GetReturnValue().Set( setOptRetCode );
}
NAN_METHOD( Multi::OnMessage )
{
Nan::HandleScope scope;
Multi *obj = Nan::ObjectWrap::Unwrap<Multi>( info.This() );
if ( !info.Length() ) {
Nan::ThrowError( "You must specify the callback function. If you want to remove the current one you can pass null." );
return;
}
v8::Local<v8::Value> arg = info[0];
bool isNull = arg->IsNull();
if ( !arg->IsFunction() && !isNull ) {
Nan::ThrowTypeError( "Argument must be a Function. If you want to remove the current one you can pass null." );
return;
}
if ( isNull ) {
obj->cbOnMessage = nullptr;
}
else {
v8::Local<v8::Function> callback = arg.As<v8::Function>();
obj->cbOnMessage.reset( new Nan::Callback( callback ) );
}
info.GetReturnValue().Set( info.This() );
}
NAN_METHOD( Multi::AddHandle )
{
Nan::HandleScope scope;
Multi *obj = Nan::ObjectWrap::Unwrap<Multi>( info.This() );
if ( !obj->isOpen ) {
Nan::ThrowError( "Multi handle is closed." );
return;
}
v8::Local<v8::Value> handle = info[0];
if ( !handle->IsObject() || !Nan::New( Easy::constructor )->HasInstance( handle ) ) {
Nan::ThrowError( Nan::TypeError( "Argument must be an instance of an Easy handle." ) );
return;
}
else {
Easy *easy = Nan::ObjectWrap::Unwrap<Easy>( handle.As<v8::Object>() );
if ( !easy->isOpen ) {
Nan::ThrowError( "Cannot add an Easy handle that is closed." );
return;
}
CURLMcode code = curl_multi_add_handle( obj->mh, easy->ch );
if ( code != CURLM_OK ) {
Nan::ThrowError( Nan::TypeError( "Could not add easy handle to the multi handle." ) );
return;
}
++obj->amountOfHandles;
easy->isInsideMultiHandle = true;
v8::Local<v8::Int32> ret = Nan::New( static_cast<int32_t>( code ) );
info.GetReturnValue().Set( ret );
}
}
NAN_METHOD( Multi::RemoveHandle )
{
Nan::HandleScope scope;
Multi *obj = Nan::ObjectWrap::Unwrap<Multi>( info.This() );
if ( !obj->isOpen ) {
Nan::ThrowError( "Multi handle is closed." );
return;
}
v8::Local<v8::Value> handle = info[0];
if ( !handle->IsObject() || !Nan::New( Easy::constructor )->HasInstance( handle ) ) {
Nan::ThrowError( Nan::TypeError( "Argument must be an instance of an Easy handle." ) );
return;
}
else {
Easy *easy = Nan::ObjectWrap::Unwrap<Easy>( handle.As<v8::Object>() );
CURLMcode code = curl_multi_remove_handle( obj->mh, easy->ch );
if ( code != CURLM_OK ) {
Nan::ThrowError( Nan::TypeError( "Could not remove easy handle from multi handle." ) );
return;
}
--obj->amountOfHandles;
easy->isInsideMultiHandle = false;
v8::Local<v8::Int32> ret = Nan::New( static_cast<int32_t>( code ) );
info.GetReturnValue().Set( ret );
}
}
NAN_METHOD( Multi::GetCount )
{
Nan::HandleScope scope;
Multi *obj = Nan::ObjectWrap::Unwrap<Multi>( info.This() );
v8::Local<v8::Uint32> ret = Nan::New( static_cast<uint32_t>( obj->amountOfHandles ) );
info.GetReturnValue().Set( ret );
}
NAN_METHOD( Multi::Close )
{
Nan::HandleScope scope;
Multi *obj = Nan::ObjectWrap::Unwrap<Multi>( info.This() );
if ( !obj->isOpen ) {
Nan::ThrowError( "Multi handle already closed." );
return;
}
obj->Dispose();
}
NAN_METHOD( Multi::StrError )
{
Nan::HandleScope scope;
v8::Local<v8::Value> errCode = info[0];
if ( !errCode->IsInt32() ) {
Nan::ThrowTypeError( "Invalid errCode passed to Multi.strError." );
return;
}
const char * errorMsg = curl_multi_strerror( static_cast<CURLMcode>( errCode->Int32Value() ) );
v8::Local<v8::String> ret = Nan::New( errorMsg ).ToLocalChecked();
info.GetReturnValue().Set( ret );
}
}
|
.include "header.asm"
.include "snes.asm"
.include "MC_libks.asm"
Main:
SNES_INIT0
rep #$10 ;16 bit xy
sep #$20 ; 8 bit a
SNES_INIDISP $8F
SNES_NMITIMEN $00
jsl LKS_Clear_RAM
SNES_INIT
Start:
jsl LKS_INIT
LKS_Clear_VRAM
SNES_DMAX $01
SNES_DMAX_BADD $18
;load font
LKS_LOAD_VRAM $4000,$00,bpp_font,$400
LKS_LOAD_CG $00,bpp_fontpal,$10
;load Sprite pal
LKS_LOAD_CG $80,Player_pal,$20
;Sprite Engine
ldx #$20*0 ; Sprite n'0
LKS_SPRITE_INIT 40,40,0,$00,$AA,64 ; X,Y,Tile,Flip+PAL,Ext,OAM
LKS_SPRITE_ANIM_INIT $18,0,9,4 ; Size,act,cadence,n
LKS_DMA_INIT Player,$100,128,$6000,1 ;Data,Size,largeur,VRAM,Func DMA
jsl LKS_GAMELOOP_INIT
Game:
jsl LKS_Fade_in
SNES_DMAX $00
SNES_DMAX_BADD $80
jsl LKS_Joypad ; Read Joypad
jsl LKS_OAM_Clear ; Clear Sprite
;-------------
ldy #$20*0 ; Target Sprite n'0
lda #0
sta LKS_SPRITE.VX+0,y
sta LKS_SPRITE.VX+1,y
sta LKS_SPRITE.VY+0,y
sta LKS_SPRITE.VY+1,y
lda LKS_STDCTRL+_UP
cmp #2
bne +
rep #$20
lda #-1<<2
sta LKS_SPRITE.VY,y
sep #$20
+:
lda LKS_STDCTRL+_DOWN
cmp #2
bne +
rep #$20
lda #1<<2
sta LKS_SPRITE.VY,y
sep #$20
+:
lda LKS_STDCTRL+_RIGHT
cmp #2
bne +
rep #$20
lda #1<<2
sta LKS_SPRITE.VX,y
sep #$20
+:
lda LKS_STDCTRL+_LEFT
cmp #2
bne +
rep #$20
lda #-1<<2
sta LKS_SPRITE.VX,y
sep #$20
+:
jsl LKS_Sprite_Move ;For move Sprite
jsr Draw_Sprite_Anim
jsr Draw_text
;-------------
jsl LKS_DMA_SORT ; prepares DMA transfer and sorting
jsl WaitVBlank
jmp Game
;2)
Draw_Sprite_Anim:
jsl LKS_Sprite_Draw_32x32_2x2 ;meta sprite
jsl LKS_Sprite_Anim ;animation sprite
jsl LKS_Sprite_DMA ;Enable DMA for sprite
rts
;1)
Draw_text:
LKS_printf_setpal 0 ; select pal 0
ldx #text_s1 ;address text
LKS_printfs 1,1 ; x,y
LKS_printf_setpal 1 ; select pal 0
ldx #text_s1 ;address text
LKS_printfs 1,2 ;x,y
rts
text_s1:
.db "hello world",0
.include "libksIRQ.asm"
.bank 1 slot 0
.org 0
.include "libks.asm"
.bank 2 slot 0
.org 0
Player:
.incbin "DATA/Player.spr"
Player_pal:
.incbin "DATA/Player.pal"
|
<%
from pwnlib.shellcraft import pretty, value, common, registers
from pwnlib.shellcraft.i386 import mov, pushstr, setregs
from pwnlib import constants
%>
<%docstring>
Calculate the length of the specified string.
Arguments:
string(str): Register or address with the string
reg(str): Named register to return the value in,
ecx is the default.
Example:
>>> sc = 'jmp get_str\n'
>>> sc += 'pop_str: pop eax\n'
>>> sc += shellcraft.i386.strlen('eax')
>>> sc += 'push ecx;'
>>> sc += shellcraft.i386.linux.write(1, 'esp', 4)
>>> sc += shellcraft.i386.linux.exit(0)
>>> sc += 'get_str: call pop_str\n'
>>> sc += '.asciz "Hello, world\\n"'
>>> run_assembly(sc).unpack() == len('Hello, world\n')
True
</%docstring>
<%page args="string, reg='ecx'"/>
${setregs({'ecx': -1,
'edi': string,
'eax': 0})}
repnz scas al, BYTE PTR [edi]
inc ecx
inc ecx
neg ecx
${mov(reg, 'ecx')}
|
dnl Pentium-4 mpn_copyd -- copy limb vector, decrementing.
dnl
dnl Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
dnl
dnl This file is part of the GNU MP Library.
dnl
dnl The GNU MP Library is free software; you can redistribute it and/or
dnl modify it under the terms of the GNU Lesser General Public License as
dnl published by the Free Software Foundation; either version 3 of the
dnl License, or (at your option) any later version.
dnl
dnl The GNU MP Library is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
dnl Lesser General Public License for more details.
dnl
dnl You should have received a copy of the GNU Lesser General Public License
dnl along with the GNU MP Library. If not, see http://www.gnu.org/licenses/.
dnl The std/rep/movsl/cld is very slow for small blocks on pentium4. Its
dnl startup time seems to be about 165 cycles. It then needs 2.6 c/l.
dnl We therefore use an open-coded 2 c/l copying loop.
dnl Ultimately, we may want to use 64-bit movq or 128-bit movdqu in some
dnl nifty unrolled arrangement. Clearly, that could reach much higher
dnl speeds, at least for large blocks.
include(`../config.m4')
defframe(PARAM_SIZE, 12)
defframe(PARAM_SRC, 8)
defframe(PARAM_DST, 4)
TEXT
ALIGN(8)
PROLOGUE(mpn_copyd)
deflit(`FRAME',0)
movl PARAM_SIZE, %ecx
movl PARAM_SRC, %eax
movl PARAM_DST, %edx
movl %ebx, PARAM_SIZE
addl $-1, %ecx
js L(end)
L(loop):
movl (%eax,%ecx,4), %ebx
movl %ebx, (%edx,%ecx,4)
addl $-1, %ecx
jns L(loop)
L(end):
movl PARAM_SIZE, %ebx
ret
EPILOGUE()
|
; A130205: a(n) = n^2 - a(n-1) - a(n-2), with a(1) = 1 and a(2) = 2.
; 1,2,6,8,11,17,21,26,34,40,47,57,65,74,86,96,107,121,133,146,162,176,191,209,225,242,262,280,299,321,341,362,386,408,431,457,481,506,534,560,587,617,645,674,706,736,767,801,833,866,902,936,971,1009,1045,1082
add $0,2
mov $1,2
lpb $0
trn $0,2
add $1,$0
trn $0,1
add $1,2
add $1,$0
lpe
sub $1,3
|
; A122188: Triangle read by rows, formed from the coefficients of characteristic polynomials of the following sequence of matrices: 2 X 2 {{0, 1}, {1, 1}}, 3 X 3 {{0, 1, 0}, {0, 0, 1}, {1, 1, 1}}, 4 X 4 {{0, 1,0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}, {1, 1, 1, 1}}, 5 X 5 {{0, 1, 0, 0, 0}, {0, 0, 1, 0, 0}, {0, 0, 0, 1, 0}, {0, 0, 0, 0, 1}, {1, 1, 1, 1, 1}}, ...
; 1,1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1,-1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
mov $1,1
lpb $0,1
add $1,1
trn $0,$1
sub $0,1
lpe
add $2,$1
mov $1,1
sub $1,$2
mod $1,2
mul $1,2
add $1,1
|
#include "connectiondb.h"
#include <QDebug>
#include <QtSql/QSqlDatabase>
#include <QtSql/QSqlDriver>
#include <QtSql/QtSql>
ConnectionDB::ConnectionDB(QObject *parent) : QObject(parent)
{
}
bool ConnectionDB::createConnectionMYSQLite(QString path)
{
QSqlDatabase dbsqlite = QSqlDatabase::addDatabase("QSQLITE", "dbsqlite");
dbsqlite.setDatabaseName(path);
qDebug() << dbsqlite.drivers();
if (!dbsqlite.open()) {
qDebug() << "Cannot open database: " << dbsqlite.lastError();
return false;
}
return true;
}
|
; A102566: a(n) = {minimal k such that f^k(prime(n)) = 1} where f(m) = (m+1)/2^r, 2^r is the highest power of two dividing m+1.
; 2,1,2,1,2,2,4,3,2,2,1,4,4,3,2,3,2,2,5,4,5,3,4,4,5,4,3,3,3,4,1,6,6,5,5,4,4,5,4,4,4,4,2,6,5,4,4,2,4,4,4,2,4,2,8,6,6,5,6,6,5,6,5,4,5,4,5,6,4,4,6,4,3,4,3,2,6,5,6,5,5,5,3,5,3,3,6,5,4,3,4,2,3,3,3,2,2,8,7,6
seq $0,40 ; The prime numbers.
seq $0,80791 ; Number of nonleading 0's in binary expansion of n.
add $0,1
|
#include <iostream>
#include <iomanip>
#include <boost/python.hpp>
#include "../../def_submodule.hpp"
#include "../../../../../render/engine.hpp"
#include "../../../../../type/picture/memory.hpp"
namespace
{
typedef GS_DDMRM::S_IceRay::S_render::GC_engine GFs_engine;
typedef GS_DDMRM::S_IceRay::S_type::S_picture::GC__pure GTs_picture;
bool start( GFs_engine & P_engine, GTs_picture * P_picture )
{
std::cout << std::endl;
P_engine.F_do( *P_picture );
return true;
}
}
void expose_IceRay_render_Engine()
{
//MAKE_SUBMODULE( IceRay );
MAKE_SUBMODULE( core );
MAKE_SUBMODULE( render );
typedef GS_DDMRM::S_IceRay::S_render::S_scanner::GC__pure Tf_scanner;
typedef GS_DDMRM::S_IceRay::S_render::S_pixel::GC__pure Tf_pixel;
typedef GS_DDMRM::S_IceRay::S_render::S_pierce::GC__pure Tf_pierce;
typedef GS_DDMRM::S_IceRay::S_render::S_sheaf::GC__pure Tf_sheaf;
typedef GS_DDMRM::S_IceRay::S_render::S_ray::GC__pure Tf_ray;
void (GFs_engine::*I_setScanner)( Tf_scanner * ) = &GFs_engine::F_scanner;
void (GFs_engine::*I_setPixel )( Tf_pixel * ) = &GFs_engine::F_pixel;
void (GFs_engine::*I_setPierce )( Tf_pierce * ) = &GFs_engine::F_pierce;
void (GFs_engine::*I_setSheaf )( Tf_sheaf * ) = &GFs_engine::F_sheaf;
void (GFs_engine::*I_setRay )( Tf_ray * ) = &GFs_engine::F_ray;
boost::python::class_<GFs_engine>( "RenderEngine" )
.def( boost::python::init<>() )
.def( "start", &start )
.def( "work", &GFs_engine::F_work )
.def( "stop", &GFs_engine::F_stop )
.def( "progress", &GFs_engine::F_progress )
//.def( "join", &GFs_engine::F_join )
.def( "scanner", I_setScanner )
.def( "pixel", I_setPixel )
.def( "pierce", I_setPierce )
.def( "sheaf", I_setSheaf )
.def( "ray", I_setRay )
;
}
|
Name: zel_rmdt9.asm
Type: file
Size: 377096
Last-Modified: '2016-05-13T04:25:37Z'
SHA-1: CDE2EE3B0E0F9C708EB2519C46DDBE34CB451E76
Description: null
|
; A122658: a(n) = if n mod 2 = 1 then n^3*(n-1)^2/2 else n^5/2.
; 0,0,16,54,512,1000,3888,6174,16384,23328,50000,66550,124416,158184,268912,330750,524288,628864,944784,1111158,1600000,1852200,2576816,2944414,3981312,4500000,5940688,6652854,8605184,9560488,12150000,13405950,16777216,18399744
mov $2,$0
div $0,-2
pow $2,3
mul $2,$0
mul $0,$2
mul $0,2
|
/*
Provided to you by Emlid Ltd (c) 2015.
twitter.com/emlidtech || www.emlid.com || info@emlid.com
Example: Read accelerometer, gyroscope and magnetometer values from
inertial measurement unit: MPU9250 or LSM9DS1 over SPI on Raspberry Pi + Navio.
Navio's onboard sensors are connected to the SPI bus on Raspberry Pi
and can be read through /dev/spidev0.1 (MPU9250), /dev/spidev0.3 (acc/gyro LSM9DS1)
and /dev/spidev0.2 (mag LSM9DS1).
To run this example navigate to the directory containing it and run following commands:
make
./AccelGyroMag -i [sensor name]
Sensors names: mpu is MPU9250, lsm is LSM9DS1.
For print help:
./AccelGyroMag -h
*/
#include <Navio2/Led_Navio2.h>
//#include <Common/Ublox.h>
#include <Common/MS5611.h>
#include <string>
#include <stdio.h>
#include <memory>
#include <stdint.h>
#include <unistd.h>
#include <sys/time.h>
#include <Common/MPU9250.h>
#include <Navio2/LSM9DS1.h>
#include <Common/Util.h>
#include <pthread.h>
#include <iostream>
#include <vector>
#include <mutex>
// std::cout
// std::thread, std::this_thread::sleep_for
#define G_SI 9.80665
#define PI 3.14159
float ax, ay, az;
float gx, gy, gz;
float mx, my, mz;
float ax2, ay2, az2;
float gx2, gy2, gz2;
float mx2, my2, mz2;
struct timeval baro1,baro2,mpu1,mpu2,lsm1,lsm2,led1,led2,tot1,tot2;
float dt;
unsigned long int dtlong=0,auxCount=0,count=0,dtMPU=0,dtLSM=0,dtLED=0,dtBaro=0,dtTot=0,countMax=5000;
//std::mutex mtxBaro,mtxMPU,mtxLSM,mtxLed;
float temperatura,pressao;
std::vector<int> baroData;
std::vector<int> mpuData;
std::vector<int> lsmData;
std::vector<int> ledData;
std::vector<int> totData;
using namespace std;
std::unique_ptr <Led> get_led()
{
auto ptr = std::unique_ptr <Led>{ new Led_Navio2() };
return ptr;
}
void * acquireBarometerData(void * barom)
{
//unsigned long int previoustime=0, currenttime=0;
unsigned long int baroCount=0;
MS5611* barometer = (MS5611*)barom;
while (count<countMax) {
mtxBaro.lock();
baroCount++;
gettimeofday(&baro1,NULL);
barometer->refreshPressure();
usleep(10000); // Waiting for pressure data ready
barometer->readPressure();
barometer->refreshTemperature();
usleep(10000); // Waiting for temperature data ready
barometer->readTemperature();
barometer->calculatePressureAndTemperature();
temperatura=barometer->getTemperature();
pressao=barometer->getPressure();
gettimeofday(&baro2,NULL);
dtBaro=(1000000 * baro2.tv_sec + baro2.tv_usec)-1000000 * baro1.tv_sec - baro1.tv_usec-20000;
baroData.push_back(dtBaro);
//usleep(5000);
}
pthread_exit(NULL);
}
void * acquireMPUData(void * imuMPU)
{
unsigned long int mpuCount=0;
MPU9250* mpu=(MPU9250*)imuMPU;
while(count<countMax){
mtxMPU.lock();
mpuCount++;
gettimeofday(&mpu1,NULL);
mpu->update();
mpu->read_accelerometer(&ax, &ay, &az);
mpu->read_gyroscope(&gx, &gy, &gz);
mpu->read_magnetometer(&mx, &my, &mz);
gettimeofday(&mpu2,NULL);
dtMPU=(1000000 * mpu2.tv_sec + mpu2.tv_usec)-1000000 * mpu1.tv_sec - mpu1.tv_usec ;
mpuData.push_back(dtMPU);
usleep(5000);
}
pthread_exit(NULL);
}
void * acquireLSMData(void * imuLSM)
{
unsigned long int lsmCount=0;
LSM9DS1* lsm=(LSM9DS1*)imuLSM;
while(count<countMax){
mtxLSM.lock();
lsmCount++;
gettimeofday(&lsm1,NULL);
lsm->update();
lsm->read_accelerometer(&ax2, &ay2, &az2);
lsm->read_gyroscope(&gx2, &gy2, &gz2);
lsm->read_magnetometer(&mx2, &my2, &mz2);
gettimeofday(&lsm2,NULL);
dtLSM=(1000000 * lsm2.tv_sec + lsm2.tv_usec)-1000000 * lsm1.tv_sec - lsm1.tv_usec ;
lsmData.push_back(dtLSM);
usleep(5000);
}
pthread_exit(NULL);
}
void * acquireLedData(void * led)
{
unsigned long int ledCount=0;
Led_Navio2* diode=(Led_Navio2*)led;
while(count<countMax){
mtxLed.lock();
ledCount++;
gettimeofday(&led1,NULL);
if((ledCount%2)==0){
diode->setColor(Colors::Red);
}
else{
diode->setColor(Colors::Green);
}
gettimeofday(&led2,NULL);
dtLED=(1000000 * led2.tv_sec + led2.tv_usec)-1000000 * led1.tv_sec - led1.tv_usec ;
ledData.push_back(dtLED);
usleep(500000);
}
pthread_exit(NULL);
}
std::unique_ptr <InertialSensor> get_inertial_sensor( std::string sensor_name)
{
if (sensor_name == "mpu") {
printf("Selected: MPU9250\n");
auto ptr = std::unique_ptr <InertialSensor>{ new MPU9250() };
return ptr;
}
else if (sensor_name == "lsm") {
printf("Selected: LSM9DS1\n");
auto ptr = std::unique_ptr <InertialSensor>{ new LSM9DS1() };
return ptr;
}
else {
return NULL;
}
}
void print_help()
{
printf("Possible parameters:\nSensor selection: -i [sensor name]\n");
printf("Sensors names: mpu is MPU9250, lsm is LSM9DS1\nFor help: -h\n");
}
std::string get_sensor_name(int argc, char *argv[])
{
if (get_navio_version() == NAVIO2) {
if (argc < 2) {
printf("Enter parameter\n");
print_help();
return std::string();
}
// prevent the error message
opterr = 0;
int parameter;
while ((parameter = getopt(argc, argv, "i:h")) != -1) {
switch (parameter) {
case 'i': if (!strcmp(optarg,"mpu") ) return "mpu";
else return "lsm";
case 'h': print_help(); return "-1";
case '?': printf("Wrong parameter.\n");
print_help();
return std::string();
}
}
} else { //sensor on NAVIO+
return "mpu";
}
}
//=============================================================================
int main(int argc, char *argv[])
{
unsigned long int min=0,max=0,mem=0,media=0,sum=0;
if (check_apm()) {
return 1;
}
Led_Navio2 led;
MS5611 baro;
MPU9250 imuMPU;
LSM9DS1 imuLSM;
pthread_t baro_thread;
pthread_t MPU_thread;
pthread_t LSM_thread;
pthread_t led_thread;
mtxBaro.lock();
mtxMPU.lock();
mtxLSM.lock();
mtxLed.lock();
baro.initialize();
if(pthread_create(&baro_thread, NULL, acquireBarometerData, (void *)&baro))
{
printf("Error: Failed to create barometer thread\n");
return 0;
}
imuLSM.initialize();
if(pthread_create(&LSM_thread, NULL, acquireLSMData, (void *)&imuLSM))
{
printf("Error: Failed to create lsm thread\n");
return 0;
}
imuMPU.initialize();
if(pthread_create(&MPU_thread, NULL, acquireMPUData, (void *)&imuMPU))
{
printf("Error: Failed to create mpu thread\n");
return 0;
}
led.initialize();
if(pthread_create(&led_thread, NULL, acquireLedData, (void *)&led))
{
printf("Error: Failed to create led thread\n");
return 0;
}
while(count<countMax) {
count++;
mtxBaro.unlock();
mtxMPU.unlock();
mtxLSM.unlock();
mtxLed.unlock();
gettimeofday(&tot1,NULL);
while((swMPU & swLSM & swLed)!=1){
}
gettimeofday(&tot2,NULL);
dtTot=(1000000 * tot2.tv_sec + tot2.tv_usec)-1000000 * tot1.tv_sec - tot1.tv_usec ;
//----------------Obtencao do tempo antes da leitura dos sensores---------------------------------//
//----------------Escrita no PWM ---------------------------------//
//----------------Leitura da IMU MPU ---------------------------------//
//----------------Leitura da IMU LSM---------------------------------//
//----------------Leitura do barometro ---------------------------------//
//----------------Obtencao do tempo apos leitura dos dados ---------------------------------//
//dtTot= dtMPU + dtLSM + dtLED;
totData.push_back(dtTot);
if(count==1){
min=dtTot;
max=dtTot;
media=dtTot;
sum=dtTot;
}
else{
sum=sum+dtTot;
media=sum/(count);
if(dtTot<min){
min=dtTot;
}
if(dtTot>max){
max=dtTot;
}
}
//printf("Numero da leitura: %lu \n", count);
//printf("Duracao media em microsegundos da leitura dos sensores: %lu \n", media);
//printf("Duracao atual em microsegundos da leitura dos sensores: %lu \n", dtTot);
/*if(count==1){
FILE *f = fopen("dtTot.txt", "w");
fprintf(f, "count;dtTot\n");
fprintf(f, "%d;%lu\n",count,dtTot);
fclose(f);
}
else if(count>1){
FILE *f = fopen("dtTot.txt", "a");
fprintf(f, "%d;%lu\n",count,dtTot);
fclose(f);
}*/
usleep(10000);
}
FILE *fBaro = fopen("barometer.txt", "w");
fprintf(fBaro, "count;dtBaro\n");
fclose(fBaro);
for (std::vector<int>::iterator it = baroData.begin() ; it != baroData.end(); ++it){
auxCount++;
FILE *fBaro = fopen("barometer.txt", "a");
fprintf(fBaro, "%d;%lu\n",auxCount,*it);
fclose(fBaro);
}
auxCount=0;
FILE *fMPU = fopen("mpu.txt", "w");
fprintf(fMPU, "count;dtMPU\n");
fclose(fMPU);
for (std::vector<int>::iterator it = mpuData.begin() ; it != mpuData.end(); ++it){
auxCount++;
FILE *fMPU = fopen("mpu.txt", "a");
fprintf(fMPU, "%d;%lu\n",auxCount,*it);
fclose(fMPU);
}
auxCount=0;
FILE *fLSM = fopen("lsm.txt", "w");
fprintf(fLSM, "count;dtLSM\n");
fclose(fLSM);
for (std::vector<int>::iterator it = lsmData.begin() ; it != lsmData.end(); ++it){
auxCount++;
FILE *fLSM = fopen("lsm.txt", "a");
fprintf(fLSM, "%d;%lu\n",auxCount,*it);
fclose(fLSM);
}
auxCount=0;
FILE *fLed = fopen("led.txt", "w");
fprintf(fLed, "count;dtLed\n");
fclose(fLed);
for (std::vector<int>::iterator it = ledData.begin() ; it != ledData.end(); ++it){
auxCount++;
FILE *fLed = fopen("led.txt", "a");
fprintf(fLed, "%d;%lu\n",auxCount,*it);
fclose(fLed);
}
auxCount=0;
FILE *fTot = fopen("dtTot.txt", "w");
fprintf(fTot, "count;dtTot\n");
fclose(fTot);
for (std::vector<int>::iterator it = totData.begin() ; it != totData.end(); ++it){
auxCount++;
FILE *fTot = fopen("dtTot.txt", "a");
fprintf(fTot, "%d;%lu\n",auxCount,*it);
fclose(fTot);
}
printf("--------------------------------------------------------------------------------------------------\n");
printf("Numero da leitura: %lu \n", count);
//printf("Duracao minima microsegundos da leitura dos sensores: %lu \n", min);
printf("Duracao em microsegundos da leitura atual do barometro: %lu \n", dtBaro);
printf("Duracao em microsegundos da leitura atual da IMU MPU: %lu \n", dtMPU);
printf("Duracao em microsegundos da leitura atual da IMU LSM: %lu \n", dtLSM);
printf("Duracao em microsegundos da escrita PWM no LED: %lu \n", dtLED);
printf("Duracao em microsegundos da leitura atual MPU LSM e escrita LED: %lu \n", dtlong);
printf("Duracao media em microsegundos da leitura dos sensores: %lu \n", media);
printf("Duracao minima microsegundos da leitura dos sensores: %lu \n", min);
printf("Duracao maxima microsegundos da leitura dos sensores: %lu \n", max);
time_t rawtime;
struct tm * timeinfo;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
printf ( "Data e tempo local atual: %s", asctime (timeinfo) );
printf("-----------------------------------Leitura da IMU MPU9250-----------------------------------------");
printf("\n\nAcc: %+7.3f %+7.3f %+7.3f ", ax, ay, az);
printf("Gyr: %+8.3f %+8.3f %+8.3f ", gx, gy, gz);
printf("Mag: %+7.3f %+7.3f %+7.3f\n", mx, my, mz);
printf("-----------------------------------Leitura da IMU LSM9DS1-----------------------------------------");
printf("\n\nAcc: %+7.3f %+7.3f %+7.3f ", ax2, ay2, az2);
printf("Gyr: %+8.3f %+8.3f %+8.3f ", gx2, gy2, gz2);
printf("Mag: %+7.3f %+7.3f %+7.3f\n", mx2, my2, mz2);
printf("-----------------------------------Leitura do barometro-------------------------------------------");
printf("\nTemperatura(C): %f Pressao (milibar): %f\n",
temperatura, pressao);
pthread_exit(NULL);
pthread_exit(NULL);
pthread_exit(NULL);
pthread_exit(NULL);
return 0;
}
|
#include "PAnimationWidget.h"
#include "PSimulationThread.h"
#include <QGridLayout>
#include <QPushButton>
#include <QSpinBox>
#include <QLineEdit>
#include <QSlider>
#include <QScrollBar>
#include <QIntValidator>
namespace dyno
{
PAnimationWidget::PAnimationWidget(QWidget *parent) :
QWidget(parent),
m_startSim(nullptr),
m_resetSim(nullptr)
{
QHBoxLayout* layout = new QHBoxLayout();
setLayout(layout);
QGridLayout* frameLayout = new QGridLayout();
QLineEdit* startFrame = new QLineEdit();
QLineEdit* endFrame = new QLineEdit();
m_start_spinbox = new QSpinBox();
m_start_spinbox->setFixedSize(60, 25);
m_start_spinbox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
m_end_spinbox = new QSpinBox();
m_end_spinbox->setFixedSize(60, 25);
m_end_spinbox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
m_end_spinbox->setMaximum(99999);
m_end_spinbox->setValue(999);
m_sim_scrollbar = new QScrollBar(Qt::Horizontal, this);
m_sim_scrollbar->setFixedHeight(25);
m_sim_scrollbar->setPageStep(999);
frameLayout->addWidget(m_start_spinbox, 0, 0);
frameLayout->addWidget(m_sim_scrollbar, 0, 1);
frameLayout->addWidget(m_end_spinbox, 0, 2);
QGridLayout* operationLayout = new QGridLayout();
m_startSim = new QPushButton("Start");
m_resetSim = new QPushButton("Reset");
operationLayout->addWidget(m_startSim, 0, 0);
operationLayout->addWidget(m_resetSim, 0, 1);
m_startSim->setCheckable(true);
layout->addLayout(frameLayout, 10);
layout->addLayout(operationLayout, 1);
connect(m_startSim, SIGNAL(released()), this, SLOT(toggleSimulation()));
connect(m_resetSim, SIGNAL(released()), this, SLOT(resetSimulation()));
connect(PSimulationThread::instance(), SIGNAL(finished()), this, SLOT(simulationFinished()));
}
PAnimationWidget::~PAnimationWidget()
{
}
void PAnimationWidget::toggleSimulation()
{
if (m_sim_started)
{
if (m_startSim->isChecked())
{
PSimulationThread::instance()->resume();
m_startSim->setText("Pause");
m_resetSim->setDisabled(true);
}
else
{
PSimulationThread::instance()->pause();
m_startSim->setText("Resume");
m_resetSim->setDisabled(false);
}
}
else
{
PSimulationThread::instance()->setTotalFrames(m_end_spinbox->value());
PSimulationThread::instance()->start();
m_startSim->setText("Pause");
m_sim_started = true;
m_resetSim->setDisabled(true);
}
}
void PAnimationWidget::resetSimulation()
{
PSimulationThread::instance()->reset();
}
void PAnimationWidget::simulationFinished()
{
m_startSim->setText("Finished");
m_startSim->setDisabled(true);
}
}
|
icl '../os/symbols.asm'
; this test is a direct read from storage, without BIOS support
org BOOTADDR
lda #0
ldx #OS_SET_VIDEO_MODE
jsr OS_CALL
sta ST_WRITE_RESET
mwa DISPLAY_START VRAM_TO_RAM
jsr lib_vram_to_ram
; Call command to open file
lda #ST_CMD_OPEN
jsr storage_write
lda #ST_MODE_READ
jsr storage_write
ldx #0
send_filename:
lda filename, x
beq @+
jsr storage_write
inx
bne send_filename
lda #0
jsr storage_write
; Proceed with command
@:
jsr storage_proceed
jsr storage_read ; length of response. Ignored in this example
jsr storage_read ; result of the operation
cmp #ST_RET_SUCCESS
bne end_with_error
jsr storage_read ; file handle
sta file_handle
read_next_block:
lda #ST_CMD_READ_BLOCK
jsr storage_write
lda file_handle
jsr storage_write
jsr storage_proceed
jsr storage_read ; length of response. Ignored in this example
jsr storage_read
cmp #ST_RET_SUCCESS
bne eof
jsr storage_read
sta R2
ldx #0
copy_block:
jsr storage_read
jsr screen_putc
inx
cpx R2
bne copy_block
jmp read_next_block
eof:
lda #ST_CMD_CLOSE
jsr storage_write
lda file_handle
jsr storage_write
jsr storage_proceed
jmp end
end_with_error:
ldx #0
@:
lda message_not_found, x
beq print_filename
jsr screen_putc
inx
bne @-
print_filename:
ldx #0
@:
lda filename, x
beq end
jsr screen_putc
inx
bne @-
end:
jmp end
.proc storage_write
stx R1
@:
ldx ST_WRITE_ENABLE
bne @-
sta ST_WRITE_DATA
ldx #$FF
stx ST_WRITE_ENABLE
ldx R1
rts
.endp
.proc storage_read
stx R1
@:
ldx ST_READ_ENABLE
bne @-
lda ST_READ_DATA
ldx #$FF
stx ST_READ_ENABLE
ldx R1
rts
.endp
.proc storage_proceed
sta ST_PROCEED
@:
lda ST_STATUS
cmp #ST_STATUS_DONE
bne @-
rts
.endp
.proc screen_putc
sty R1
ldy #0
sta (RAM_TO_VRAM), y
inw RAM_TO_VRAM
ldy R1
rts
.endp
file_handle:
.byte 0
filename:
.by "../asm/6502/test/storage_block.asm", 0
message_not_found:
.by "Cannot open file: ", 0
icl '../os/stdlib.asm'
|
; NOTE: compile with MASM 5.10. Later MASM's will produce code that crashes.
;
; static char sccs_id[] = "@(#)patch16.asm 1.10 1/12/95 15:41:19";
;
; This code is being published by Intel to users of the Pentium(tm)
; processor. Recipients are authorized to copy, modify, compile, use and
; distribute the code.
;
; Intel makes no warranty of any kind with regard to this code, including
; but not limited to, implied warranties or merchantability and fitness for
; a particular purpose. Intel assumes no responsibility for any errors that
; may appear in this code.
;
; No patent licenses are granted, express or implied.
;
;
include macros.asm
.386
.387
name fdiv_patch
if LCODE
EXTRN _FDIV_DETECT:FAR
else
EXTRN _FDIV_DETECT:NEAR
endif
_DATA SEGMENT DWORD USE16 PUBLIC 'DATA'
fdiv_risc_table DB 0, 1, 0, 0, 4, 0, 0, 7, 0, 0, 10, 0, 0, 13, 0, 0
fdiv_scale_1 DD 03f700000h ;0.9375
fdiv_scale_2 DD 03f880000h ;1.0625
one_shl_63 DD 05f000000h
;
; This is the flag that is tested by all the compiler branches
; before the divide instruction.
;
; 0 = unknown whether running on a part with the flaw
; 1 = running on a part with no flaw
; -1= running on a part with the flaw
;
EXTRN _fdiv_chk_flag:WORD
;
; The following are initializers for known values that cause
; the divide problem.
;
dispatch_table DW offset _TEXT:label0
DW offset _TEXT:label1
DW offset _TEXT:label2
DW offset _TEXT:label3
DW offset _TEXT:label4
DW offset _TEXT:label5
DW offset _TEXT:label6
DW offset _TEXT:label7
DW offset _TEXT:label8
DW offset _TEXT:label9
DW offset _TEXT:label10
DW offset _TEXT:label11
DW offset _TEXT:label12
DW offset _TEXT:label13
DW offset _TEXT:label14
DW offset _TEXT:label15
DW offset _TEXT:label16
DW offset _TEXT:label17
DW offset _TEXT:label18
DW offset _TEXT:label19
DW offset _TEXT:label20
DW offset _TEXT:label21
DW offset _TEXT:label22
DW offset _TEXT:label23
DW offset _TEXT:label24
DW offset _TEXT:label25
DW offset _TEXT:label26
DW offset _TEXT:label27
DW offset _TEXT:label28
DW offset _TEXT:label29
DW offset _TEXT:label30
DW offset _TEXT:label31
DW offset _TEXT:label32
DW offset _TEXT:label33
DW offset _TEXT:label34
DW offset _TEXT:label35
DW offset _TEXT:label36
DW offset _TEXT:label37
DW offset _TEXT:label38
DW offset _TEXT:label39
DW offset _TEXT:label40
DW offset _TEXT:label41
DW offset _TEXT:label42
DW offset _TEXT:label43
DW offset _TEXT:label44
DW offset _TEXT:label45
DW offset _TEXT:label46
DW offset _TEXT:label47
DW offset _TEXT:label48
DW offset _TEXT:label49
DW offset _TEXT:label50
DW offset _TEXT:label51
DW offset _TEXT:label52
DW offset _TEXT:label53
DW offset _TEXT:label54
DW offset _TEXT:label55
DW offset _TEXT:label56
DW offset _TEXT:label57
DW offset _TEXT:label58
DW offset _TEXT:label59
DW offset _TEXT:label60
DW offset _TEXT:label61
DW offset _TEXT:label62
DW offset _TEXT:label63
FPU_STATE STRUC
CONTROL_WORD DW ?
STATUS_WORD DW ?
TAG_WORD DW ?
IP_OFFSET DW ?
CS_SLCT DW ?
OPERAND_OFF DW ?
OPERAND_SLCT DW ?
FPU_STATE ENDS
ENV_SIZE EQU 14
_DATA ENDS
;
; Stack variables for divide routines.
;
DENOM EQU 0
NUMER EQU 12
PATCH_CW EQU 28
PREV_CW EQU 24
DENOM_SAVE EQU 32
STACK_SIZE EQU 44
MAIN_DENOM EQU 0
MAIN_NUMER EQU 12
SPILL_SIZE EQU 12
MEM_OPERAND EQU 10
SPILL_MEM_OPERAND EQU 22
;
; Stack frame locations for MS C/C++
;
SINGLE1 EQU 6 + STACK_SIZE
SINGLE2 EQU 10 + STACK_SIZE
DOUBLE1 EQU 6 + STACK_SIZE
DOUBLE2 EQU 14 + STACK_SIZE
LDOUBLE1 EQU 6 + STACK_SIZE
LDOUBLE2 EQU 22 + STACK_SIZE
SRESULT EQU 14
DRESULT EQU 22
LDRESULT EQU 38
ONESMASK EQU 0e00h
SINGLE_NAN EQU 07f80h
DOUBLE_NAN EQU 07ff0h
C023MASK EQU 04500h
EMPTY_MASK EQU 04100h
ILLEGAL_OPC EQU 6
fdivr_st MACRO reg_index, reg_index_minus1
fstp tbyte ptr [bp+DENOM]
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fstp tbyte ptr [bp+NUMER]
call fdiv_main_routine
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fld tbyte ptr [bp+NUMER]
fxch st(reg_index)
add sp, STACK_SIZE ; update stack
ENDM
fdivr_sti MACRO reg_index, reg_index_minus1
fstp tbyte ptr [bp+NUMER]
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fstp tbyte ptr [bp+DENOM]
call fdiv_main_routine
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fld tbyte ptr [bp+NUMER]
add sp, STACK_SIZE ; update stack
ENDM
fdivrp_sti MACRO reg_index, reg_index_minus1
fstp tbyte ptr [bp+NUMER]
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fstp tbyte ptr [bp+DENOM]
call fdiv_main_routine
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
add sp, STACK_SIZE ; update stack
ENDM
fdiv_st MACRO reg_index, reg_index_minus1
fstp tbyte ptr [bp+NUMER]
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fld st
fstp tbyte ptr [bp+DENOM]
fstp tbyte ptr [bp+DENOM_SAVE]
call fdiv_main_routine
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fld tbyte ptr [bp+DENOM_SAVE]
fxch st(reg_index)
add sp, STACK_SIZE ; update stack
ENDM
fdiv_sti MACRO reg_index, reg_index_minus1
fxch st(reg_index)
fstp tbyte ptr [bp+NUMER]
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fld st
fstp tbyte ptr [bp+DENOM]
fstp tbyte ptr [bp+DENOM_SAVE]
call fdiv_main_routine
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fld tbyte ptr [bp+DENOM_SAVE]
add sp, STACK_SIZE ; update stack
ENDM
fdivp_sti MACRO reg_index, reg_index_minus1
fstp tbyte ptr [bp+DENOM]
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
fstp tbyte ptr [bp+NUMER]
call fdiv_main_routine
IF reg_index_minus1 GE 1
fxch st(reg_index_minus1)
ENDIF
add sp, STACK_SIZE ; update stack
ENDM
_TEXT SEGMENT PARA USE16 PUBLIC 'CODE'
_TEXT ENDS
_DATA SEGMENT DWORD USE16 PUBLIC 'DATA'
_DATA ENDS
CONST SEGMENT DWORD USE16 PUBLIC 'CONST'
CONST ENDS
_BSS SEGMENT DWORD USE16 PUBLIC 'BSS'
_BSS ENDS
DGROUP GROUP CONST, _BSS, _DATA
_TEXT SEGMENT PARA USE16 PUBLIC 'CODE'
assume cs:_TEXT, ds:DGROUP, ss:DGROUP
; In this implementation the
; fdiv_main_routine is called,
; therefore all the stack frame
; locations are adjusted for the
; return pointer.
fdiv_main_routine PROC NEAR
fld tbyte ptr [bp+MAIN_NUMER] ; load the numerator
fld tbyte ptr [bp+MAIN_DENOM] ; load the denominator
retry:
; The following three lines test for denormals and zeros.
; A denormal or zero has a 0 in the explicit digit to the left of the
; binary point. Since that bit is the high bit of the word, adding
; it to itself will produce a carry if and only if the number is not
; denormal or zero.
;
mov ax, [bp+MAIN_DENOM+6] ; get mantissa bits 48-64
add ax,ax ; shift one's bit into carry
jnc denormal ; if no carry, we have a denormal
; The following three lines test the three bits after the four bit
; pattern (1,4,7,a,d). If these three bits are not all one, then
; the denominator cannot expose the flaw. This condition is tested by
; inverting the bits and testing that all are equal to zero afterward.
xor ax, ONESMASK ; invert the bits that must be one
test ax, ONESMASK ; test for needed bits
jz scale_if_needed ; if all one, it may need scalling
fdivp st(1), st ; OK to use the hardware
ret
;
; Now we test the four bits for one of the five patterns.
;
scale_if_needed:
shr ax, 12 ; keep first four bits after point
push bx ; save bx
mov bx,ax ; bx = index
cmp byte ptr fdiv_risc_table[bx], 0 ; check for (1,4,7,a,d)
pop bx ; restore bx
jnz divide_scaled
fdivp st(1), st ; OK to use the hardware
ret
divide_scaled:
mov ax, [bp + MAIN_DENOM+8] ; test denominator exponent
and ax, 07fffh ; if pseudodenormal ensure that only
jz invalid_denom ; invalid exception flag is set
cmp ax, 07fffh ; if NaN or infinity ensure that only
je invalid_denom ; invalid exception flag is set
;
; The following six lines turn off exceptions and set the
; precision control to 80 bits. The former is necessary to
; force any traps to be taken at the divide instead of the scaling
; code. The latter is necessary in order to get full precision for
; codes with incoming 32 and 64 bit precision settings. If
; it can be guaranteed that before reaching this point, the underflow
; exception is masked and the precision control is at 80 bits, these
; six lines can be omitted.
;
fnstcw [bp+PREV_CW] ; save caller's control word
mov ax, [bp+PREV_CW]
or ax, 033fh ; mask exceptions, pc=80
and ax, 0f3ffh ; set rounding mode to nearest
mov [bp+PATCH_CW], ax
fldcw [bp+PATCH_CW] ; mask exceptions & pc=80
; The following lines check the numerator exponent before scaling.
; This in order to prevent undeflow when scaling the numerator,
; which will cause a denormal exception flag to be set when the
; actual divide is preformed. This flag would not have been set
; normally. If there is a risk of underflow, the scale factor is
; 17/16 instead of 15/16.
;
mov ax, [bp+MAIN_NUMER+8] ; test numerator exponent
and ax, 07fffh
cmp ax, 00001h
je small_numer
; perform scaling of both numerator and denominator
fmul fdiv_scale_1 ; scale denominator by 15/16
fxch
fmul fdiv_scale_1 ; scale numerator by 15/16
fxch
;
; The next line restores the users control word. If the incoming
; control word had the underflow exception masked and precision
; control set to 80 bits, this line can be omitted.
;
fldcw [bp+PREV_CW] ; restore caller's control word
fdivp st(1), st ; OK to use the hardware
ret
small_numer:
fmul fdiv_scale_2 ; scale denominator by 17/16
fxch
fmul fdiv_scale_2 ; scale numerator by 17/16
fxch
;
; The next line restores the users control word. If the incoming
; control word had the underflow exception masked and precision
; control set to 80 bits, this line can be omitted.
;
fldcw [bp+PREV_CW] ; restore caller's control word
fdivp st(1), st ; OK to use the hardware
ret
denormal:
mov eax, [bp+MAIN_DENOM] ; test for whole mantissa == 0
or eax, [bp+MAIN_DENOM+4] ; test for whole mantissa == 0
jnz denormal_divide_scaled ; denominator is not zero
invalid_denom: ; zero or invalid denominator
fdivp st(1), st ; OK to use the hardware
ret
denormal_divide_scaled:
mov ax, word ptr[bp + MAIN_DENOM + 8] ; get exponent
and ax, 07fffh ; check for zero exponent
jnz invalid_denom
;
; The following six lines turn off exceptions and set the
; precision control to 80 bits. The former is necessary to
; force any traps to be taken at the divide instead of the scaling
; code. The latter is necessary in order to get full precision for
; codes with incoming 32 and 64 bit precision settings. If
; it can be guaranteed that before reaching this point, the underflow
; exception is masked and the precision control is at 80 bits, these
; six lines can be omitted.
;
fnstcw [bp+PREV_CW] ; save caller's control word
mov ax, [bp+PREV_CW]
or ax, 033fh ; mask exceptions, pc=80
and ax, 0f3ffh ; set rounding mode to nearest
mov [bp+PATCH_CW], ax
fldcw [bp+PATCH_CW] ; mask exceptions & pc=80
mov ax, [bp + MAIN_NUMER +8] ; test numerator exponent
and ax, 07fffh ; check for denormal numerator
je denormal_numer
cmp ax, 07fffh ; NaN or infinity
je invalid_numer
mov ax, [bp + MAIN_NUMER + 6] ; get bits 48..63 of mantissa
add ax, ax ; shift the first bit into carry
jnc invalid_numer ; if there is no carry, we have an
; invalid numer
jmp numer_ok
denormal_numer:
mov ax, [bp + MAIN_NUMER + 6] ; get bits 48..63 of mantissa
add ax, ax ; shift the first bit into carry
jc invalid_numer ; if there is a carry, we have an
; invalid numer
numer_ok:
fxch
fstp st ; pop numerator
fld st ; make copy of denominator
fmul [one_shl_63] ; make denominator not denormal
fstp tbyte ptr [bp+MAIN_DENOM]
fld tbyte ptr [bp+MAIN_NUMER] ; load numerator
fxch ; restore proper order
fwait
; The next line restores the users control word. If the incoming
; control word had the underflow exception masked and precision
; control set to 80 bits, this line can be omitted.
;
fldcw [bp+PREV_CW] ; restore caller's control word
jmp retry ; start the whole thing over
invalid_numer:
;
; The next line restores the users control word. If the incoming
; control word had the underflow exception masked and precision
; control set to 80 bits, this line can be omitted.
;
fldcw [bp + PREV_CW]
fdivp st(1), st ; use of hardware is OK.
ret
fdiv_main_routine ENDP
public FDIV_R
if LCODE
FDIV_R PROC FAR
else
FDIV_R PROC NEAR
endif
push bp
push bx
sub sp, STACK_SIZE
shl ax, 1
mov bx,ax
cmp _fdiv_chk_flag,0
jne flaw_detected1
sub sp, 12
mov bp,sp
fstp tbyte ptr [bp]
call _FDIV_DETECT
fld tbyte ptr [bp]
add sp, 12
flaw_detected1:
mov bp,sp
jmp word ptr dispatch_table[bx]
label0:
fdiv st,st(0) ; D8 F0 FDIV ST,ST(0)
add sp, STACK_SIZE
pop bx
pop bp
ret
label1:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label2:
fdivr st,st(0) ; D8 F8 FDIVR ST,ST(0)
add sp, STACK_SIZE
pop bx
pop bp
ret
label3:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label4:
fdiv st(0),st ; DC F8/D8 F0 FDIV ST(0),ST
add sp, STACK_SIZE
pop bx
pop bp
ret
label5:
fdivp st(0),st ; DE F8 FDIVP ST(0),ST
add sp, STACK_SIZE
pop bx
pop bp
ret
label6:
fdivr st(0),st ; DC F0/DE F8 FDIVR ST(0),ST
add sp, STACK_SIZE
pop bx
pop bp
ret
label7:
fdivrp st(0),st ; DE F0 FDIVRP ST(0),ST
add sp, STACK_SIZE
pop bx
pop bp
ret
label8:
fdiv_st 1 0
pop bx
pop bp
ret
label9:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label10:
fdivr_st 1 0
pop bx
pop bp
ret
label11:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label12:
fdiv_sti 1 0
pop bx
pop bp
ret
label13:
fdivp_sti 1 0
pop bx
pop bp
ret
label14:
fdivr_sti 1 0
pop bx
pop bp
ret
label15:
fdivrp_sti 1 0
pop bx
pop bp
ret
label16:
fdiv_st 2 1
pop bx
pop bp
ret
label17:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label18:
fdivr_st 2 1
pop bx
pop bp
ret
label19:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label20:
fdiv_sti 2 1
pop bx
pop bp
ret
label21:
fdivp_sti 2 1
pop bx
pop bp
ret
label22:
fdivr_sti 2 1
pop bx
pop bp
ret
label23:
fdivrp_sti 2 1
pop bx
pop bp
ret
label24:
fdiv_st 3 2
pop bx
pop bp
ret
label25:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label26:
fdivr_st 3 2
pop bx
pop bp
ret
label27:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label28:
fdiv_sti 3 2
pop bx
pop bp
ret
label29:
fdivp_sti 3 2
pop bx
pop bp
ret
label30:
fdivr_sti 3 2
pop bx
pop bp
ret
label31:
fdivrp_sti 3 2
pop bx
pop bp
ret
label32:
fdiv_st 4 3
pop bx
pop bp
ret
label33:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label34:
fdivr_st 4 3
pop bx
pop bp
ret
label35:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label36:
fdiv_sti 4 3
pop bx
pop bp
ret
label37:
fdivp_sti 4 3
pop bx
pop bp
ret
label38:
fdivr_sti 4 3
pop bx
pop bp
ret
label39:
fdivrp_sti 4 3
pop bx
pop bp
ret
label40:
fdiv_st 5 4
pop bx
pop bp
ret
label41:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label42:
fdivr_st 5 4
pop bx
pop bp
ret
label43:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label44:
fdiv_sti 5 4
pop bx
pop bp
ret
label45:
fdivp_sti 5 4
pop bx
pop bp
ret
label46:
fdivr_sti 5 4
add bx,bx
pop bx
pop bp
ret
label47:
fdivrp_sti 5 4
pop bx
pop bp
ret
label48:
fdiv_st 6 5
pop bx
pop bp
ret
label49:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label50:
fdivr_st 6 5
pop bx
pop bp
ret
label51:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label52:
fdiv_sti 6 5
pop bx
pop bp
ret
label53:
fdivp_sti 6 5
pop bx
pop bp
ret
label54:
fdivr_sti 6 5
pop bx
pop bp
ret
label55:
fdivrp_sti 6 5
pop bx
pop bp
ret
label56:
fdiv_st 7 6
pop bx
pop bp
ret
label57:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label58:
fdivr_st 7 6
pop bx
pop bp
ret
label59:
add sp, STACK_SIZE
pop bx
pop bp
int ILLEGAL_OPC
label60:
fdiv_sti 7 6
pop bx
pop bp
ret
label61:
fdivp_sti 7 6
pop bx
pop bp
ret
label62:
fdivr_sti 7 6
pop bx
pop bp
ret
label63:
fdivrp_sti 7 6
pop bx
pop bp
ret
FDIV_R ENDP
fdivp_sti_st PROC NEAR
; for calling from mem routines
cmp _fdiv_chk_flag,0
jne flaw_detected2
sub sp, 12
mov bp,sp
fstp tbyte ptr [bp]
call _FDIV_DETECT
fld tbyte ptr [bp]
add sp, 12
flaw_detected2:
sub sp, STACK_SIZE
mov bp,sp
fdivp_sti 1 0
ret
fdivp_sti_st ENDP
fdivrp_sti_st PROC NEAR
; for calling from mem routines
cmp _fdiv_chk_flag,0
jne flaw_detected3
sub sp, 12
mov bp,sp
fstp tbyte ptr [bp]
call _FDIV_DETECT
fld tbyte ptr [bp]
add sp, 12
flaw_detected3:
sub sp, STACK_SIZE
mov bp,sp
fdivrp_sti 1 0
ret
fdivrp_sti_st ENDP
;;; FDIV_M32 - FDIV m32real FIX
;;
;; Input : Value of the m32real in the top of STACK
;;
;; Output: Result of FDIV in ST
PUBLIC FDIV_M32
FDIV_M32 PROC FAR
push eax ; save eax
push bp
mov bp,sp
mov ax, [bp + MEM_OPERAND + 2] ; check for
and ax, SINGLE_NAN ; NaN
cmp ax, SINGLE_NAN ;
je memory_divide_m32 ;
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack ; spill TOS-1 reg
fld dword ptr[bp + MEM_OPERAND] ; load m32real in ST
call fdivp_sti_st ; do actual divide
jmp m32_ok ; return
spill_fpstack:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp ] ; save user's ST(1)
fld dword ptr[bp + SPILL_MEM_OPERAND] ; load m32 real
call fdivp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m32_ok:
pop bp
pop eax
ret
memory_divide_m32:
fdiv dword ptr[bp + MEM_OPERAND] ; do actual divide
pop bp
pop eax
ret
FDIV_M32 ENDP
;;; FDIV_M64 - FDIV m64real FIX
;;
;; Input : Value of the m64real in the top of STACK
;;
;; Output: Result of FDIV in ST
PUBLIC FDIV_M64
FDIV_M64 PROC FAR
push eax ; save eax
push bp
mov bp,sp
mov ax, [bp + MEM_OPERAND + 6] ; check for
and ax, DOUBLE_NAN ; NaN
cmp ax, DOUBLE_NAN ;
je memory_divide_m64 ;
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack_m64 ; spill TOS-1 reg
fld qword ptr[bp + MEM_OPERAND] ; load m64real in ST
call fdivp_sti_st ; do actual divide
jmp m64_ok ; return
spill_fpstack_m64:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp] ; save user's ST(1)
fld qword ptr[bp + SPILL_MEM_OPERAND] ; load m64real
call fdivp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m64_ok:
pop bp
pop eax
ret
memory_divide_m64:
fdiv qword ptr[bp + MEM_OPERAND] ; do actual divide
pop bp
pop eax
ret
FDIV_M64 ENDP
;;; FDIV_M16I - FDIV m16int FIX
;;
;; Input : Value of the m16int in the top of STACK
;;
;; Output: Result of FDIV in ST
PUBLIC FDIV_M16I
FDIV_M16I PROC FAR
push eax ; save eax
push bp
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack_m16i ; spill TOS-1 reg
mov bp,sp
fild word ptr[bp + MEM_OPERAND] ; load m16int in ST
call fdivp_sti_st ; do actual divide
jmp m16i_ok ; return
spill_fpstack_m16i:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp ] ; save user's ST(1)
fild word ptr[bp + SPILL_MEM_OPERAND] ; load m16int
call fdivp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m16i_ok:
pop bp
pop eax
ret
FDIV_M16I ENDP
;;; FDIV_M32I - FDIV m16int FIX
;;
;; Input : Value of the m16int in the top of STACK
;;
;; Output: Result of FDIV in ST
PUBLIC FDIV_M32I
FDIV_M32I PROC FAR
push eax ; save eax
push bp
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack_m32i ; spill TOS-1 reg
mov bp,sp
fild dword ptr[bp + MEM_OPERAND] ; load m32int in ST
call fdivp_sti_st ; do actual divide
jmp m32i_ok ; return
spill_fpstack_m32i:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp ] ; save user's ST(1)
fild dword ptr[bp + SPILL_MEM_OPERAND] ; load m32int
call fdivp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m32i_ok:
pop bp
pop eax
ret
FDIV_M32I ENDP
;;; FDIVR_M32 - FDIVR m32real FIX
;;
;; Input : Value of the m32real in the top of STACK
;;
;; Output: Result of FDIVR in ST
PUBLIC FDIVR_M32
FDIVR_M32 PROC FAR
push eax ; save eax
push bp
mov bp,sp
mov ax, [bp + MEM_OPERAND + 2] ; check for
and ax, SINGLE_NAN ; NaN
cmp ax, SINGLE_NAN ;
je memory_divide_m32r ;
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack_m32r ; spill TOS-1 reg
fld dword ptr[bp + MEM_OPERAND] ; load m32real in ST
call fdivrp_sti_st ; do actual divide
jmp m32r_ok ; return
spill_fpstack_m32r:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp ] ; save user's ST(1)
fld dword ptr[bp + SPILL_MEM_OPERAND] ; load m32 real
call fdivrp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m32r_ok:
pop bp
pop eax
ret
memory_divide_m32r:
fdivr dword ptr[bp + MEM_OPERAND] ; do actual divide
pop bp
pop eax
ret
FDIVR_M32 ENDP
;;; FDIVR_M64 - FDIVR m64real FIX
;;
;; Input : Value of the m64real in the top of STACK
;;
;; Output: Result of FDIVR in ST
PUBLIC FDIVR_M64
FDIVR_M64 PROC FAR
push eax ; save eax
push bp
mov bp,sp
mov ax, [bp + MEM_OPERAND + 6] ; check for
and ax, DOUBLE_NAN ; NaN
cmp ax, DOUBLE_NAN ;
je memory_divide_m64r ;
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack_m64r ; spill TOS-1 reg
fld qword ptr[bp + MEM_OPERAND] ; load m64real in ST
call fdivrp_sti_st ; do actual divide
jmp m64r_ok ; return
spill_fpstack_m64r:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp ] ; save user's ST(1)
fld qword ptr[bp + SPILL_MEM_OPERAND] ; load m64real
call fdivrp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m64r_ok:
pop bp
pop eax
ret
memory_divide_m64r:
fdivr qword ptr[bp + MEM_OPERAND] ; do actual divide
pop bp
pop eax
ret
FDIVR_M64 ENDP
;;; FDIVR_M16I - FDIVR m16int FIX
;;
;; Input : Value of the m16int in the top of STACK
;;
;; Output: Result of FDIVR in ST
PUBLIC FDIVR_M16I
FDIVR_M16I PROC FAR
push eax ; save eax
push bp
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack_m16ir ; spill TOS-1 reg
mov bp,sp
fild word ptr[bp + MEM_OPERAND] ; load m16int in ST
call fdivrp_sti_st ; do actual divide
jmp m16ir_ok ; return
spill_fpstack_m16ir:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp ] ; save user's ST(1)
fild word ptr[bp + SPILL_MEM_OPERAND] ; load m16int
call fdivrp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m16ir_ok:
pop bp
pop eax
ret
FDIVR_M16I ENDP
;;; FDIVR_M32I - FDIVR m32int FIX
;;
;; Input : Value of the m32int in the top of STACK
;;
;; Output: Result of FDIVR in ST
PUBLIC FDIVR_M32I
FDIVR_M32I PROC FAR
push eax ; save eax
push bp
call fdiv_tos_valid ; check if (TOS-1) is empty
cmp ax, 0 ; is TOS-1 not empty?
je spill_fpstack_m32ir ; spill TOS-1 reg
mov bp,sp
fild dword ptr[bp + MEM_OPERAND] ; load m32int in ST
call fdivrp_sti_st ; do actual divide
jmp m32ir_ok ; return
spill_fpstack_m32ir:
sub sp, SPILL_SIZE ; make temp space
mov bp,sp
fstp tbyte ptr[bp ] ; save user's ST(1)
fild dword ptr[bp + SPILL_MEM_OPERAND] ; load m32int
call fdivrp_sti_st ; do actual divide
fld tbyte ptr[bp] ; restore user's (TOS-1)
fincstp ; restore FP stack
add sp, SPILL_SIZE
m32ir_ok:
pop bp
pop eax
ret
FDIVR_M32I ENDP
fdiv_tos_valid PROC NEAR
fdecstp ; make (ST-1) TOS
fxam ; examine ST(-1)
fnstsw ax ; get status word
and ax, C023MASK ; isolate C0, C2, and C3
cmp ax, EMPTY_MASK ; is ST(-1) empty?
je st_1_empty ; ST(-1) is empty
xor ax, ax ; return 0 for spill
ret
st_1_empty:
fincstp ; restore FP stack
ret ; return non zero value
fdiv_tos_valid ENDP
_TEXT ENDS
end
|
#pragma once
#include "scene/scene.hpp" |
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include "LmbrCentral_precompiled.h"
#include "StaticPhysicsComponent.h"
#include <AzCore/RTTI/BehaviorContext.h>
#include <AzCore/Serialization/SerializeContext.h>
namespace AzFramework
{
void StaticPhysicsConfig::Reflect(AZ::ReflectContext* context)
{
if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
{
serializeContext->Class<AzFramework::StaticPhysicsConfig>()
->Version(1)
->Field("EnabledInitially", &AzFramework::StaticPhysicsConfig::m_enabledInitially)
;
}
if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
{
behaviorContext->Class<AzFramework::StaticPhysicsConfig>()
->Property("EnabledInitially", BehaviorValueProperty(&AzFramework::StaticPhysicsConfig::m_enabledInitially))
;
}
}
}
namespace LmbrCentral
{
void StaticPhysicsComponent::Reflect(AZ::ReflectContext* context)
{
AzFramework::StaticPhysicsConfig::Reflect(context);
if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
{
serializeContext->Class<StaticPhysicsComponent, PhysicsComponent>()
->Version(1)
->Field("Configuration", &StaticPhysicsComponent::m_configuration)
;
}
if(auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
{
behaviorContext->Constant("StaticPhysicsComponentTypeId", BehaviorConstant(AzFramework::StaticPhysicsComponentTypeId));
}
}
bool StaticPhysicsComponent::ReadInConfig(const AZ::ComponentConfig* baseConfig)
{
if (auto config = azrtti_cast<const AzFramework::StaticPhysicsConfig*>(baseConfig))
{
m_configuration = *config;
return true;
}
return false;
}
bool StaticPhysicsComponent::WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const
{
if (auto outConfig = azrtti_cast<AzFramework::StaticPhysicsConfig*>(outBaseConfig))
{
*outConfig = m_configuration;
return true;
}
return false;
}
void StaticPhysicsComponent::ConfigurePhysicalEntity()
{
}
} // namespace LmbrCentral
|
;******************************************************************
; 6502 BBC Micro Compressed VGM (VGC) Music Player
; By Simon Morris
; https://github.com/simondotm/vgm-packer
;******************************************************************
;---------------------------------------------------------------
; VGM Player Library code
;---------------------------------------------------------------
.vgm_start
;--------------------------------------------------
; user callable routines:
; vgm_init()
; vgm_update()
; sn_reset()
; sn_write()
;--------------------------------------------------
; Sound chip data from the vgm player
IF ENABLE_VGM_FX
.vgm_fx SKIP 11
; first 8 bytes are:
; tone0 LO, tone1 LO, tone2 LO, tone3, vol0, vol1, vol2, vol3 (all 4-bit values)
; next 3 bytes are:
; tone0 HI, tone1 HI, tone2 HI (all 6-bit values)
VGM_FX_TONE0_LO = 0
VGM_FX_TONE1_LO = 1
VGM_FX_TONE2_LO = 2
VGM_FX_TONE3_LO = 3 ; noise
VGM_FX_VOL0 = 4
VGM_FX_VOL1 = 5
VGM_FX_VOL2 = 6
VGM_FX_VOL3 = 7 ; noise
VGM_FX_TONE0_HI = 8
VGM_FX_TONE1_HI = 9
VGM_FX_TONE2_HI = 10
ENDIF
;-------------------------------------------
; vgm_init
;-------------------------------------------
; Initialise playback routine
; A points to HI byte of a page aligned 2Kb RAM buffer address
; X/Y point to the VGC data stream to be played
; C=1 for looped playback
;-------------------------------------------
.vgm_init
{
; stash the 2kb buffer address
sta vgm_buffers
lda #0
ror a ; move carry into A
sta vgm_loop
; stash the data source addr for looping
stx vgm_source+0
sty vgm_source+1
; Prepare the data for streaming (passed in X/Y)
jmp vgm_stream_mount
}
;-------------------------------------------
; vgm_update
;-------------------------------------------
; call every 50Hz to play music
; vgm_init must be called prior to this
; On entry A is non-zero if the music should be looped
; returns non-zero when VGM is finished.
;-------------------------------------------
.vgm_update
{
lda vgm_finished
bne exit
; SN76489 data register format is %1cctdddd where cc=channel, t=0=tone, t=1=volume, dddd=data
; The data is run length encoded.
; Get Channel 3 tone first because that contains the EOF marker
; Update Tone3
lda#3:jsr vgm_update_register1 ; on exit C set if data changed, Y is last value
bcc more_updates
cpy #&08 ; EOF marker? (0x08 is an invalid tone 3 value)
beq finished
.more_updates
lda#7:jsr vgm_update_register1 ; Volume3
lda#1:jsr vgm_update_register2 ; Tone1
lda#2:jsr vgm_update_register2 ; Tone2
lda#4:jsr vgm_update_register1 ; Volume0
lda#5:jsr vgm_update_register1 ; Volume1
lda#6:jsr vgm_update_register1 ; Volume2
; do tone0 last so we can use X output as the Zero return flag
lda#0:jsr vgm_update_register2 ; Tone0, returns 0 in X
txa ; return Z=0=still playing
.exit
rts
.finished
; end of tune reached
lda vgm_loop
beq no_looping
; restart if looping
ldx vgm_source+0
ldy vgm_source+1
lda vgm_loop
asl a ; -> C
lda vgm_buffers
jsr vgm_init
jmp vgm_update
.no_looping
; no looping so set flag & stop PSG
sty vgm_finished ; any NZ value is fine, in this case 0x08
jmp sn_reset ; also returns non-zero in A
}
;-------------------------------------------
; Sound chip routines
;-------------------------------------------
; Write data to SN76489 sound chip
; A contains data to be written to sound chip
; clobbers X, A is non-zero on exit
.sn_write
{
ldx #255
stx &fe43
sta &fe41
inx
stx &fe40
lda &fe40
ora #8
sta &fe40
rts ; 21 bytes
}
; Reset SN76489 sound chip to a default (silent) state
.sn_reset
{
\\ Zero volume on all channels
lda #&9f : jsr sn_write
lda #&bf : jsr sn_write
lda #&df : jsr sn_write
lda #&ff : jmp sn_write
}
;-------------------------------------------
; VGM internal routines
; Not user callable.
;-------------------------------------------
; LZ4_FORMAT is a legacy define. May get reactivated if we ever do the full lz4 support
LZ4_FORMAT = FALSE
; HUFFMAN_INLINE is an experimental optimization that inlines huffman/lz fetch_byte routines.
; Not sure its worth it for the huffman code path since it's inherently slower
; and not likely to be much of a benefit.
HUFFMAN_INLINE = FALSE
;-------------------------------------------
; local vgm workspace
;-------------------------------------------
VGM_STREAM_CONTEXT_SIZE = 10 ; number of bytes total workspace for a stream
VGM_STREAMS = 8
;ALIGN 16 ; doesnt have to be aligned, just for debugging ease
.vgm_streams ; decoder contexts - 8 bytes per stream, 8 streams (64 bytes)
skip VGM_STREAMS*VGM_STREAM_CONTEXT_SIZE
; 0 zp_stream_src ; stream data ptr LO/HI
; 2 zp_literal_cnt ; literal count LO/HI
; 4 zp_match_cnt ; match count LO/HI
; 6 lz_window_src ; window read ptr - index
; 7 lz_window_dst ; window write ptr - index
; 8 zp_huff_bitbuffer ; 1 byte, referenced by inner loop
; 9 huff_bitsleft ; 1 byte, referenced by inner loop
.vgm_buffers equb 0 ; the HI byte of the address where the buffers are stored
.vgm_finished equb 0 ; a flag to indicate player has reached the end of the vgm stream
.vgm_flags equb 0 ; flags for current vgm file. bit7 set stream is huffman coded. bit 6 set if stream is 16-bit LZ4 offsets
.vgm_temp equb 0 ; used by vgm_update_register1()
.vgm_loop equb 0 ; non zero if tune is to be looped
.vgm_source equw 0 ; vgm data address
; 8 counters for VGM register update counters (RLE)
.vgm_register_counts
SKIP 8
; Table of SN76489 flags for the 8 LATCH/DATA registers
; %1cctdddd
.vgm_register_headers
EQUB &80 + (0<<5) ; Tone 0
EQUB &80 + (1<<5) ; Tone 1
EQUB &80 + (2<<5) ; Tone 2
EQUB &80 + (3<<5) ; Tone 3
EQUB &90 + (0<<5) ; Volume 0
EQUB &90 + (1<<5) ; Volume 1
EQUB &90 + (2<<5) ; Volume 2
EQUB &90 + (3<<5) ; Volume 3
; VGC file parsing - Skip to the next block.
; on entry zp_block_data points to current block (header)
; on exit zp_block_data points to next block
; Clobbers Y
.vgm_next_block
{
; read 16-bit block size to zp_block_size
; +4 to compensate for block header
ldy #0
lda (zp_block_data),Y
clc
adc #4
sta zp_block_size+0
iny
lda (zp_block_data),Y
adc #0
sta zp_block_size+1
; move to next block
lda zp_block_data+0
clc
adc zp_block_size+0
sta zp_block_data+0
lda zp_block_data+1
adc zp_block_size+1
sta zp_block_data+1
rts
}
; VGC file parsing - Initialise the system for the provided in-memory VGC data stream.
; On entry X/Y point to Lo/Hi address of the vgc data
.vgm_stream_mount
{
; parse data stream
; VGC broadly uses LZ4 frame & block formats for convenience
; however there are assumptions for format:
; Magic number[4], Flags[1], MaxBlockSize[1], Header checksum[1]
; Contains 8 blocks
; Obviously since this is an 8-bit CPU no files or blocks can be > 64Kb in size
; VGC streams have a different magic number to LZ4
; [56 47 43 XX]
; where XX:
; bit 6 - LZ 8 bit (0) or 16 bit (1) [unsupported atm]
; bit 7 - Huffman (1) or no huffman (0)
stx zp_block_data+0
sty zp_block_data+1
; get the stream flags (huffman/8 or 16 bit offsets)
ldy #3
lda (zp_block_data), y
sta vgm_flags
; Skip frame header, and move to first block
lda zp_block_data+0
clc
adc #7
sta zp_block_data+0
bcc no_block_hi
inc zp_block_data+1
.no_block_hi
IF ENABLE_HUFFMAN
; first block contains the bitlength and symbol tables
bit vgm_flags
bpl skip_hufftable
; stash table sizes for later
IF FALSE
; we dont need the symbol table size for anything.
; left here for future possibility of GD3 tags
ldy #8
lda (zp_block_data),Y ; symbol table size
sta zp_symbol_table_size
iny
ELSE
ldy #9
ENDIF
lda (zp_block_data),Y ; bitlength table size
sta stashLengthTableSize+1 ; **SELF MODIFYING**
; compensate for the first byte (range is 0-nbits inclusive), value always < 254
inc stashLengthTableSize+1 ; **SELF-MODIFYING**
; store the address of the bitlengths table directly in the huff_fetch_byte routine
lda zp_block_data + 0
clc
adc #4+4+1 ; skip lz blocksize, huff block size and symbol count byte
sta LOAD_LENGTH_TABLE + 1 ; ** SELF MODIFICATION ***
lda zp_block_data + 1
adc #0
sta LOAD_LENGTH_TABLE + 2 ; ** SELF MODIFICATION ***
; store the address of the symbols table directly in the huff_fetch_byte routine
lda LOAD_LENGTH_TABLE + 1
clc
.stashLengthTableSize
adc #0 ; length table size **SELF MODIFIED - see above **
sta LOAD_SYMBOL_TABLE + 1 ; ** SELF MODIFICATION ***
lda LOAD_LENGTH_TABLE + 2
adc #0
sta LOAD_SYMBOL_TABLE + 2 ; ** SELF MODIFICATION ***
; skip to next block
jsr vgm_next_block
.skip_hufftable
ENDIF ; ENABLE_HUFFMAN
; read the block headers (size)
ldx #0
; clear vgm finished flag
stx vgm_finished
.block_loop
; get start address of encoded data for vgm_stream[x] (block ptr+4)
lda zp_block_data+0
clc
adc #4 ; skip block header
sta vgm_streams + VGM_STREAMS*0, x ; zp_stream_src LO
lda zp_block_data+1
adc #0
sta vgm_streams + VGM_STREAMS*1, x ; zp_stream_src HI
; init the rest
lda #0
sta vgm_streams + VGM_STREAMS*2, x ; literal cnt
sta vgm_streams + VGM_STREAMS*3, x ; literal cnt
sta vgm_streams + VGM_STREAMS*4, x ; match cnt
sta vgm_streams + VGM_STREAMS*5, x ; match cnt
sta vgm_streams + VGM_STREAMS*6, x ; window src ptr
sta vgm_streams + VGM_STREAMS*7, x ; window dst ptr
sta vgm_streams + VGM_STREAMS*8, x ; huff bitbuffer
sta vgm_streams + VGM_STREAMS*9, x ; huff bitsleft
; setup RLE tables
lda #1
sta vgm_register_counts, X
; move to next block
jsr vgm_next_block
; for all 8 blocks
inx
cpx #8
bne block_loop
IF ENABLE_HUFFMAN
IF HUFFMAN_INLINE
; setup byte fetch routines to lz_fetch_byte or huff_fetch_byte
; depending if data file is huffman encoded or not
; default compilation is lz_fetch_byte, so this code is not needed if HUFFMAN disabled
ldx #lo(lz_fetch_byte)
ldy #hi(lz_fetch_byte)
; if bit7 of vgm_flags is set, its a huffman stream
bit vgm_flags ; [3 zp, 4 abs] (2)
bpl no_huffman ; [2, +1, +2] (2)
ldx #lo(huff_fetch_byte)
ldy #hi(huff_fetch_byte)
.no_huffman
stx fetchByte1+1
sty fetchByte1+2
stx fetchByte2+1
sty fetchByte2+2
sty fetchByte3+2
stx fetchByte3+1
IF LZ4_FORMAT
stx fetchByte4+1
sty fetchByte4+2
ENDIF
stx fetchByte5+1
sty fetchByte5+2
ENDIF ; HUFFMAN_INLINE
ENDIF ;ENABLE_HUFFMAN
rts
}
;----------------------------------------------------------------------
; fetch register data byte from register stream selected in A
; This byte will be LZ4 encoded
; A is register id (0-7)
; clobbers X,Y
.vgm_get_register_data
{
; set the LZ4 decoder stream workspace buffer (initialised by vgm_stream_mount)
tax
clc
adc vgm_buffers ; hi byte of the base address of the 2Kb (8x256) vgm stream buffers
; store hi byte of where the 256 byte vgm stream buffer for this stream is located
sta lz_window_src+1 ; **SELFMOD**
sta lz_window_dst+1 ; **SELFMOD**
; calculate the stream buffer context
stx loadX+1 ; Stash X for later *** SELF MODIFYING SEE BELOW ***
; since we have 8 separately compressed register streams
; we have to load the required decoder context to ZP
lda vgm_streams + VGM_STREAMS*0, x
sta zp_stream_src + 0
lda vgm_streams + VGM_STREAMS*1, x
sta zp_stream_src + 1
lda vgm_streams + VGM_STREAMS*2, x
sta zp_literal_cnt + 0
lda vgm_streams + VGM_STREAMS*3, x
sta zp_literal_cnt + 1
lda vgm_streams + VGM_STREAMS*4, x
sta zp_match_cnt + 0
lda vgm_streams + VGM_STREAMS*5, x
sta zp_match_cnt + 1
lda vgm_streams + VGM_STREAMS*6, x
sta lz_window_src ; **SELF MODIFY** not ZP
lda vgm_streams + VGM_STREAMS*7, x
sta lz_window_dst ; **SELF MODIFY** not ZP
IF ENABLE_HUFFMAN
lda vgm_streams + VGM_STREAMS*8, x
sta zp_huff_bitbuffer
lda vgm_streams + VGM_STREAMS*9, x
sta zp_huff_bitsleft
ENDIF
; then fetch a decompressed byte
jsr lz_decode_byte
sta loadA+1 ; Stash A for later - ** SMOD ** [4](2) faster than pha/pla
; then we save the decoder context from ZP back to main ram
.loadX
ldx #0 ; *** SELF MODIFIED - See above ***
lda zp_stream_src + 0
sta vgm_streams + VGM_STREAMS*0, x
lda zp_stream_src + 1
sta vgm_streams + VGM_STREAMS*1, x
lda zp_literal_cnt + 0
sta vgm_streams + VGM_STREAMS*2, x
lda zp_literal_cnt + 1
sta vgm_streams + VGM_STREAMS*3, x
lda zp_match_cnt + 0
sta vgm_streams + VGM_STREAMS*4, x
lda zp_match_cnt + 1
sta vgm_streams + VGM_STREAMS*5, x
lda lz_window_src
sta vgm_streams + VGM_STREAMS*6, x
lda lz_window_dst
sta vgm_streams + VGM_STREAMS*7, x
IF ENABLE_HUFFMAN
lda zp_huff_bitbuffer
sta vgm_streams + VGM_STREAMS*8, x
lda zp_huff_bitsleft
sta vgm_streams + VGM_STREAMS*9, x
ENDIF
.loadA
lda #0 ;[2](2) - ***SELF MODIFIED - See above ***
rts
}
; Fetch 1 register data byte from the encoded stream and send to sound chip (volumes & tone3)
; A is register to update
; on exit:
; C is set if an update happened and Y contains last register value
; C is clear if no updated happened and Y is preserved
; X contains register provided in A on entry (0-7)
.vgm_update_register1
{
tax
clc
dec vgm_register_counts,x ; no effect on C
bne skip_register_update
; decode a byte & send to psg
stx vgm_temp
jsr vgm_get_register_data
tay
and #&0f
ldx vgm_temp
ora vgm_register_headers,x
; check if it's a tone3 skip command (&ef) before we play it
; - this prevents the LFSR being reset unnecessarily
cmp #&ef
beq skip_tone3
jsr sn_write ; clobbers X
.skip_tone3
; get run length (top 4-bits + 1)
tya
lsr a
lsr a
lsr a
lsr a
clc
adc #1
ldx vgm_temp
sta vgm_register_counts,x
IF ENABLE_VGM_FX
tya
and #&0f
ora vgm_register_headers,X
cmp #&ef ; tone3 skip?
beq skip_tone3_fx
and #&0f
sta vgm_fx,x ; store the register (0-7) setting in fx array
.skip_tone3_fx
ENDIF
sec
}
.skip_register_update
{
rts
}
; Fetch 2 register bytes (LATCH+DATA) from the encoded stream and send to sound chip (tone0, tone1, tone2)
; Same parameters as vgm_update_register1
.vgm_update_register2
{
jsr vgm_update_register1 ; returns stream in X if updated, and C=0 if no update needed
bcc skip_register_update
; decode 2nd byte and send to psg as (DATA)
txa
jsr vgm_get_register_data
IF ENABLE_VGM_FX
ldx vgm_temp ; still contains the stream id from previous call to vgm_update_register1()
sta vgm_fx+8,x ; store the register (0-2) setting for fx
ENDIF
jmp sn_write ; clobbers X
}
.vgm_end
.decoder_start
;-------------------------------
; lz4 decoder
;-------------------------------
; fetch a byte from the current decode buffer at the current read ptr offset
; returns byte in A, clobbers Y
.lz_fetch_buffer
{
lda &ffff ; *** SELF MODIFIED ***
inc lz_fetch_buffer+1
rts
}
; push byte into decode buffer
; clobbers Y, preserves A
.lz_store_buffer ; called twice - 4 byte overhead, 6 byte function. Cheaper to inline.
{
sta &ffff ; *** SELF MODIFIED ***
inc lz_store_buffer+1
rts ; [6] (1)
}
; provide these vars as cleaner addresses for the code address to be self modified
lz_window_src = lz_fetch_buffer + 1 ; window read ptr LO (2 bytes) - index, 3 references
lz_window_dst = lz_store_buffer + 1 ; window write ptr LO (2 bytes) - index, 3 references
; Calculate a multi-byte lz4 style length into zp_temp
; On entry A contains the initial counter value (LO)
; Returns 16-bit length in A/X (A=LO, X=HI)
; Clobbers Y, zp_temp+0, zp_temp+1
.lz_fetch_count
ldx #0
cmp #15 ; >=15 signals byte extend
bne lz_fetch_count_done
sta zp_temp+0
stx zp_temp+1
.fetch
.fetchByte1
jsr lz_fetch_byte
tay
clc
adc zp_temp+0
sta zp_temp+0
lda zp_temp+1 ; [3zp 4abs](2)
adc #0 ; [2](2)
sta zp_temp+1 ; [3zp 4abs](2)
cpy #255 ; 255 signals byte extend
beq fetch
tax
lda zp_temp+0
.lz_fetch_count_done
; A/X now contain count (LO/HI)
rts
; decode a byte from the currently selected register stream
; unlike typical lz style unpackers we are using a state machine
; because it is necessary for us to be able to decode a byte at a time from 8 separate streams
.lz_decode_byte
; decoder state is:
; empty - fetch new token & prepare
; literal - decode new literal
; match - decode new match
; lz4 block format:
; [TOKEN][LITERAL LENGTH][LITERALS][...][MATCH OFFSET][MATCH LENGTH]
; try fetching a literal byte from the stream
.try_literal
lda zp_literal_cnt+0 ; [3 zp][4 abs]
bne is_literal ; [2, +1, +2]
lda zp_literal_cnt+1 ; [3 zp][4 abs]
beq try_match ; [2, +1, +2]
.is_literal
.fetchByte2
; fetch a literal & stash in decode buffer
jsr lz_fetch_byte ; [6] +6 RTS
jsr lz_store_buffer ; [6] +6 RTS
sta stashA+1 ; **SELF MODIFICATION**
; for all literals
dec zp_literal_cnt+0 ; [5 zp][6 abs]
bne end_literal ; [2, +1, +2]
lda zp_literal_cnt+1 ; [3 zp][4 abs]
beq begin_matches ; [2, +1, +2]
dec zp_literal_cnt+1 ; [5 zp][6 abs]
bne end_literal
.begin_matches
; literals run completed
; now fetch match offset & length
.fetchByte3
; get match offset LO
jsr lz_fetch_byte
; set buffer read ptr
;sta zp_temp
sta stashS+1 ; **SELF MODIFICATION**
lda lz_window_dst + 0 ; *** SELF MODIFYING CODE ***
sec
.stashS
sbc #0 ; **SELFMODIFIED**
;sbc zp_temp
sta lz_window_src + 0 ; *** SELF MODIFYING CODE ***
IF LZ4_FORMAT
; fetch match offset HI, but ignore it.
; this implementation only supports 8-bit windows.
.fetchByte4
jsr lz_fetch_byte
ENDIF
; fetch match length
lda zp_match_cnt+0
jsr lz_fetch_count
; match length is always+4 (0=4)
; cant do this before because we need to detect 15
clc ; [2] (1)
adc #4 ; [2] (2)
sta zp_match_cnt+0 ; [3 zp, 4 abs] (2)
bcc store_hi ; [2, +1, +2] (2)
inx ; [2] (1)
;inc zp_match_cnt+1 ; [5 zp, 6 abs] (2)
.store_hi
stx zp_match_cnt+1 ; [3 zp, 4 abs](2)
.end_literal
.stashA
lda #0 ;**SELFMODIFIED - See above**
rts
; try fetching a matched byte from the stream
.try_match
lda zp_match_cnt+1
bne is_match
lda zp_match_cnt+0
; all matches done, so get a new token.
beq try_token
.is_match
jsr lz_fetch_buffer ; fetch matched byte from decode buffer
jsr lz_store_buffer ; stash in decode buffer
sta stashAA+1 ; **SELF MODIFICATION**
; for all matches
; we know match cnt is at least 1
lda zp_match_cnt+0
bne skiphi
dec zp_match_cnt+1
.skiphi
dec zp_match_cnt+0
.end_match
.stashAA
lda #0 ; **SELF MODIFIED - See above **
rts
; then token parser
.try_token
.fetchByte5
; fetch a token
jsr lz_fetch_byte
tax
ldy #0
; unpack match length from token (bottom 4 bits)
and #&0f
sta zp_match_cnt+0
sty zp_match_cnt+1
; unpack literal length from token (top 4 bits)
txa
lsr a
lsr a
lsr a
lsr a
; fetch literal extended length, passing in A
jsr lz_fetch_count
sta zp_literal_cnt+0
stx zp_literal_cnt+1
; if no literals, begin the match sequence
; and fetch one match byte
cmp #0
bne has_literals
jsr begin_matches
jmp try_match
.has_literals
; ok now go back to literal parser so we can return a byte
; if no literals, logic will fall through to matches
jmp try_literal
; fetch a byte from the currently selected compressed register data stream
; either huffman encoded or plain data
; returns byte in A, clobbers Y
.lz_fetch_byte
{
IF ENABLE_HUFFMAN == TRUE
IF HUFFMAN_INLINE == FALSE
; if bit7 of vgm_flags is set, its a huffman stream
bit vgm_flags ; [3 zp, 4 abs] (2)
bmi huff_fetch_byte ; [2, +1, +2] (2) see below
ENDIF ; HUFFMAN_INLINE
ENDIF ; ENABLE_HUFFMAN
; otherwise plain LZ4 byte fetch
ldy #0
lda (zp_stream_src),y
inc zp_stream_src+0
bne ok
inc zp_stream_src+1
.ok
rts
}
IF ENABLE_HUFFMAN
;-------------------------------
; huffman decoder routines
;-------------------------------
; TODO: Optimize with a peek buffer.
; 70-90% of codes are 7 bits or less. At 8 bits the % is higher.
; Peek buffer translates to two lookups and no loops.
; http://cbloomrants.blogspot.com/2010/08/08-11-10-huffman-arithmetic-equivalence.html
; 7 bits peek would require 2x 128 byte tables (256 bytes total extra to data stream).
; this routine must be located within branch reach of lz_fetch_byte()
.huff_fetch_byte
{
; code = codesize = firstcode = startindex = 0
lda #0
sta huff_code + 0
sta huff_code + 1
sta huff_codesize
sta huff_firstcode + 0
sta huff_firstcode + 1
sta huff_startindex
; skip over nextbit on first entry - this layout saves a jmp per bitlength
jmp decode_loop
}
.nextbit
{
; otherwise, move to the next bit length
; firstcode += numcodes
lda huff_firstcode + 0
clc
adc huff_numcodes
sta huff_firstcode + 0
lda huff_firstcode + 1
adc #0
sta huff_firstcode + 1
; firstcode <<= 1
asl huff_firstcode + 0
rol huff_firstcode + 1
; startindex += numcodes
lda huff_startindex
clc
adc huff_numcodes
sta huff_startindex
; keep going until we find a symbol
; falls into decode_loop
}
.decode_loop
{
; check if we need to refill bitbuffer
lda zp_huff_bitsleft
bne got_bits
; fetch 8 more bits
ldy #0
lda (huff_readptr), y
sta zp_huff_bitbuffer
lda #8
sta zp_huff_bitsleft
inc huff_readptr + 0
bne got_bits
inc huff_readptr + 1
.got_bits
; build code
; bitsleft -=1
dec zp_huff_bitsleft
; bit = (bitbuffer & 128) >> 7
; buffbuffer <<= 1
asl zp_huff_bitbuffer ; bit7 -> C
; code = (code << 1) | bit
rol huff_code + 0 ; C -> bit0, bit7 -> C
rol huff_code + 1 ; C -> bit8, bit15 -> C
; codesize += 1
inc huff_codesize
; how many canonical codes have this many bits?
; numCodes = length_table[codesize]
ldy huff_codesize
}
.LOAD_LENGTH_TABLE
{
lda &FFFF, Y ; ** MODIFIED ** See vgm_stream_mount
sta huff_numcodes
; if input code so far is within the range of the first code with the current number of bits, it's a match
; index = code - firstcode
sec
lda huff_code + 0
sbc huff_firstcode + 0
sta huff_index + 0
lda huff_code + 1
sbc huff_firstcode + 1
sta huff_index + 1
; if index < numcodes:
; if hi byte is non zero, is definitely > numcodes
; or numcodes >= index
bne nextbit
; we found our code, determine which symbol index it has.
lda huff_index
cmp huff_numcodes
bcs nextbit
; code = startindex + index
lda huff_startindex
clc
adc huff_index
tay
}
.LOAD_SYMBOL_TABLE
{
; return symbol_table[code]
lda &FFFF, Y ; ** MODIFIED ** See vgm_stream_mount
rts
}
ENDIF ; ENABLE_HUFFMAN
.decoder_end
PRINT " decoder code size is", (decoder_end-decoder_start), "bytes"
PRINT " vgm player code size is", (vgm_end-vgm_start), "bytes"
PRINT "total vgm player size is", (decoder_end-decoder_start) + (vgm_end-vgm_start), "bytes"
PRINT " vgm buffer size is", (vgm_buffer_end-vgm_buffer_start), "bytes"
|
; int adler32file(char* filepath, int* result);
global adler32file
extern CreateFileA
extern CloseHandle
extern ReadFile
; ======= Configure here the best size for your system =======
%define BUFFER_SIZE 65536
; ============================================================
section .bss
buffer resb BUFFER_SIZE
section .text
adler32file:
mov rbx,rdx ; adler32 output address
push rbp
mov rbp,rsp
push 0 ; lpSecurityAttributes = NULL
push 128 ; FILE_ATTRIBUTE_NORMAL
push 3 ; OPEN_EXISTING
sub rsp,32 ; shadow space, rcx contains file path
xor r9d,r9d
xor r8d,r8d
mov edx,-2147483648 ; GENERIC_READ
call CreateFileA ; used to read files too (windows kernel)
leave
cmp rax,-1 ; INVALID_HANDLE_VALUE
jz open_error
mov r15,rax ; file handle
mov r14,65521 ; MOD_ADLER
mov r13,1 ; s1 == r13d
xor r12,r12 ; s2 == r12d
read_input: ; synchronous read and processing (blocking input and output)
mov rcx,r15
lea rdx,[rel buffer]
mov r8,BUFFER_SIZE
sub rsp,8
lea r9,[rsp] ; bytes read
push rbp
mov rbp,rsp
push 0
sub rsp,32
call ReadFile
leave
pop r11
test rax,rax
je read_error
test r11,r11
je close
lea rdi,[rel buffer] ; start buffer address
lea rsi,[rel buffer+r11] ; end buffer address
process_buffer:
movzx rax,byte [rdi]
add eax,r13d
xor rdx,rdx
div r14d
mov r13d,edx
add r12d,r13d
mov eax,r12d
xor rdx,rdx
div r14d
mov r12d,edx
inc rdi
cmp rdi,rsi
jl process_buffer
jmp read_input
close:
shl r12d,16
add r13d,r12d ; update *result with adler32
mov [rbx],r13d
mov rcx,r15
call CloseHandle
test rax,rax
je close_error
xor rax,rax
ret
open_error:
mov rax,1
ret
close_error:
mov rax,2
ret
read_error:
mov rcx,r15
call CloseHandle ; try to close to avoid memory leak
mov rax,3
ret
|
#include "../RadioHandler.h"
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r15
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x1246b, %r10
nop
xor $995, %r12
movb $0x61, (%r10)
nop
nop
nop
sub $35894, %rdx
lea addresses_UC_ht+0xc47b, %r10
and %r12, %r12
movl $0x61626364, (%r10)
nop
nop
nop
nop
inc %r15
lea addresses_normal_ht+0xaccb, %rdx
nop
nop
nop
nop
mfence
mov (%rdx), %rsi
sub $39032, %r12
lea addresses_WT_ht+0x28e5, %r12
nop
nop
and $64721, %rdx
vmovups (%r12), %ymm4
vextracti128 $0, %ymm4, %xmm4
vpextrq $1, %xmm4, %r10
nop
and $48801, %rdx
lea addresses_WC_ht+0x761d, %rsi
lea addresses_WT_ht+0x1a6ab, %rdi
nop
nop
nop
nop
nop
xor $27586, %rbp
mov $126, %rcx
rep movsq
nop
nop
sub %r15, %r15
lea addresses_WT_ht+0x13d0b, %rdx
nop
nop
nop
cmp $38367, %rdi
mov (%rdx), %r15w
nop
nop
nop
nop
nop
cmp $52008, %r12
lea addresses_A_ht+0x1458b, %r10
nop
xor %r15, %r15
mov (%r10), %bp
nop
inc %rcx
lea addresses_normal_ht+0x1620b, %rdx
clflush (%rdx)
nop
add %rsi, %rsi
mov (%rdx), %r12
sub %rdi, %rdi
lea addresses_normal_ht+0x39db, %rsi
lea addresses_normal_ht+0x228b, %rdi
nop
nop
nop
nop
nop
add $12889, %r15
mov $117, %rcx
rep movsw
nop
nop
nop
add $60356, %rdi
lea addresses_WC_ht+0x19093, %rdi
cmp %rdx, %rdx
mov (%rdi), %r12
cmp $56023, %r10
lea addresses_WT_ht+0xe08b, %rdi
nop
nop
nop
nop
xor %r15, %r15
vmovups (%rdi), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $0, %xmm0, %rsi
nop
sub %rsi, %rsi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r15
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r14
push %r9
push %rcx
push %rsi
// Store
mov $0xb9b, %r12
nop
nop
nop
nop
nop
and %rsi, %rsi
mov $0x5152535455565758, %rcx
movq %rcx, %xmm2
movups %xmm2, (%r12)
nop
nop
cmp $5025, %rcx
// Faulty Load
lea addresses_normal+0x1560b, %r14
nop
and %r13, %r13
vmovups (%r14), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $1, %xmm3, %rcx
lea oracles, %r14
and $0xff, %rcx
shlq $12, %rcx
mov (%r14,%rcx,1), %rcx
pop %rsi
pop %rcx
pop %r9
pop %r14
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': False, 'NT': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_P', 'AVXalign': False, 'congruent': 3, 'size': 16, 'same': False, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'AVXalign': False, 'congruent': 0, 'size': 32, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 3, 'size': 1, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 4, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 0, 'size': 8, 'same': True, 'NT': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'congruent': 1, 'size': 32, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'AVXalign': True, 'congruent': 8, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 6, 'size': 2, 'same': True, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 9, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 7, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 1, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'congruent': 6, 'size': 32, 'same': False, 'NT': False}}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
int n, m;
cin >> n >> m;
vector <double> v;
for(int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
double cost = (a * 1.0) / (b * 1.0);
v.push_back(cost);
}
sort(v.begin(), v.end());
double ans = v[0] * m;
printf("%0.10f\n", ans);
return 0;
} |
_usertests: formato do arquivo elf32-i386
Desmontagem da seção .text:
00000000 <main>:
return randstate;
}
int
main(int argc, char *argv[])
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 51 push %ecx
e: 83 ec 0c sub $0xc,%esp
printf(1, "usertests starting\n");
11: 68 bf 4d 00 00 push $0x4dbf
16: 6a 01 push $0x1
18: e8 93 3a 00 00 call 3ab0 <printf>
if(open("usertests.ran", 0) >= 0){
1d: 5a pop %edx
1e: 59 pop %ecx
1f: 6a 00 push $0x0
21: 68 d3 4d 00 00 push $0x4dd3
26: e8 77 39 00 00 call 39a2 <open>
2b: 83 c4 10 add $0x10,%esp
2e: 85 c0 test %eax,%eax
30: 78 14 js 46 <main+0x46>
printf(1, "already ran user tests -- rebuild fs.img\n");
32: 83 ec 08 sub $0x8,%esp
35: 68 3c 55 00 00 push $0x553c
3a: 6a 01 push $0x1
3c: e8 6f 3a 00 00 call 3ab0 <printf>
exit();
41: e8 1c 39 00 00 call 3962 <exit>
}
close(open("usertests.ran", O_CREATE));
46: 50 push %eax
47: 50 push %eax
48: 68 00 02 00 00 push $0x200
4d: 68 d3 4d 00 00 push $0x4dd3
52: e8 4b 39 00 00 call 39a2 <open>
57: 89 04 24 mov %eax,(%esp)
5a: e8 2b 39 00 00 call 398a <close>
argptest();
5f: e8 2c 36 00 00 call 3690 <argptest>
createdelete();
64: e8 c7 11 00 00 call 1230 <createdelete>
linkunlink();
69: e8 b2 1a 00 00 call 1b20 <linkunlink>
concreate();
6e: e8 7d 17 00 00 call 17f0 <concreate>
fourfiles();
73: e8 b8 0f 00 00 call 1030 <fourfiles>
sharedfd();
78: e8 f3 0d 00 00 call e70 <sharedfd>
bigargtest();
7d: e8 8e 32 00 00 call 3310 <bigargtest>
bigwrite();
82: e8 b9 23 00 00 call 2440 <bigwrite>
bigargtest();
87: e8 84 32 00 00 call 3310 <bigargtest>
bsstest();
8c: e8 0f 32 00 00 call 32a0 <bsstest>
sbrktest();
91: e8 fa 2c 00 00 call 2d90 <sbrktest>
validatetest();
96: e8 45 31 00 00 call 31e0 <validatetest>
opentest();
9b: e8 60 03 00 00 call 400 <opentest>
writetest();
a0: e8 eb 03 00 00 call 490 <writetest>
writetest1();
a5: e8 c6 05 00 00 call 670 <writetest1>
createtest();
aa: e8 91 07 00 00 call 840 <createtest>
openiputtest();
af: e8 3c 02 00 00 call 2f0 <openiputtest>
exitiputtest();
b4: e8 47 01 00 00 call 200 <exitiputtest>
iputtest();
b9: e8 62 00 00 00 call 120 <iputtest>
mem();
be: e8 dd 0c 00 00 call da0 <mem>
pipe1();
c3: e8 58 09 00 00 call a20 <pipe1>
preempt();
c8: e8 f3 0a 00 00 call bc0 <preempt>
exitwait();
cd: e8 3e 0c 00 00 call d10 <exitwait>
rmdot();
d2: e8 59 27 00 00 call 2830 <rmdot>
fourteen();
d7: e8 14 26 00 00 call 26f0 <fourteen>
bigfile();
dc: e8 3f 24 00 00 call 2520 <bigfile>
subdir();
e1: e8 7a 1c 00 00 call 1d60 <subdir>
linktest();
e6: e8 f5 14 00 00 call 15e0 <linktest>
unlinkread();
eb: e8 60 13 00 00 call 1450 <unlinkread>
dirfile();
f0: e8 bb 28 00 00 call 29b0 <dirfile>
iref();
f5: e8 b6 2a 00 00 call 2bb0 <iref>
forktest();
fa: e8 d1 2b 00 00 call 2cd0 <forktest>
bigdir(); // slow
ff: e8 2c 1b 00 00 call 1c30 <bigdir>
uio();
104: e8 07 35 00 00 call 3610 <uio>
exectest();
109: e8 c2 08 00 00 call 9d0 <exectest>
exit();
10e: e8 4f 38 00 00 call 3962 <exit>
113: 66 90 xchg %ax,%ax
115: 66 90 xchg %ax,%ax
117: 66 90 xchg %ax,%ax
119: 66 90 xchg %ax,%ax
11b: 66 90 xchg %ax,%ax
11d: 66 90 xchg %ax,%ax
11f: 90 nop
00000120 <iputtest>:
int stdout = 1;
// does chdir() call iput(p->cwd) in a transaction?
void
iputtest(void)
{
120: 55 push %ebp
121: 89 e5 mov %esp,%ebp
123: 83 ec 10 sub $0x10,%esp
printf(stdout, "iput test\n");
126: 68 64 3e 00 00 push $0x3e64
12b: ff 35 64 5e 00 00 pushl 0x5e64
131: e8 7a 39 00 00 call 3ab0 <printf>
if(mkdir("iputdir") < 0){
136: c7 04 24 f7 3d 00 00 movl $0x3df7,(%esp)
13d: e8 88 38 00 00 call 39ca <mkdir>
142: 83 c4 10 add $0x10,%esp
145: 85 c0 test %eax,%eax
147: 78 58 js 1a1 <iputtest+0x81>
printf(stdout, "mkdir failed\n");
exit();
}
if(chdir("iputdir") < 0){
149: 83 ec 0c sub $0xc,%esp
14c: 68 f7 3d 00 00 push $0x3df7
151: e8 7c 38 00 00 call 39d2 <chdir>
156: 83 c4 10 add $0x10,%esp
159: 85 c0 test %eax,%eax
15b: 0f 88 85 00 00 00 js 1e6 <iputtest+0xc6>
printf(stdout, "chdir iputdir failed\n");
exit();
}
if(unlink("../iputdir") < 0){
161: 83 ec 0c sub $0xc,%esp
164: 68 f4 3d 00 00 push $0x3df4
169: e8 44 38 00 00 call 39b2 <unlink>
16e: 83 c4 10 add $0x10,%esp
171: 85 c0 test %eax,%eax
173: 78 5a js 1cf <iputtest+0xaf>
printf(stdout, "unlink ../iputdir failed\n");
exit();
}
if(chdir("/") < 0){
175: 83 ec 0c sub $0xc,%esp
178: 68 19 3e 00 00 push $0x3e19
17d: e8 50 38 00 00 call 39d2 <chdir>
182: 83 c4 10 add $0x10,%esp
185: 85 c0 test %eax,%eax
187: 78 2f js 1b8 <iputtest+0x98>
printf(stdout, "chdir / failed\n");
exit();
}
printf(stdout, "iput test ok\n");
189: 83 ec 08 sub $0x8,%esp
18c: 68 9c 3e 00 00 push $0x3e9c
191: ff 35 64 5e 00 00 pushl 0x5e64
197: e8 14 39 00 00 call 3ab0 <printf>
}
19c: 83 c4 10 add $0x10,%esp
19f: c9 leave
1a0: c3 ret
iputtest(void)
{
printf(stdout, "iput test\n");
if(mkdir("iputdir") < 0){
printf(stdout, "mkdir failed\n");
1a1: 50 push %eax
1a2: 50 push %eax
1a3: 68 d0 3d 00 00 push $0x3dd0
1a8: ff 35 64 5e 00 00 pushl 0x5e64
1ae: e8 fd 38 00 00 call 3ab0 <printf>
exit();
1b3: e8 aa 37 00 00 call 3962 <exit>
if(unlink("../iputdir") < 0){
printf(stdout, "unlink ../iputdir failed\n");
exit();
}
if(chdir("/") < 0){
printf(stdout, "chdir / failed\n");
1b8: 50 push %eax
1b9: 50 push %eax
1ba: 68 1b 3e 00 00 push $0x3e1b
1bf: ff 35 64 5e 00 00 pushl 0x5e64
1c5: e8 e6 38 00 00 call 3ab0 <printf>
exit();
1ca: e8 93 37 00 00 call 3962 <exit>
if(chdir("iputdir") < 0){
printf(stdout, "chdir iputdir failed\n");
exit();
}
if(unlink("../iputdir") < 0){
printf(stdout, "unlink ../iputdir failed\n");
1cf: 52 push %edx
1d0: 52 push %edx
1d1: 68 ff 3d 00 00 push $0x3dff
1d6: ff 35 64 5e 00 00 pushl 0x5e64
1dc: e8 cf 38 00 00 call 3ab0 <printf>
exit();
1e1: e8 7c 37 00 00 call 3962 <exit>
if(mkdir("iputdir") < 0){
printf(stdout, "mkdir failed\n");
exit();
}
if(chdir("iputdir") < 0){
printf(stdout, "chdir iputdir failed\n");
1e6: 51 push %ecx
1e7: 51 push %ecx
1e8: 68 de 3d 00 00 push $0x3dde
1ed: ff 35 64 5e 00 00 pushl 0x5e64
1f3: e8 b8 38 00 00 call 3ab0 <printf>
exit();
1f8: e8 65 37 00 00 call 3962 <exit>
1fd: 8d 76 00 lea 0x0(%esi),%esi
00000200 <exitiputtest>:
}
// does exit() call iput(p->cwd) in a transaction?
void
exitiputtest(void)
{
200: 55 push %ebp
201: 89 e5 mov %esp,%ebp
203: 83 ec 10 sub $0x10,%esp
int pid;
printf(stdout, "exitiput test\n");
206: 68 2b 3e 00 00 push $0x3e2b
20b: ff 35 64 5e 00 00 pushl 0x5e64
211: e8 9a 38 00 00 call 3ab0 <printf>
pid = fork(0);
216: c7 04 24 00 00 00 00 movl $0x0,(%esp)
21d: e8 38 37 00 00 call 395a <fork>
if(pid < 0){
222: 83 c4 10 add $0x10,%esp
225: 85 c0 test %eax,%eax
227: 78 7f js 2a8 <exitiputtest+0xa8>
printf(stdout, "fork failed\n");
exit();
}
if(pid == 0){
229: 75 45 jne 270 <exitiputtest+0x70>
if(mkdir("iputdir") < 0){
22b: 83 ec 0c sub $0xc,%esp
22e: 68 f7 3d 00 00 push $0x3df7
233: e8 92 37 00 00 call 39ca <mkdir>
238: 83 c4 10 add $0x10,%esp
23b: 85 c0 test %eax,%eax
23d: 0f 88 93 00 00 00 js 2d6 <exitiputtest+0xd6>
printf(stdout, "mkdir failed\n");
exit();
}
if(chdir("iputdir") < 0){
243: 83 ec 0c sub $0xc,%esp
246: 68 f7 3d 00 00 push $0x3df7
24b: e8 82 37 00 00 call 39d2 <chdir>
250: 83 c4 10 add $0x10,%esp
253: 85 c0 test %eax,%eax
255: 78 68 js 2bf <exitiputtest+0xbf>
printf(stdout, "child chdir failed\n");
exit();
}
if(unlink("../iputdir") < 0){
257: 83 ec 0c sub $0xc,%esp
25a: 68 f4 3d 00 00 push $0x3df4
25f: e8 4e 37 00 00 call 39b2 <unlink>
264: 83 c4 10 add $0x10,%esp
267: 85 c0 test %eax,%eax
269: 78 25 js 290 <exitiputtest+0x90>
printf(stdout, "unlink ../iputdir failed\n");
exit();
}
exit();
26b: e8 f2 36 00 00 call 3962 <exit>
}
wait();
270: e8 f5 36 00 00 call 396a <wait>
printf(stdout, "exitiput test ok\n");
275: 83 ec 08 sub $0x8,%esp
278: 68 4e 3e 00 00 push $0x3e4e
27d: ff 35 64 5e 00 00 pushl 0x5e64
283: e8 28 38 00 00 call 3ab0 <printf>
}
288: 83 c4 10 add $0x10,%esp
28b: c9 leave
28c: c3 ret
28d: 8d 76 00 lea 0x0(%esi),%esi
if(chdir("iputdir") < 0){
printf(stdout, "child chdir failed\n");
exit();
}
if(unlink("../iputdir") < 0){
printf(stdout, "unlink ../iputdir failed\n");
290: 83 ec 08 sub $0x8,%esp
293: 68 ff 3d 00 00 push $0x3dff
298: ff 35 64 5e 00 00 pushl 0x5e64
29e: e8 0d 38 00 00 call 3ab0 <printf>
exit();
2a3: e8 ba 36 00 00 call 3962 <exit>
printf(stdout, "exitiput test\n");
pid = fork(0);
if(pid < 0){
printf(stdout, "fork failed\n");
2a8: 51 push %ecx
2a9: 51 push %ecx
2aa: 68 12 4d 00 00 push $0x4d12
2af: ff 35 64 5e 00 00 pushl 0x5e64
2b5: e8 f6 37 00 00 call 3ab0 <printf>
exit();
2ba: e8 a3 36 00 00 call 3962 <exit>
if(mkdir("iputdir") < 0){
printf(stdout, "mkdir failed\n");
exit();
}
if(chdir("iputdir") < 0){
printf(stdout, "child chdir failed\n");
2bf: 50 push %eax
2c0: 50 push %eax
2c1: 68 3a 3e 00 00 push $0x3e3a
2c6: ff 35 64 5e 00 00 pushl 0x5e64
2cc: e8 df 37 00 00 call 3ab0 <printf>
exit();
2d1: e8 8c 36 00 00 call 3962 <exit>
printf(stdout, "fork failed\n");
exit();
}
if(pid == 0){
if(mkdir("iputdir") < 0){
printf(stdout, "mkdir failed\n");
2d6: 52 push %edx
2d7: 52 push %edx
2d8: 68 d0 3d 00 00 push $0x3dd0
2dd: ff 35 64 5e 00 00 pushl 0x5e64
2e3: e8 c8 37 00 00 call 3ab0 <printf>
exit();
2e8: e8 75 36 00 00 call 3962 <exit>
2ed: 8d 76 00 lea 0x0(%esi),%esi
000002f0 <openiputtest>:
// for(i = 0; i < 10000; i++)
// yield();
// }
void
openiputtest(void)
{
2f0: 55 push %ebp
2f1: 89 e5 mov %esp,%ebp
2f3: 83 ec 10 sub $0x10,%esp
int pid;
printf(stdout, "openiput test\n");
2f6: 68 60 3e 00 00 push $0x3e60
2fb: ff 35 64 5e 00 00 pushl 0x5e64
301: e8 aa 37 00 00 call 3ab0 <printf>
if(mkdir("oidir") < 0){
306: c7 04 24 6f 3e 00 00 movl $0x3e6f,(%esp)
30d: e8 b8 36 00 00 call 39ca <mkdir>
312: 83 c4 10 add $0x10,%esp
315: 85 c0 test %eax,%eax
317: 0f 88 90 00 00 00 js 3ad <openiputtest+0xbd>
printf(stdout, "mkdir oidir failed\n");
exit();
}
pid = fork(0);
31d: 83 ec 0c sub $0xc,%esp
320: 6a 00 push $0x0
322: e8 33 36 00 00 call 395a <fork>
if(pid < 0){
327: 83 c4 10 add $0x10,%esp
32a: 85 c0 test %eax,%eax
32c: 0f 88 92 00 00 00 js 3c4 <openiputtest+0xd4>
printf(stdout, "fork failed\n");
exit();
}
if(pid == 0){
332: 75 34 jne 368 <openiputtest+0x78>
int fd = open("oidir", O_RDWR);
334: 83 ec 08 sub $0x8,%esp
337: 6a 02 push $0x2
339: 68 6f 3e 00 00 push $0x3e6f
33e: e8 5f 36 00 00 call 39a2 <open>
if(fd >= 0){
343: 83 c4 10 add $0x10,%esp
346: 85 c0 test %eax,%eax
348: 78 5e js 3a8 <openiputtest+0xb8>
printf(stdout, "open directory for write succeeded\n");
34a: 83 ec 08 sub $0x8,%esp
34d: 68 f4 4d 00 00 push $0x4df4
352: ff 35 64 5e 00 00 pushl 0x5e64
358: e8 53 37 00 00 call 3ab0 <printf>
exit();
35d: e8 00 36 00 00 call 3962 <exit>
362: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
exit();
}
sleep(1);
368: 83 ec 0c sub $0xc,%esp
36b: 6a 01 push $0x1
36d: e8 80 36 00 00 call 39f2 <sleep>
if(unlink("oidir") != 0){
372: c7 04 24 6f 3e 00 00 movl $0x3e6f,(%esp)
379: e8 34 36 00 00 call 39b2 <unlink>
37e: 83 c4 10 add $0x10,%esp
381: 85 c0 test %eax,%eax
383: 75 56 jne 3db <openiputtest+0xeb>
printf(stdout, "unlink failed\n");
exit();
}
wait();
385: e8 e0 35 00 00 call 396a <wait>
printf(stdout, "openiput test ok\n");
38a: 83 ec 08 sub $0x8,%esp
38d: 68 98 3e 00 00 push $0x3e98
392: ff 35 64 5e 00 00 pushl 0x5e64
398: e8 13 37 00 00 call 3ab0 <printf>
}
39d: 83 c4 10 add $0x10,%esp
3a0: c9 leave
3a1: c3 ret
3a2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
int fd = open("oidir", O_RDWR);
if(fd >= 0){
printf(stdout, "open directory for write succeeded\n");
exit();
}
exit();
3a8: e8 b5 35 00 00 call 3962 <exit>
{
int pid;
printf(stdout, "openiput test\n");
if(mkdir("oidir") < 0){
printf(stdout, "mkdir oidir failed\n");
3ad: 51 push %ecx
3ae: 51 push %ecx
3af: 68 75 3e 00 00 push $0x3e75
3b4: ff 35 64 5e 00 00 pushl 0x5e64
3ba: e8 f1 36 00 00 call 3ab0 <printf>
exit();
3bf: e8 9e 35 00 00 call 3962 <exit>
}
pid = fork(0);
if(pid < 0){
printf(stdout, "fork failed\n");
3c4: 52 push %edx
3c5: 52 push %edx
3c6: 68 12 4d 00 00 push $0x4d12
3cb: ff 35 64 5e 00 00 pushl 0x5e64
3d1: e8 da 36 00 00 call 3ab0 <printf>
exit();
3d6: e8 87 35 00 00 call 3962 <exit>
}
exit();
}
sleep(1);
if(unlink("oidir") != 0){
printf(stdout, "unlink failed\n");
3db: 50 push %eax
3dc: 50 push %eax
3dd: 68 89 3e 00 00 push $0x3e89
3e2: ff 35 64 5e 00 00 pushl 0x5e64
3e8: e8 c3 36 00 00 call 3ab0 <printf>
exit();
3ed: e8 70 35 00 00 call 3962 <exit>
3f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000400 <opentest>:
// simple file system tests
void
opentest(void)
{
400: 55 push %ebp
401: 89 e5 mov %esp,%ebp
403: 83 ec 10 sub $0x10,%esp
int fd;
printf(stdout, "open test\n");
406: 68 aa 3e 00 00 push $0x3eaa
40b: ff 35 64 5e 00 00 pushl 0x5e64
411: e8 9a 36 00 00 call 3ab0 <printf>
fd = open("echo", 0);
416: 58 pop %eax
417: 5a pop %edx
418: 6a 00 push $0x0
41a: 68 b5 3e 00 00 push $0x3eb5
41f: e8 7e 35 00 00 call 39a2 <open>
if(fd < 0){
424: 83 c4 10 add $0x10,%esp
427: 85 c0 test %eax,%eax
429: 78 36 js 461 <opentest+0x61>
printf(stdout, "open echo failed!\n");
exit();
}
close(fd);
42b: 83 ec 0c sub $0xc,%esp
42e: 50 push %eax
42f: e8 56 35 00 00 call 398a <close>
fd = open("doesnotexist", 0);
434: 5a pop %edx
435: 59 pop %ecx
436: 6a 00 push $0x0
438: 68 cd 3e 00 00 push $0x3ecd
43d: e8 60 35 00 00 call 39a2 <open>
if(fd >= 0){
442: 83 c4 10 add $0x10,%esp
445: 85 c0 test %eax,%eax
447: 79 2f jns 478 <opentest+0x78>
printf(stdout, "open doesnotexist succeeded!\n");
exit();
}
printf(stdout, "open test ok\n");
449: 83 ec 08 sub $0x8,%esp
44c: 68 f8 3e 00 00 push $0x3ef8
451: ff 35 64 5e 00 00 pushl 0x5e64
457: e8 54 36 00 00 call 3ab0 <printf>
}
45c: 83 c4 10 add $0x10,%esp
45f: c9 leave
460: c3 ret
int fd;
printf(stdout, "open test\n");
fd = open("echo", 0);
if(fd < 0){
printf(stdout, "open echo failed!\n");
461: 50 push %eax
462: 50 push %eax
463: 68 ba 3e 00 00 push $0x3eba
468: ff 35 64 5e 00 00 pushl 0x5e64
46e: e8 3d 36 00 00 call 3ab0 <printf>
exit();
473: e8 ea 34 00 00 call 3962 <exit>
}
close(fd);
fd = open("doesnotexist", 0);
if(fd >= 0){
printf(stdout, "open doesnotexist succeeded!\n");
478: 50 push %eax
479: 50 push %eax
47a: 68 da 3e 00 00 push $0x3eda
47f: ff 35 64 5e 00 00 pushl 0x5e64
485: e8 26 36 00 00 call 3ab0 <printf>
exit();
48a: e8 d3 34 00 00 call 3962 <exit>
48f: 90 nop
00000490 <writetest>:
printf(stdout, "open test ok\n");
}
void
writetest(void)
{
490: 55 push %ebp
491: 89 e5 mov %esp,%ebp
493: 56 push %esi
494: 53 push %ebx
int fd;
int i;
printf(stdout, "small file test\n");
495: 83 ec 08 sub $0x8,%esp
498: 68 06 3f 00 00 push $0x3f06
49d: ff 35 64 5e 00 00 pushl 0x5e64
4a3: e8 08 36 00 00 call 3ab0 <printf>
fd = open("small", O_CREATE|O_RDWR);
4a8: 59 pop %ecx
4a9: 5b pop %ebx
4aa: 68 02 02 00 00 push $0x202
4af: 68 17 3f 00 00 push $0x3f17
4b4: e8 e9 34 00 00 call 39a2 <open>
if(fd >= 0){
4b9: 83 c4 10 add $0x10,%esp
4bc: 85 c0 test %eax,%eax
4be: 0f 88 8b 01 00 00 js 64f <writetest+0x1bf>
printf(stdout, "creat small succeeded; ok\n");
4c4: 83 ec 08 sub $0x8,%esp
4c7: 89 c6 mov %eax,%esi
} else {
printf(stdout, "error: creat small failed!\n");
exit();
}
for(i = 0; i < 100; i++){
4c9: 31 db xor %ebx,%ebx
int i;
printf(stdout, "small file test\n");
fd = open("small", O_CREATE|O_RDWR);
if(fd >= 0){
printf(stdout, "creat small succeeded; ok\n");
4cb: 68 1d 3f 00 00 push $0x3f1d
4d0: ff 35 64 5e 00 00 pushl 0x5e64
4d6: e8 d5 35 00 00 call 3ab0 <printf>
4db: 83 c4 10 add $0x10,%esp
4de: 66 90 xchg %ax,%ax
} else {
printf(stdout, "error: creat small failed!\n");
exit();
}
for(i = 0; i < 100; i++){
if(write(fd, "aaaaaaaaaa", 10) != 10){
4e0: 83 ec 04 sub $0x4,%esp
4e3: 6a 0a push $0xa
4e5: 68 54 3f 00 00 push $0x3f54
4ea: 56 push %esi
4eb: e8 92 34 00 00 call 3982 <write>
4f0: 83 c4 10 add $0x10,%esp
4f3: 83 f8 0a cmp $0xa,%eax
4f6: 0f 85 d9 00 00 00 jne 5d5 <writetest+0x145>
printf(stdout, "error: write aa %d new file failed\n", i);
exit();
}
if(write(fd, "bbbbbbbbbb", 10) != 10){
4fc: 83 ec 04 sub $0x4,%esp
4ff: 6a 0a push $0xa
501: 68 5f 3f 00 00 push $0x3f5f
506: 56 push %esi
507: e8 76 34 00 00 call 3982 <write>
50c: 83 c4 10 add $0x10,%esp
50f: 83 f8 0a cmp $0xa,%eax
512: 0f 85 d6 00 00 00 jne 5ee <writetest+0x15e>
printf(stdout, "creat small succeeded; ok\n");
} else {
printf(stdout, "error: creat small failed!\n");
exit();
}
for(i = 0; i < 100; i++){
518: 83 c3 01 add $0x1,%ebx
51b: 83 fb 64 cmp $0x64,%ebx
51e: 75 c0 jne 4e0 <writetest+0x50>
if(write(fd, "bbbbbbbbbb", 10) != 10){
printf(stdout, "error: write bb %d new file failed\n", i);
exit();
}
}
printf(stdout, "writes ok\n");
520: 83 ec 08 sub $0x8,%esp
523: 68 6a 3f 00 00 push $0x3f6a
528: ff 35 64 5e 00 00 pushl 0x5e64
52e: e8 7d 35 00 00 call 3ab0 <printf>
close(fd);
533: 89 34 24 mov %esi,(%esp)
536: e8 4f 34 00 00 call 398a <close>
fd = open("small", O_RDONLY);
53b: 58 pop %eax
53c: 5a pop %edx
53d: 6a 00 push $0x0
53f: 68 17 3f 00 00 push $0x3f17
544: e8 59 34 00 00 call 39a2 <open>
if(fd >= 0){
549: 83 c4 10 add $0x10,%esp
54c: 85 c0 test %eax,%eax
exit();
}
}
printf(stdout, "writes ok\n");
close(fd);
fd = open("small", O_RDONLY);
54e: 89 c3 mov %eax,%ebx
if(fd >= 0){
550: 0f 88 b1 00 00 00 js 607 <writetest+0x177>
printf(stdout, "open small succeeded ok\n");
556: 83 ec 08 sub $0x8,%esp
559: 68 75 3f 00 00 push $0x3f75
55e: ff 35 64 5e 00 00 pushl 0x5e64
564: e8 47 35 00 00 call 3ab0 <printf>
} else {
printf(stdout, "error: open small failed!\n");
exit();
}
i = read(fd, buf, 2000);
569: 83 c4 0c add $0xc,%esp
56c: 68 d0 07 00 00 push $0x7d0
571: 68 40 86 00 00 push $0x8640
576: 53 push %ebx
577: e8 fe 33 00 00 call 397a <read>
if(i == 2000){
57c: 83 c4 10 add $0x10,%esp
57f: 3d d0 07 00 00 cmp $0x7d0,%eax
584: 0f 85 95 00 00 00 jne 61f <writetest+0x18f>
printf(stdout, "read succeeded ok\n");
58a: 83 ec 08 sub $0x8,%esp
58d: 68 a9 3f 00 00 push $0x3fa9
592: ff 35 64 5e 00 00 pushl 0x5e64
598: e8 13 35 00 00 call 3ab0 <printf>
} else {
printf(stdout, "read failed\n");
exit();
}
close(fd);
59d: 89 1c 24 mov %ebx,(%esp)
5a0: e8 e5 33 00 00 call 398a <close>
if(unlink("small") < 0){
5a5: c7 04 24 17 3f 00 00 movl $0x3f17,(%esp)
5ac: e8 01 34 00 00 call 39b2 <unlink>
5b1: 83 c4 10 add $0x10,%esp
5b4: 85 c0 test %eax,%eax
5b6: 78 7f js 637 <writetest+0x1a7>
printf(stdout, "unlink small failed\n");
exit();
}
printf(stdout, "small file test ok\n");
5b8: 83 ec 08 sub $0x8,%esp
5bb: 68 d1 3f 00 00 push $0x3fd1
5c0: ff 35 64 5e 00 00 pushl 0x5e64
5c6: e8 e5 34 00 00 call 3ab0 <printf>
}
5cb: 83 c4 10 add $0x10,%esp
5ce: 8d 65 f8 lea -0x8(%ebp),%esp
5d1: 5b pop %ebx
5d2: 5e pop %esi
5d3: 5d pop %ebp
5d4: c3 ret
printf(stdout, "error: creat small failed!\n");
exit();
}
for(i = 0; i < 100; i++){
if(write(fd, "aaaaaaaaaa", 10) != 10){
printf(stdout, "error: write aa %d new file failed\n", i);
5d5: 83 ec 04 sub $0x4,%esp
5d8: 53 push %ebx
5d9: 68 18 4e 00 00 push $0x4e18
5de: ff 35 64 5e 00 00 pushl 0x5e64
5e4: e8 c7 34 00 00 call 3ab0 <printf>
exit();
5e9: e8 74 33 00 00 call 3962 <exit>
}
if(write(fd, "bbbbbbbbbb", 10) != 10){
printf(stdout, "error: write bb %d new file failed\n", i);
5ee: 83 ec 04 sub $0x4,%esp
5f1: 53 push %ebx
5f2: 68 3c 4e 00 00 push $0x4e3c
5f7: ff 35 64 5e 00 00 pushl 0x5e64
5fd: e8 ae 34 00 00 call 3ab0 <printf>
exit();
602: e8 5b 33 00 00 call 3962 <exit>
close(fd);
fd = open("small", O_RDONLY);
if(fd >= 0){
printf(stdout, "open small succeeded ok\n");
} else {
printf(stdout, "error: open small failed!\n");
607: 83 ec 08 sub $0x8,%esp
60a: 68 8e 3f 00 00 push $0x3f8e
60f: ff 35 64 5e 00 00 pushl 0x5e64
615: e8 96 34 00 00 call 3ab0 <printf>
exit();
61a: e8 43 33 00 00 call 3962 <exit>
}
i = read(fd, buf, 2000);
if(i == 2000){
printf(stdout, "read succeeded ok\n");
} else {
printf(stdout, "read failed\n");
61f: 83 ec 08 sub $0x8,%esp
622: 68 d6 42 00 00 push $0x42d6
627: ff 35 64 5e 00 00 pushl 0x5e64
62d: e8 7e 34 00 00 call 3ab0 <printf>
exit();
632: e8 2b 33 00 00 call 3962 <exit>
}
close(fd);
if(unlink("small") < 0){
printf(stdout, "unlink small failed\n");
637: 83 ec 08 sub $0x8,%esp
63a: 68 bc 3f 00 00 push $0x3fbc
63f: ff 35 64 5e 00 00 pushl 0x5e64
645: e8 66 34 00 00 call 3ab0 <printf>
exit();
64a: e8 13 33 00 00 call 3962 <exit>
printf(stdout, "small file test\n");
fd = open("small", O_CREATE|O_RDWR);
if(fd >= 0){
printf(stdout, "creat small succeeded; ok\n");
} else {
printf(stdout, "error: creat small failed!\n");
64f: 83 ec 08 sub $0x8,%esp
652: 68 38 3f 00 00 push $0x3f38
657: ff 35 64 5e 00 00 pushl 0x5e64
65d: e8 4e 34 00 00 call 3ab0 <printf>
exit();
662: e8 fb 32 00 00 call 3962 <exit>
667: 89 f6 mov %esi,%esi
669: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000670 <writetest1>:
printf(stdout, "small file test ok\n");
}
void
writetest1(void)
{
670: 55 push %ebp
671: 89 e5 mov %esp,%ebp
673: 56 push %esi
674: 53 push %ebx
int i, fd, n;
printf(stdout, "big files test\n");
675: 83 ec 08 sub $0x8,%esp
678: 68 e5 3f 00 00 push $0x3fe5
67d: ff 35 64 5e 00 00 pushl 0x5e64
683: e8 28 34 00 00 call 3ab0 <printf>
fd = open("big", O_CREATE|O_RDWR);
688: 59 pop %ecx
689: 5b pop %ebx
68a: 68 02 02 00 00 push $0x202
68f: 68 5f 40 00 00 push $0x405f
694: e8 09 33 00 00 call 39a2 <open>
if(fd < 0){
699: 83 c4 10 add $0x10,%esp
69c: 85 c0 test %eax,%eax
69e: 0f 88 64 01 00 00 js 808 <writetest1+0x198>
6a4: 89 c6 mov %eax,%esi
6a6: 31 db xor %ebx,%ebx
6a8: 90 nop
6a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
exit();
}
for(i = 0; i < MAXFILE; i++){
((int*)buf)[0] = i;
if(write(fd, buf, 512) != 512){
6b0: 83 ec 04 sub $0x4,%esp
printf(stdout, "error: creat big failed!\n");
exit();
}
for(i = 0; i < MAXFILE; i++){
((int*)buf)[0] = i;
6b3: 89 1d 40 86 00 00 mov %ebx,0x8640
if(write(fd, buf, 512) != 512){
6b9: 68 00 02 00 00 push $0x200
6be: 68 40 86 00 00 push $0x8640
6c3: 56 push %esi
6c4: e8 b9 32 00 00 call 3982 <write>
6c9: 83 c4 10 add $0x10,%esp
6cc: 3d 00 02 00 00 cmp $0x200,%eax
6d1: 0f 85 b3 00 00 00 jne 78a <writetest1+0x11a>
if(fd < 0){
printf(stdout, "error: creat big failed!\n");
exit();
}
for(i = 0; i < MAXFILE; i++){
6d7: 83 c3 01 add $0x1,%ebx
6da: 81 fb 8c 00 00 00 cmp $0x8c,%ebx
6e0: 75 ce jne 6b0 <writetest1+0x40>
printf(stdout, "error: write big file failed\n", i);
exit();
}
}
close(fd);
6e2: 83 ec 0c sub $0xc,%esp
6e5: 56 push %esi
6e6: e8 9f 32 00 00 call 398a <close>
fd = open("big", O_RDONLY);
6eb: 58 pop %eax
6ec: 5a pop %edx
6ed: 6a 00 push $0x0
6ef: 68 5f 40 00 00 push $0x405f
6f4: e8 a9 32 00 00 call 39a2 <open>
if(fd < 0){
6f9: 83 c4 10 add $0x10,%esp
6fc: 85 c0 test %eax,%eax
}
}
close(fd);
fd = open("big", O_RDONLY);
6fe: 89 c6 mov %eax,%esi
if(fd < 0){
700: 0f 88 ea 00 00 00 js 7f0 <writetest1+0x180>
706: 31 db xor %ebx,%ebx
708: eb 1d jmp 727 <writetest1+0xb7>
70a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(n == MAXFILE - 1){
printf(stdout, "read only %d blocks from big", n);
exit();
}
break;
} else if(i != 512){
710: 3d 00 02 00 00 cmp $0x200,%eax
715: 0f 85 9f 00 00 00 jne 7ba <writetest1+0x14a>
printf(stdout, "read failed %d\n", i);
exit();
}
if(((int*)buf)[0] != n){
71b: a1 40 86 00 00 mov 0x8640,%eax
720: 39 c3 cmp %eax,%ebx
722: 75 7f jne 7a3 <writetest1+0x133>
printf(stdout, "read content of block %d is %d\n",
n, ((int*)buf)[0]);
exit();
}
n++;
724: 83 c3 01 add $0x1,%ebx
exit();
}
n = 0;
for(;;){
i = read(fd, buf, 512);
727: 83 ec 04 sub $0x4,%esp
72a: 68 00 02 00 00 push $0x200
72f: 68 40 86 00 00 push $0x8640
734: 56 push %esi
735: e8 40 32 00 00 call 397a <read>
if(i == 0){
73a: 83 c4 10 add $0x10,%esp
73d: 85 c0 test %eax,%eax
73f: 75 cf jne 710 <writetest1+0xa0>
if(n == MAXFILE - 1){
741: 81 fb 8b 00 00 00 cmp $0x8b,%ebx
747: 0f 84 86 00 00 00 je 7d3 <writetest1+0x163>
n, ((int*)buf)[0]);
exit();
}
n++;
}
close(fd);
74d: 83 ec 0c sub $0xc,%esp
750: 56 push %esi
751: e8 34 32 00 00 call 398a <close>
if(unlink("big") < 0){
756: c7 04 24 5f 40 00 00 movl $0x405f,(%esp)
75d: e8 50 32 00 00 call 39b2 <unlink>
762: 83 c4 10 add $0x10,%esp
765: 85 c0 test %eax,%eax
767: 0f 88 b3 00 00 00 js 820 <writetest1+0x1b0>
printf(stdout, "unlink big failed\n");
exit();
}
printf(stdout, "big files ok\n");
76d: 83 ec 08 sub $0x8,%esp
770: 68 86 40 00 00 push $0x4086
775: ff 35 64 5e 00 00 pushl 0x5e64
77b: e8 30 33 00 00 call 3ab0 <printf>
}
780: 83 c4 10 add $0x10,%esp
783: 8d 65 f8 lea -0x8(%ebp),%esp
786: 5b pop %ebx
787: 5e pop %esi
788: 5d pop %ebp
789: c3 ret
}
for(i = 0; i < MAXFILE; i++){
((int*)buf)[0] = i;
if(write(fd, buf, 512) != 512){
printf(stdout, "error: write big file failed\n", i);
78a: 83 ec 04 sub $0x4,%esp
78d: 53 push %ebx
78e: 68 0f 40 00 00 push $0x400f
793: ff 35 64 5e 00 00 pushl 0x5e64
799: e8 12 33 00 00 call 3ab0 <printf>
exit();
79e: e8 bf 31 00 00 call 3962 <exit>
} else if(i != 512){
printf(stdout, "read failed %d\n", i);
exit();
}
if(((int*)buf)[0] != n){
printf(stdout, "read content of block %d is %d\n",
7a3: 50 push %eax
7a4: 53 push %ebx
7a5: 68 60 4e 00 00 push $0x4e60
7aa: ff 35 64 5e 00 00 pushl 0x5e64
7b0: e8 fb 32 00 00 call 3ab0 <printf>
n, ((int*)buf)[0]);
exit();
7b5: e8 a8 31 00 00 call 3962 <exit>
printf(stdout, "read only %d blocks from big", n);
exit();
}
break;
} else if(i != 512){
printf(stdout, "read failed %d\n", i);
7ba: 83 ec 04 sub $0x4,%esp
7bd: 50 push %eax
7be: 68 63 40 00 00 push $0x4063
7c3: ff 35 64 5e 00 00 pushl 0x5e64
7c9: e8 e2 32 00 00 call 3ab0 <printf>
exit();
7ce: e8 8f 31 00 00 call 3962 <exit>
n = 0;
for(;;){
i = read(fd, buf, 512);
if(i == 0){
if(n == MAXFILE - 1){
printf(stdout, "read only %d blocks from big", n);
7d3: 83 ec 04 sub $0x4,%esp
7d6: 68 8b 00 00 00 push $0x8b
7db: 68 46 40 00 00 push $0x4046
7e0: ff 35 64 5e 00 00 pushl 0x5e64
7e6: e8 c5 32 00 00 call 3ab0 <printf>
exit();
7eb: e8 72 31 00 00 call 3962 <exit>
close(fd);
fd = open("big", O_RDONLY);
if(fd < 0){
printf(stdout, "error: open big failed!\n");
7f0: 83 ec 08 sub $0x8,%esp
7f3: 68 2d 40 00 00 push $0x402d
7f8: ff 35 64 5e 00 00 pushl 0x5e64
7fe: e8 ad 32 00 00 call 3ab0 <printf>
exit();
803: e8 5a 31 00 00 call 3962 <exit>
printf(stdout, "big files test\n");
fd = open("big", O_CREATE|O_RDWR);
if(fd < 0){
printf(stdout, "error: creat big failed!\n");
808: 83 ec 08 sub $0x8,%esp
80b: 68 f5 3f 00 00 push $0x3ff5
810: ff 35 64 5e 00 00 pushl 0x5e64
816: e8 95 32 00 00 call 3ab0 <printf>
exit();
81b: e8 42 31 00 00 call 3962 <exit>
}
n++;
}
close(fd);
if(unlink("big") < 0){
printf(stdout, "unlink big failed\n");
820: 83 ec 08 sub $0x8,%esp
823: 68 73 40 00 00 push $0x4073
828: ff 35 64 5e 00 00 pushl 0x5e64
82e: e8 7d 32 00 00 call 3ab0 <printf>
exit();
833: e8 2a 31 00 00 call 3962 <exit>
838: 90 nop
839: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000840 <createtest>:
printf(stdout, "big files ok\n");
}
void
createtest(void)
{
840: 55 push %ebp
841: 89 e5 mov %esp,%ebp
843: 53 push %ebx
int i, fd;
printf(stdout, "many creates, followed by unlink test\n");
name[0] = 'a';
name[2] = '\0';
844: bb 30 00 00 00 mov $0x30,%ebx
printf(stdout, "big files ok\n");
}
void
createtest(void)
{
849: 83 ec 0c sub $0xc,%esp
int i, fd;
printf(stdout, "many creates, followed by unlink test\n");
84c: 68 80 4e 00 00 push $0x4e80
851: ff 35 64 5e 00 00 pushl 0x5e64
857: e8 54 32 00 00 call 3ab0 <printf>
name[0] = 'a';
85c: c6 05 40 a6 00 00 61 movb $0x61,0xa640
name[2] = '\0';
863: c6 05 42 a6 00 00 00 movb $0x0,0xa642
86a: 83 c4 10 add $0x10,%esp
86d: 8d 76 00 lea 0x0(%esi),%esi
for(i = 0; i < 52; i++){
name[1] = '0' + i;
fd = open(name, O_CREATE|O_RDWR);
870: 83 ec 08 sub $0x8,%esp
printf(stdout, "many creates, followed by unlink test\n");
name[0] = 'a';
name[2] = '\0';
for(i = 0; i < 52; i++){
name[1] = '0' + i;
873: 88 1d 41 a6 00 00 mov %bl,0xa641
879: 83 c3 01 add $0x1,%ebx
fd = open(name, O_CREATE|O_RDWR);
87c: 68 02 02 00 00 push $0x202
881: 68 40 a6 00 00 push $0xa640
886: e8 17 31 00 00 call 39a2 <open>
close(fd);
88b: 89 04 24 mov %eax,(%esp)
88e: e8 f7 30 00 00 call 398a <close>
printf(stdout, "many creates, followed by unlink test\n");
name[0] = 'a';
name[2] = '\0';
for(i = 0; i < 52; i++){
893: 83 c4 10 add $0x10,%esp
896: 80 fb 64 cmp $0x64,%bl
899: 75 d5 jne 870 <createtest+0x30>
name[1] = '0' + i;
fd = open(name, O_CREATE|O_RDWR);
close(fd);
}
name[0] = 'a';
89b: c6 05 40 a6 00 00 61 movb $0x61,0xa640
name[2] = '\0';
8a2: c6 05 42 a6 00 00 00 movb $0x0,0xa642
8a9: bb 30 00 00 00 mov $0x30,%ebx
8ae: 66 90 xchg %ax,%ax
for(i = 0; i < 52; i++){
name[1] = '0' + i;
unlink(name);
8b0: 83 ec 0c sub $0xc,%esp
close(fd);
}
name[0] = 'a';
name[2] = '\0';
for(i = 0; i < 52; i++){
name[1] = '0' + i;
8b3: 88 1d 41 a6 00 00 mov %bl,0xa641
8b9: 83 c3 01 add $0x1,%ebx
unlink(name);
8bc: 68 40 a6 00 00 push $0xa640
8c1: e8 ec 30 00 00 call 39b2 <unlink>
fd = open(name, O_CREATE|O_RDWR);
close(fd);
}
name[0] = 'a';
name[2] = '\0';
for(i = 0; i < 52; i++){
8c6: 83 c4 10 add $0x10,%esp
8c9: 80 fb 64 cmp $0x64,%bl
8cc: 75 e2 jne 8b0 <createtest+0x70>
name[1] = '0' + i;
unlink(name);
}
printf(stdout, "many creates, followed by unlink; ok\n");
8ce: 83 ec 08 sub $0x8,%esp
8d1: 68 a8 4e 00 00 push $0x4ea8
8d6: ff 35 64 5e 00 00 pushl 0x5e64
8dc: e8 cf 31 00 00 call 3ab0 <printf>
}
8e1: 83 c4 10 add $0x10,%esp
8e4: 8b 5d fc mov -0x4(%ebp),%ebx
8e7: c9 leave
8e8: c3 ret
8e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000008f0 <dirtest>:
void dirtest(void)
{
8f0: 55 push %ebp
8f1: 89 e5 mov %esp,%ebp
8f3: 83 ec 10 sub $0x10,%esp
printf(stdout, "mkdir test\n");
8f6: 68 94 40 00 00 push $0x4094
8fb: ff 35 64 5e 00 00 pushl 0x5e64
901: e8 aa 31 00 00 call 3ab0 <printf>
if(mkdir("dir0") < 0){
906: c7 04 24 a0 40 00 00 movl $0x40a0,(%esp)
90d: e8 b8 30 00 00 call 39ca <mkdir>
912: 83 c4 10 add $0x10,%esp
915: 85 c0 test %eax,%eax
917: 78 58 js 971 <dirtest+0x81>
printf(stdout, "mkdir failed\n");
exit();
}
if(chdir("dir0") < 0){
919: 83 ec 0c sub $0xc,%esp
91c: 68 a0 40 00 00 push $0x40a0
921: e8 ac 30 00 00 call 39d2 <chdir>
926: 83 c4 10 add $0x10,%esp
929: 85 c0 test %eax,%eax
92b: 0f 88 85 00 00 00 js 9b6 <dirtest+0xc6>
printf(stdout, "chdir dir0 failed\n");
exit();
}
if(chdir("..") < 0){
931: 83 ec 0c sub $0xc,%esp
934: 68 46 46 00 00 push $0x4646
939: e8 94 30 00 00 call 39d2 <chdir>
93e: 83 c4 10 add $0x10,%esp
941: 85 c0 test %eax,%eax
943: 78 5a js 99f <dirtest+0xaf>
printf(stdout, "chdir .. failed\n");
exit();
}
if(unlink("dir0") < 0){
945: 83 ec 0c sub $0xc,%esp
948: 68 a0 40 00 00 push $0x40a0
94d: e8 60 30 00 00 call 39b2 <unlink>
952: 83 c4 10 add $0x10,%esp
955: 85 c0 test %eax,%eax
957: 78 2f js 988 <dirtest+0x98>
printf(stdout, "unlink dir0 failed\n");
exit();
}
printf(stdout, "mkdir test ok\n");
959: 83 ec 08 sub $0x8,%esp
95c: 68 dd 40 00 00 push $0x40dd
961: ff 35 64 5e 00 00 pushl 0x5e64
967: e8 44 31 00 00 call 3ab0 <printf>
}
96c: 83 c4 10 add $0x10,%esp
96f: c9 leave
970: c3 ret
void dirtest(void)
{
printf(stdout, "mkdir test\n");
if(mkdir("dir0") < 0){
printf(stdout, "mkdir failed\n");
971: 50 push %eax
972: 50 push %eax
973: 68 d0 3d 00 00 push $0x3dd0
978: ff 35 64 5e 00 00 pushl 0x5e64
97e: e8 2d 31 00 00 call 3ab0 <printf>
exit();
983: e8 da 2f 00 00 call 3962 <exit>
printf(stdout, "chdir .. failed\n");
exit();
}
if(unlink("dir0") < 0){
printf(stdout, "unlink dir0 failed\n");
988: 50 push %eax
989: 50 push %eax
98a: 68 c9 40 00 00 push $0x40c9
98f: ff 35 64 5e 00 00 pushl 0x5e64
995: e8 16 31 00 00 call 3ab0 <printf>
exit();
99a: e8 c3 2f 00 00 call 3962 <exit>
printf(stdout, "chdir dir0 failed\n");
exit();
}
if(chdir("..") < 0){
printf(stdout, "chdir .. failed\n");
99f: 52 push %edx
9a0: 52 push %edx
9a1: 68 b8 40 00 00 push $0x40b8
9a6: ff 35 64 5e 00 00 pushl 0x5e64
9ac: e8 ff 30 00 00 call 3ab0 <printf>
exit();
9b1: e8 ac 2f 00 00 call 3962 <exit>
printf(stdout, "mkdir failed\n");
exit();
}
if(chdir("dir0") < 0){
printf(stdout, "chdir dir0 failed\n");
9b6: 51 push %ecx
9b7: 51 push %ecx
9b8: 68 a5 40 00 00 push $0x40a5
9bd: ff 35 64 5e 00 00 pushl 0x5e64
9c3: e8 e8 30 00 00 call 3ab0 <printf>
exit();
9c8: e8 95 2f 00 00 call 3962 <exit>
9cd: 8d 76 00 lea 0x0(%esi),%esi
000009d0 <exectest>:
printf(stdout, "mkdir test ok\n");
}
void
exectest(void)
{
9d0: 55 push %ebp
9d1: 89 e5 mov %esp,%ebp
9d3: 83 ec 10 sub $0x10,%esp
printf(stdout, "exec test\n");
9d6: 68 ec 40 00 00 push $0x40ec
9db: ff 35 64 5e 00 00 pushl 0x5e64
9e1: e8 ca 30 00 00 call 3ab0 <printf>
if(exec("echo", echoargv) < 0){
9e6: 5a pop %edx
9e7: 59 pop %ecx
9e8: 68 68 5e 00 00 push $0x5e68
9ed: 68 b5 3e 00 00 push $0x3eb5
9f2: e8 a3 2f 00 00 call 399a <exec>
9f7: 83 c4 10 add $0x10,%esp
9fa: 85 c0 test %eax,%eax
9fc: 78 02 js a00 <exectest+0x30>
printf(stdout, "exec echo failed\n");
exit();
}
}
9fe: c9 leave
9ff: c3 ret
void
exectest(void)
{
printf(stdout, "exec test\n");
if(exec("echo", echoargv) < 0){
printf(stdout, "exec echo failed\n");
a00: 50 push %eax
a01: 50 push %eax
a02: 68 f7 40 00 00 push $0x40f7
a07: ff 35 64 5e 00 00 pushl 0x5e64
a0d: e8 9e 30 00 00 call 3ab0 <printf>
exit();
a12: e8 4b 2f 00 00 call 3962 <exit>
a17: 89 f6 mov %esi,%esi
a19: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000a20 <pipe1>:
// simple fork and pipe read/write
void
pipe1(void)
{
a20: 55 push %ebp
a21: 89 e5 mov %esp,%ebp
a23: 57 push %edi
a24: 56 push %esi
a25: 53 push %ebx
int fds[2], pid;
int seq, i, n, cc, total;
if(pipe(fds) != 0){
a26: 8d 45 e0 lea -0x20(%ebp),%eax
// simple fork and pipe read/write
void
pipe1(void)
{
a29: 83 ec 38 sub $0x38,%esp
int fds[2], pid;
int seq, i, n, cc, total;
if(pipe(fds) != 0){
a2c: 50 push %eax
a2d: e8 40 2f 00 00 call 3972 <pipe>
a32: 83 c4 10 add $0x10,%esp
a35: 85 c0 test %eax,%eax
a37: 0f 85 45 01 00 00 jne b82 <pipe1+0x162>
printf(1, "pipe() failed\n");
exit();
}
pid = fork(0);
a3d: 83 ec 0c sub $0xc,%esp
a40: 6a 00 push $0x0
a42: e8 13 2f 00 00 call 395a <fork>
seq = 0;
if(pid == 0){
a47: 83 c4 10 add $0x10,%esp
a4a: 83 f8 00 cmp $0x0,%eax
a4d: 0f 84 8e 00 00 00 je ae1 <pipe1+0xc1>
printf(1, "pipe1 oops 1\n");
exit();
}
}
exit();
} else if(pid > 0){
a53: 0f 8e 3d 01 00 00 jle b96 <pipe1+0x176>
close(fds[1]);
a59: 83 ec 0c sub $0xc,%esp
a5c: ff 75 e4 pushl -0x1c(%ebp)
total = 0;
cc = 1;
a5f: bf 01 00 00 00 mov $0x1,%edi
if(pipe(fds) != 0){
printf(1, "pipe() failed\n");
exit();
}
pid = fork(0);
seq = 0;
a64: 31 db xor %ebx,%ebx
exit();
}
}
exit();
} else if(pid > 0){
close(fds[1]);
a66: e8 1f 2f 00 00 call 398a <close>
total = 0;
cc = 1;
while((n = read(fds[0], buf, cc)) > 0){
a6b: 83 c4 10 add $0x10,%esp
}
}
exit();
} else if(pid > 0){
close(fds[1]);
total = 0;
a6e: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
cc = 1;
while((n = read(fds[0], buf, cc)) > 0){
a75: 83 ec 04 sub $0x4,%esp
a78: 57 push %edi
a79: 68 40 86 00 00 push $0x8640
a7e: ff 75 e0 pushl -0x20(%ebp)
a81: e8 f4 2e 00 00 call 397a <read>
a86: 83 c4 10 add $0x10,%esp
a89: 85 c0 test %eax,%eax
a8b: 0f 8e ab 00 00 00 jle b3c <pipe1+0x11c>
for(i = 0; i < n; i++){
if((buf[i] & 0xff) != (seq++ & 0xff)){
a91: 89 d9 mov %ebx,%ecx
a93: 8d 34 18 lea (%eax,%ebx,1),%esi
a96: f7 d9 neg %ecx
a98: 90 nop
a99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
aa0: 38 9c 0b 40 86 00 00 cmp %bl,0x8640(%ebx,%ecx,1)
aa7: 8d 53 01 lea 0x1(%ebx),%edx
aaa: 75 1b jne ac7 <pipe1+0xa7>
} else if(pid > 0){
close(fds[1]);
total = 0;
cc = 1;
while((n = read(fds[0], buf, cc)) > 0){
for(i = 0; i < n; i++){
aac: 39 f2 cmp %esi,%edx
aae: 89 d3 mov %edx,%ebx
ab0: 75 ee jne aa0 <pipe1+0x80>
printf(1, "pipe1 oops 2\n");
return;
}
}
total += n;
cc = cc * 2;
ab2: 01 ff add %edi,%edi
if((buf[i] & 0xff) != (seq++ & 0xff)){
printf(1, "pipe1 oops 2\n");
return;
}
}
total += n;
ab4: 01 45 d4 add %eax,-0x2c(%ebp)
ab7: b8 00 20 00 00 mov $0x2000,%eax
abc: 81 ff 00 20 00 00 cmp $0x2000,%edi
ac2: 0f 4f f8 cmovg %eax,%edi
ac5: eb ae jmp a75 <pipe1+0x55>
total = 0;
cc = 1;
while((n = read(fds[0], buf, cc)) > 0){
for(i = 0; i < n; i++){
if((buf[i] & 0xff) != (seq++ & 0xff)){
printf(1, "pipe1 oops 2\n");
ac7: 83 ec 08 sub $0x8,%esp
aca: 68 26 41 00 00 push $0x4126
acf: 6a 01 push $0x1
ad1: e8 da 2f 00 00 call 3ab0 <printf>
return;
ad6: 83 c4 10 add $0x10,%esp
} else {
printf(1, "fork(0) failed\n");
exit();
}
printf(1, "pipe1 ok\n");
}
ad9: 8d 65 f4 lea -0xc(%ebp),%esp
adc: 5b pop %ebx
add: 5e pop %esi
ade: 5f pop %edi
adf: 5d pop %ebp
ae0: c3 ret
exit();
}
pid = fork(0);
seq = 0;
if(pid == 0){
close(fds[0]);
ae1: 83 ec 0c sub $0xc,%esp
ae4: ff 75 e0 pushl -0x20(%ebp)
if(pipe(fds) != 0){
printf(1, "pipe() failed\n");
exit();
}
pid = fork(0);
seq = 0;
ae7: 31 f6 xor %esi,%esi
if(pid == 0){
close(fds[0]);
ae9: e8 9c 2e 00 00 call 398a <close>
aee: 83 c4 10 add $0x10,%esp
for(n = 0; n < 5; n++){
for(i = 0; i < 1033; i++)
buf[i] = seq++;
af1: 89 f0 mov %esi,%eax
af3: 8d 96 09 04 00 00 lea 0x409(%esi),%edx
// simple fork and pipe read/write
void
pipe1(void)
{
af9: 89 f3 mov %esi,%ebx
seq = 0;
if(pid == 0){
close(fds[0]);
for(n = 0; n < 5; n++){
for(i = 0; i < 1033; i++)
buf[i] = seq++;
afb: f7 d8 neg %eax
afd: 8d 76 00 lea 0x0(%esi),%esi
b00: 88 9c 18 40 86 00 00 mov %bl,0x8640(%eax,%ebx,1)
b07: 83 c3 01 add $0x1,%ebx
pid = fork(0);
seq = 0;
if(pid == 0){
close(fds[0]);
for(n = 0; n < 5; n++){
for(i = 0; i < 1033; i++)
b0a: 39 d3 cmp %edx,%ebx
b0c: 75 f2 jne b00 <pipe1+0xe0>
buf[i] = seq++;
if(write(fds[1], buf, 1033) != 1033){
b0e: 83 ec 04 sub $0x4,%esp
b11: 89 de mov %ebx,%esi
b13: 68 09 04 00 00 push $0x409
b18: 68 40 86 00 00 push $0x8640
b1d: ff 75 e4 pushl -0x1c(%ebp)
b20: e8 5d 2e 00 00 call 3982 <write>
b25: 83 c4 10 add $0x10,%esp
b28: 3d 09 04 00 00 cmp $0x409,%eax
b2d: 75 7b jne baa <pipe1+0x18a>
}
pid = fork(0);
seq = 0;
if(pid == 0){
close(fds[0]);
for(n = 0; n < 5; n++){
b2f: 81 fb 2d 14 00 00 cmp $0x142d,%ebx
b35: 75 ba jne af1 <pipe1+0xd1>
if(write(fds[1], buf, 1033) != 1033){
printf(1, "pipe1 oops 1\n");
exit();
}
}
exit();
b37: e8 26 2e 00 00 call 3962 <exit>
total += n;
cc = cc * 2;
if(cc > sizeof(buf))
cc = sizeof(buf);
}
if(total != 5 * 1033){
b3c: 81 7d d4 2d 14 00 00 cmpl $0x142d,-0x2c(%ebp)
b43: 75 26 jne b6b <pipe1+0x14b>
printf(1, "pipe1 oops 3 total %d\n", total);
exit();
}
close(fds[0]);
b45: 83 ec 0c sub $0xc,%esp
b48: ff 75 e0 pushl -0x20(%ebp)
b4b: e8 3a 2e 00 00 call 398a <close>
wait();
b50: e8 15 2e 00 00 call 396a <wait>
} else {
printf(1, "fork(0) failed\n");
exit();
}
printf(1, "pipe1 ok\n");
b55: 58 pop %eax
b56: 5a pop %edx
b57: 68 4b 41 00 00 push $0x414b
b5c: 6a 01 push $0x1
b5e: e8 4d 2f 00 00 call 3ab0 <printf>
b63: 83 c4 10 add $0x10,%esp
b66: e9 6e ff ff ff jmp ad9 <pipe1+0xb9>
cc = cc * 2;
if(cc > sizeof(buf))
cc = sizeof(buf);
}
if(total != 5 * 1033){
printf(1, "pipe1 oops 3 total %d\n", total);
b6b: 83 ec 04 sub $0x4,%esp
b6e: ff 75 d4 pushl -0x2c(%ebp)
b71: 68 34 41 00 00 push $0x4134
b76: 6a 01 push $0x1
b78: e8 33 2f 00 00 call 3ab0 <printf>
exit();
b7d: e8 e0 2d 00 00 call 3962 <exit>
{
int fds[2], pid;
int seq, i, n, cc, total;
if(pipe(fds) != 0){
printf(1, "pipe() failed\n");
b82: 83 ec 08 sub $0x8,%esp
b85: 68 09 41 00 00 push $0x4109
b8a: 6a 01 push $0x1
b8c: e8 1f 2f 00 00 call 3ab0 <printf>
exit();
b91: e8 cc 2d 00 00 call 3962 <exit>
exit();
}
close(fds[0]);
wait();
} else {
printf(1, "fork(0) failed\n");
b96: 83 ec 08 sub $0x8,%esp
b99: 68 55 41 00 00 push $0x4155
b9e: 6a 01 push $0x1
ba0: e8 0b 2f 00 00 call 3ab0 <printf>
exit();
ba5: e8 b8 2d 00 00 call 3962 <exit>
close(fds[0]);
for(n = 0; n < 5; n++){
for(i = 0; i < 1033; i++)
buf[i] = seq++;
if(write(fds[1], buf, 1033) != 1033){
printf(1, "pipe1 oops 1\n");
baa: 83 ec 08 sub $0x8,%esp
bad: 68 18 41 00 00 push $0x4118
bb2: 6a 01 push $0x1
bb4: e8 f7 2e 00 00 call 3ab0 <printf>
exit();
bb9: e8 a4 2d 00 00 call 3962 <exit>
bbe: 66 90 xchg %ax,%ax
00000bc0 <preempt>:
}
// meant to be run w/ at most two CPUs
void
preempt(void)
{
bc0: 55 push %ebp
bc1: 89 e5 mov %esp,%ebp
bc3: 57 push %edi
bc4: 56 push %esi
bc5: 53 push %ebx
bc6: 83 ec 24 sub $0x24,%esp
int pid1, pid2, pid3;
int pfds[2];
printf(1, "preempt: ");
bc9: 68 65 41 00 00 push $0x4165
bce: 6a 01 push $0x1
bd0: e8 db 2e 00 00 call 3ab0 <printf>
pid1 = fork(0);
bd5: c7 04 24 00 00 00 00 movl $0x0,(%esp)
bdc: e8 79 2d 00 00 call 395a <fork>
if(pid1 == 0)
be1: 83 c4 10 add $0x10,%esp
be4: 85 c0 test %eax,%eax
be6: 75 02 jne bea <preempt+0x2a>
be8: eb fe jmp be8 <preempt+0x28>
for(;;)
;
pid2 = fork(0);
bea: 83 ec 0c sub $0xc,%esp
bed: 89 c7 mov %eax,%edi
bef: 6a 00 push $0x0
bf1: e8 64 2d 00 00 call 395a <fork>
if(pid2 == 0)
bf6: 83 c4 10 add $0x10,%esp
bf9: 85 c0 test %eax,%eax
pid1 = fork(0);
if(pid1 == 0)
for(;;)
;
pid2 = fork(0);
bfb: 89 c6 mov %eax,%esi
if(pid2 == 0)
bfd: 75 02 jne c01 <preempt+0x41>
bff: eb fe jmp bff <preempt+0x3f>
for(;;)
;
pipe(pfds);
c01: 8d 45 e0 lea -0x20(%ebp),%eax
c04: 83 ec 0c sub $0xc,%esp
c07: 50 push %eax
c08: e8 65 2d 00 00 call 3972 <pipe>
pid3 = fork(0);
c0d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
c14: e8 41 2d 00 00 call 395a <fork>
if(pid3 == 0){
c19: 83 c4 10 add $0x10,%esp
c1c: 85 c0 test %eax,%eax
if(pid2 == 0)
for(;;)
;
pipe(pfds);
pid3 = fork(0);
c1e: 89 c3 mov %eax,%ebx
if(pid3 == 0){
c20: 75 47 jne c69 <preempt+0xa9>
close(pfds[0]);
c22: 83 ec 0c sub $0xc,%esp
c25: ff 75 e0 pushl -0x20(%ebp)
c28: e8 5d 2d 00 00 call 398a <close>
if(write(pfds[1], "x", 1) != 1)
c2d: 83 c4 0c add $0xc,%esp
c30: 6a 01 push $0x1
c32: 68 2a 47 00 00 push $0x472a
c37: ff 75 e4 pushl -0x1c(%ebp)
c3a: e8 43 2d 00 00 call 3982 <write>
c3f: 83 c4 10 add $0x10,%esp
c42: 83 f8 01 cmp $0x1,%eax
c45: 74 12 je c59 <preempt+0x99>
printf(1, "preempt write error");
c47: 83 ec 08 sub $0x8,%esp
c4a: 68 6f 41 00 00 push $0x416f
c4f: 6a 01 push $0x1
c51: e8 5a 2e 00 00 call 3ab0 <printf>
c56: 83 c4 10 add $0x10,%esp
close(pfds[1]);
c59: 83 ec 0c sub $0xc,%esp
c5c: ff 75 e4 pushl -0x1c(%ebp)
c5f: e8 26 2d 00 00 call 398a <close>
c64: 83 c4 10 add $0x10,%esp
c67: eb fe jmp c67 <preempt+0xa7>
for(;;)
;
}
close(pfds[1]);
c69: 83 ec 0c sub $0xc,%esp
c6c: ff 75 e4 pushl -0x1c(%ebp)
c6f: e8 16 2d 00 00 call 398a <close>
if(read(pfds[0], buf, sizeof(buf)) != 1){
c74: 83 c4 0c add $0xc,%esp
c77: 68 00 20 00 00 push $0x2000
c7c: 68 40 86 00 00 push $0x8640
c81: ff 75 e0 pushl -0x20(%ebp)
c84: e8 f1 2c 00 00 call 397a <read>
c89: 83 c4 10 add $0x10,%esp
c8c: 83 f8 01 cmp $0x1,%eax
c8f: 74 1a je cab <preempt+0xeb>
printf(1, "preempt read error");
c91: 83 ec 08 sub $0x8,%esp
c94: 68 83 41 00 00 push $0x4183
c99: 6a 01 push $0x1
c9b: e8 10 2e 00 00 call 3ab0 <printf>
return;
ca0: 83 c4 10 add $0x10,%esp
printf(1, "wait... ");
wait();
wait();
wait();
printf(1, "preempt ok\n");
}
ca3: 8d 65 f4 lea -0xc(%ebp),%esp
ca6: 5b pop %ebx
ca7: 5e pop %esi
ca8: 5f pop %edi
ca9: 5d pop %ebp
caa: c3 ret
close(pfds[1]);
if(read(pfds[0], buf, sizeof(buf)) != 1){
printf(1, "preempt read error");
return;
}
close(pfds[0]);
cab: 83 ec 0c sub $0xc,%esp
cae: ff 75 e0 pushl -0x20(%ebp)
cb1: e8 d4 2c 00 00 call 398a <close>
printf(1, "kill... ");
cb6: 58 pop %eax
cb7: 5a pop %edx
cb8: 68 96 41 00 00 push $0x4196
cbd: 6a 01 push $0x1
cbf: e8 ec 2d 00 00 call 3ab0 <printf>
kill(pid1);
cc4: 89 3c 24 mov %edi,(%esp)
cc7: e8 c6 2c 00 00 call 3992 <kill>
kill(pid2);
ccc: 89 34 24 mov %esi,(%esp)
ccf: e8 be 2c 00 00 call 3992 <kill>
kill(pid3);
cd4: 89 1c 24 mov %ebx,(%esp)
cd7: e8 b6 2c 00 00 call 3992 <kill>
printf(1, "wait... ");
cdc: 59 pop %ecx
cdd: 5b pop %ebx
cde: 68 9f 41 00 00 push $0x419f
ce3: 6a 01 push $0x1
ce5: e8 c6 2d 00 00 call 3ab0 <printf>
wait();
cea: e8 7b 2c 00 00 call 396a <wait>
wait();
cef: e8 76 2c 00 00 call 396a <wait>
wait();
cf4: e8 71 2c 00 00 call 396a <wait>
printf(1, "preempt ok\n");
cf9: 5e pop %esi
cfa: 5f pop %edi
cfb: 68 a8 41 00 00 push $0x41a8
d00: 6a 01 push $0x1
d02: e8 a9 2d 00 00 call 3ab0 <printf>
d07: 83 c4 10 add $0x10,%esp
d0a: eb 97 jmp ca3 <preempt+0xe3>
d0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000d10 <exitwait>:
}
// try to find any races between exit and wait
void
exitwait(void)
{
d10: 55 push %ebp
d11: 89 e5 mov %esp,%ebp
d13: 56 push %esi
d14: be 64 00 00 00 mov $0x64,%esi
d19: 53 push %ebx
d1a: eb 14 jmp d30 <exitwait+0x20>
d1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
pid = fork(0);
if(pid < 0){
printf(1, "fork failed\n");
return;
}
if(pid){
d20: 74 77 je d99 <exitwait+0x89>
if(wait() != pid){
d22: e8 43 2c 00 00 call 396a <wait>
d27: 39 c3 cmp %eax,%ebx
d29: 75 35 jne d60 <exitwait+0x50>
void
exitwait(void)
{
int i, pid;
for(i = 0; i < 100; i++){
d2b: 83 ee 01 sub $0x1,%esi
d2e: 74 50 je d80 <exitwait+0x70>
pid = fork(0);
d30: 83 ec 0c sub $0xc,%esp
d33: 6a 00 push $0x0
d35: e8 20 2c 00 00 call 395a <fork>
if(pid < 0){
d3a: 83 c4 10 add $0x10,%esp
d3d: 85 c0 test %eax,%eax
exitwait(void)
{
int i, pid;
for(i = 0; i < 100; i++){
pid = fork(0);
d3f: 89 c3 mov %eax,%ebx
if(pid < 0){
d41: 79 dd jns d20 <exitwait+0x10>
printf(1, "fork failed\n");
d43: 83 ec 08 sub $0x8,%esp
d46: 68 12 4d 00 00 push $0x4d12
d4b: 6a 01 push $0x1
d4d: e8 5e 2d 00 00 call 3ab0 <printf>
return;
d52: 83 c4 10 add $0x10,%esp
} else {
exit();
}
}
printf(1, "exitwait ok\n");
}
d55: 8d 65 f8 lea -0x8(%ebp),%esp
d58: 5b pop %ebx
d59: 5e pop %esi
d5a: 5d pop %ebp
d5b: c3 ret
d5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printf(1, "fork failed\n");
return;
}
if(pid){
if(wait() != pid){
printf(1, "wait wrong pid\n");
d60: 83 ec 08 sub $0x8,%esp
d63: 68 b4 41 00 00 push $0x41b4
d68: 6a 01 push $0x1
d6a: e8 41 2d 00 00 call 3ab0 <printf>
return;
d6f: 83 c4 10 add $0x10,%esp
} else {
exit();
}
}
printf(1, "exitwait ok\n");
}
d72: 8d 65 f8 lea -0x8(%ebp),%esp
d75: 5b pop %ebx
d76: 5e pop %esi
d77: 5d pop %ebp
d78: c3 ret
d79: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
}
} else {
exit();
}
}
printf(1, "exitwait ok\n");
d80: 83 ec 08 sub $0x8,%esp
d83: 68 c4 41 00 00 push $0x41c4
d88: 6a 01 push $0x1
d8a: e8 21 2d 00 00 call 3ab0 <printf>
d8f: 83 c4 10 add $0x10,%esp
}
d92: 8d 65 f8 lea -0x8(%ebp),%esp
d95: 5b pop %ebx
d96: 5e pop %esi
d97: 5d pop %ebp
d98: c3 ret
if(wait() != pid){
printf(1, "wait wrong pid\n");
return;
}
} else {
exit();
d99: e8 c4 2b 00 00 call 3962 <exit>
d9e: 66 90 xchg %ax,%ax
00000da0 <mem>:
printf(1, "exitwait ok\n");
}
void
mem(void)
{
da0: 55 push %ebp
da1: 89 e5 mov %esp,%ebp
da3: 57 push %edi
da4: 56 push %esi
da5: 53 push %ebx
da6: 83 ec 14 sub $0x14,%esp
void *m1, *m2;
int pid, ppid;
printf(1, "mem test\n");
da9: 68 d1 41 00 00 push $0x41d1
dae: 6a 01 push $0x1
db0: e8 fb 2c 00 00 call 3ab0 <printf>
ppid = getpid();
db5: e8 28 2c 00 00 call 39e2 <getpid>
if((pid = fork(0)) == 0){
dba: c7 04 24 00 00 00 00 movl $0x0,(%esp)
{
void *m1, *m2;
int pid, ppid;
printf(1, "mem test\n");
ppid = getpid();
dc1: 89 c6 mov %eax,%esi
if((pid = fork(0)) == 0){
dc3: e8 92 2b 00 00 call 395a <fork>
dc8: 83 c4 10 add $0x10,%esp
dcb: 85 c0 test %eax,%eax
dcd: 75 71 jne e40 <mem+0xa0>
dcf: 31 db xor %ebx,%ebx
dd1: eb 09 jmp ddc <mem+0x3c>
dd3: 90 nop
dd4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
m1 = 0;
while((m2 = malloc(10001)) != 0){
*(char**)m2 = m1;
dd8: 89 18 mov %ebx,(%eax)
dda: 89 c3 mov %eax,%ebx
printf(1, "mem test\n");
ppid = getpid();
if((pid = fork(0)) == 0){
m1 = 0;
while((m2 = malloc(10001)) != 0){
ddc: 83 ec 0c sub $0xc,%esp
ddf: 68 11 27 00 00 push $0x2711
de4: e8 f7 2e 00 00 call 3ce0 <malloc>
de9: 83 c4 10 add $0x10,%esp
dec: 85 c0 test %eax,%eax
dee: 75 e8 jne dd8 <mem+0x38>
*(char**)m2 = m1;
m1 = m2;
}
while(m1){
df0: 85 db test %ebx,%ebx
df2: 74 18 je e0c <mem+0x6c>
df4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
m2 = *(char**)m1;
df8: 8b 3b mov (%ebx),%edi
free(m1);
dfa: 83 ec 0c sub $0xc,%esp
dfd: 53 push %ebx
dfe: 89 fb mov %edi,%ebx
e00: e8 4b 2e 00 00 call 3c50 <free>
m1 = 0;
while((m2 = malloc(10001)) != 0){
*(char**)m2 = m1;
m1 = m2;
}
while(m1){
e05: 83 c4 10 add $0x10,%esp
e08: 85 db test %ebx,%ebx
e0a: 75 ec jne df8 <mem+0x58>
m2 = *(char**)m1;
free(m1);
m1 = m2;
}
m1 = malloc(1024*20);
e0c: 83 ec 0c sub $0xc,%esp
e0f: 68 00 50 00 00 push $0x5000
e14: e8 c7 2e 00 00 call 3ce0 <malloc>
if(m1 == 0){
e19: 83 c4 10 add $0x10,%esp
e1c: 85 c0 test %eax,%eax
e1e: 74 30 je e50 <mem+0xb0>
printf(1, "couldn't allocate mem?!!\n");
kill(ppid);
exit();
}
free(m1);
e20: 83 ec 0c sub $0xc,%esp
e23: 50 push %eax
e24: e8 27 2e 00 00 call 3c50 <free>
printf(1, "mem ok\n");
e29: 58 pop %eax
e2a: 5a pop %edx
e2b: 68 f5 41 00 00 push $0x41f5
e30: 6a 01 push $0x1
e32: e8 79 2c 00 00 call 3ab0 <printf>
exit();
e37: e8 26 2b 00 00 call 3962 <exit>
e3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
} else {
wait();
}
}
e40: 8d 65 f4 lea -0xc(%ebp),%esp
e43: 5b pop %ebx
e44: 5e pop %esi
e45: 5f pop %edi
e46: 5d pop %ebp
}
free(m1);
printf(1, "mem ok\n");
exit();
} else {
wait();
e47: e9 1e 2b 00 00 jmp 396a <wait>
e4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
free(m1);
m1 = m2;
}
m1 = malloc(1024*20);
if(m1 == 0){
printf(1, "couldn't allocate mem?!!\n");
e50: 83 ec 08 sub $0x8,%esp
e53: 68 db 41 00 00 push $0x41db
e58: 6a 01 push $0x1
e5a: e8 51 2c 00 00 call 3ab0 <printf>
kill(ppid);
e5f: 89 34 24 mov %esi,(%esp)
e62: e8 2b 2b 00 00 call 3992 <kill>
exit();
e67: e8 f6 2a 00 00 call 3962 <exit>
e6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000e70 <sharedfd>:
// two processes write to the same file descriptor
// is the offset shared? does inode locking work?
void
sharedfd(void)
{
e70: 55 push %ebp
e71: 89 e5 mov %esp,%ebp
e73: 57 push %edi
e74: 56 push %esi
e75: 53 push %ebx
e76: 83 ec 34 sub $0x34,%esp
int fd, pid, i, n, nc, np;
char buf[10];
printf(1, "sharedfd test\n");
e79: 68 fd 41 00 00 push $0x41fd
e7e: 6a 01 push $0x1
e80: e8 2b 2c 00 00 call 3ab0 <printf>
unlink("sharedfd");
e85: c7 04 24 0c 42 00 00 movl $0x420c,(%esp)
e8c: e8 21 2b 00 00 call 39b2 <unlink>
fd = open("sharedfd", O_CREATE|O_RDWR);
e91: 5b pop %ebx
e92: 5e pop %esi
e93: 68 02 02 00 00 push $0x202
e98: 68 0c 42 00 00 push $0x420c
e9d: e8 00 2b 00 00 call 39a2 <open>
if(fd < 0){
ea2: 83 c4 10 add $0x10,%esp
ea5: 85 c0 test %eax,%eax
ea7: 0f 88 29 01 00 00 js fd6 <sharedfd+0x166>
printf(1, "fstests: cannot open sharedfd for writing");
return;
}
pid = fork(0);
ead: 83 ec 0c sub $0xc,%esp
eb0: 89 c7 mov %eax,%edi
memset(buf, pid==0?'c':'p', sizeof(buf));
eb2: 8d 75 de lea -0x22(%ebp),%esi
fd = open("sharedfd", O_CREATE|O_RDWR);
if(fd < 0){
printf(1, "fstests: cannot open sharedfd for writing");
return;
}
pid = fork(0);
eb5: 6a 00 push $0x0
memset(buf, pid==0?'c':'p', sizeof(buf));
eb7: bb e8 03 00 00 mov $0x3e8,%ebx
fd = open("sharedfd", O_CREATE|O_RDWR);
if(fd < 0){
printf(1, "fstests: cannot open sharedfd for writing");
return;
}
pid = fork(0);
ebc: e8 99 2a 00 00 call 395a <fork>
memset(buf, pid==0?'c':'p', sizeof(buf));
ec1: 83 c4 0c add $0xc,%esp
ec4: 83 f8 01 cmp $0x1,%eax
fd = open("sharedfd", O_CREATE|O_RDWR);
if(fd < 0){
printf(1, "fstests: cannot open sharedfd for writing");
return;
}
pid = fork(0);
ec7: 89 45 d4 mov %eax,-0x2c(%ebp)
memset(buf, pid==0?'c':'p', sizeof(buf));
eca: 19 c0 sbb %eax,%eax
ecc: 6a 0a push $0xa
ece: 83 e0 f3 and $0xfffffff3,%eax
ed1: 83 c0 70 add $0x70,%eax
ed4: 50 push %eax
ed5: 56 push %esi
ed6: e8 f5 28 00 00 call 37d0 <memset>
edb: 83 c4 10 add $0x10,%esp
ede: eb 05 jmp ee5 <sharedfd+0x75>
for(i = 0; i < 1000; i++){
ee0: 83 eb 01 sub $0x1,%ebx
ee3: 74 26 je f0b <sharedfd+0x9b>
if(write(fd, buf, sizeof(buf)) != sizeof(buf)){
ee5: 83 ec 04 sub $0x4,%esp
ee8: 6a 0a push $0xa
eea: 56 push %esi
eeb: 57 push %edi
eec: e8 91 2a 00 00 call 3982 <write>
ef1: 83 c4 10 add $0x10,%esp
ef4: 83 f8 0a cmp $0xa,%eax
ef7: 74 e7 je ee0 <sharedfd+0x70>
printf(1, "fstests: write sharedfd failed\n");
ef9: 83 ec 08 sub $0x8,%esp
efc: 68 fc 4e 00 00 push $0x4efc
f01: 6a 01 push $0x1
f03: e8 a8 2b 00 00 call 3ab0 <printf>
break;
f08: 83 c4 10 add $0x10,%esp
}
}
if(pid == 0)
f0b: 8b 4d d4 mov -0x2c(%ebp),%ecx
f0e: 85 c9 test %ecx,%ecx
f10: 0f 84 f4 00 00 00 je 100a <sharedfd+0x19a>
exit();
else
wait();
f16: e8 4f 2a 00 00 call 396a <wait>
close(fd);
f1b: 83 ec 0c sub $0xc,%esp
f1e: 31 db xor %ebx,%ebx
f20: 57 push %edi
f21: 8d 7d e8 lea -0x18(%ebp),%edi
f24: e8 61 2a 00 00 call 398a <close>
fd = open("sharedfd", 0);
f29: 58 pop %eax
f2a: 5a pop %edx
f2b: 6a 00 push $0x0
f2d: 68 0c 42 00 00 push $0x420c
f32: e8 6b 2a 00 00 call 39a2 <open>
if(fd < 0){
f37: 83 c4 10 add $0x10,%esp
f3a: 31 d2 xor %edx,%edx
f3c: 85 c0 test %eax,%eax
if(pid == 0)
exit();
else
wait();
close(fd);
fd = open("sharedfd", 0);
f3e: 89 45 d0 mov %eax,-0x30(%ebp)
if(fd < 0){
f41: 0f 88 a9 00 00 00 js ff0 <sharedfd+0x180>
f47: 89 f6 mov %esi,%esi
f49: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
printf(1, "fstests: cannot open sharedfd for reading\n");
return;
}
nc = np = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
f50: 83 ec 04 sub $0x4,%esp
f53: 89 55 d4 mov %edx,-0x2c(%ebp)
f56: 6a 0a push $0xa
f58: 56 push %esi
f59: ff 75 d0 pushl -0x30(%ebp)
f5c: e8 19 2a 00 00 call 397a <read>
f61: 83 c4 10 add $0x10,%esp
f64: 85 c0 test %eax,%eax
f66: 7e 27 jle f8f <sharedfd+0x11f>
f68: 89 f0 mov %esi,%eax
f6a: 8b 55 d4 mov -0x2c(%ebp),%edx
f6d: eb 13 jmp f82 <sharedfd+0x112>
f6f: 90 nop
for(i = 0; i < sizeof(buf); i++){
if(buf[i] == 'c')
nc++;
if(buf[i] == 'p')
np++;
f70: 80 f9 70 cmp $0x70,%cl
f73: 0f 94 c1 sete %cl
f76: 0f b6 c9 movzbl %cl,%ecx
f79: 01 cb add %ecx,%ebx
f7b: 83 c0 01 add $0x1,%eax
printf(1, "fstests: cannot open sharedfd for reading\n");
return;
}
nc = np = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(i = 0; i < sizeof(buf); i++){
f7e: 39 c7 cmp %eax,%edi
f80: 74 ce je f50 <sharedfd+0xe0>
if(buf[i] == 'c')
f82: 0f b6 08 movzbl (%eax),%ecx
f85: 80 f9 63 cmp $0x63,%cl
f88: 75 e6 jne f70 <sharedfd+0x100>
nc++;
f8a: 83 c2 01 add $0x1,%edx
f8d: eb ec jmp f7b <sharedfd+0x10b>
if(buf[i] == 'p')
np++;
}
}
close(fd);
f8f: 83 ec 0c sub $0xc,%esp
f92: ff 75 d0 pushl -0x30(%ebp)
f95: e8 f0 29 00 00 call 398a <close>
unlink("sharedfd");
f9a: c7 04 24 0c 42 00 00 movl $0x420c,(%esp)
fa1: e8 0c 2a 00 00 call 39b2 <unlink>
if(nc == 10000 && np == 10000){
fa6: 8b 55 d4 mov -0x2c(%ebp),%edx
fa9: 83 c4 10 add $0x10,%esp
fac: 81 fa 10 27 00 00 cmp $0x2710,%edx
fb2: 75 5b jne 100f <sharedfd+0x19f>
fb4: 81 fb 10 27 00 00 cmp $0x2710,%ebx
fba: 75 53 jne 100f <sharedfd+0x19f>
printf(1, "sharedfd ok\n");
fbc: 83 ec 08 sub $0x8,%esp
fbf: 68 15 42 00 00 push $0x4215
fc4: 6a 01 push $0x1
fc6: e8 e5 2a 00 00 call 3ab0 <printf>
fcb: 83 c4 10 add $0x10,%esp
} else {
printf(1, "sharedfd oops %d %d\n", nc, np);
exit();
}
}
fce: 8d 65 f4 lea -0xc(%ebp),%esp
fd1: 5b pop %ebx
fd2: 5e pop %esi
fd3: 5f pop %edi
fd4: 5d pop %ebp
fd5: c3 ret
printf(1, "sharedfd test\n");
unlink("sharedfd");
fd = open("sharedfd", O_CREATE|O_RDWR);
if(fd < 0){
printf(1, "fstests: cannot open sharedfd for writing");
fd6: 83 ec 08 sub $0x8,%esp
fd9: 68 d0 4e 00 00 push $0x4ed0
fde: 6a 01 push $0x1
fe0: e8 cb 2a 00 00 call 3ab0 <printf>
return;
fe5: 83 c4 10 add $0x10,%esp
printf(1, "sharedfd ok\n");
} else {
printf(1, "sharedfd oops %d %d\n", nc, np);
exit();
}
}
fe8: 8d 65 f4 lea -0xc(%ebp),%esp
feb: 5b pop %ebx
fec: 5e pop %esi
fed: 5f pop %edi
fee: 5d pop %ebp
fef: c3 ret
else
wait();
close(fd);
fd = open("sharedfd", 0);
if(fd < 0){
printf(1, "fstests: cannot open sharedfd for reading\n");
ff0: 83 ec 08 sub $0x8,%esp
ff3: 68 1c 4f 00 00 push $0x4f1c
ff8: 6a 01 push $0x1
ffa: e8 b1 2a 00 00 call 3ab0 <printf>
return;
fff: 83 c4 10 add $0x10,%esp
printf(1, "sharedfd ok\n");
} else {
printf(1, "sharedfd oops %d %d\n", nc, np);
exit();
}
}
1002: 8d 65 f4 lea -0xc(%ebp),%esp
1005: 5b pop %ebx
1006: 5e pop %esi
1007: 5f pop %edi
1008: 5d pop %ebp
1009: c3 ret
printf(1, "fstests: write sharedfd failed\n");
break;
}
}
if(pid == 0)
exit();
100a: e8 53 29 00 00 call 3962 <exit>
close(fd);
unlink("sharedfd");
if(nc == 10000 && np == 10000){
printf(1, "sharedfd ok\n");
} else {
printf(1, "sharedfd oops %d %d\n", nc, np);
100f: 53 push %ebx
1010: 52 push %edx
1011: 68 22 42 00 00 push $0x4222
1016: 6a 01 push $0x1
1018: e8 93 2a 00 00 call 3ab0 <printf>
exit();
101d: e8 40 29 00 00 call 3962 <exit>
1022: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1029: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00001030 <fourfiles>:
// four processes write different files at the same
// time, to test block allocation.
void
fourfiles(void)
{
1030: 55 push %ebp
1031: 89 e5 mov %esp,%ebp
1033: 57 push %edi
1034: 56 push %esi
1035: 53 push %ebx
int fd, pid, i, j, n, total, pi;
char *names[] = { "f0", "f1", "f2", "f3" };
char *fname;
printf(1, "fourfiles test\n");
1036: be 37 42 00 00 mov $0x4237,%esi
for(pi = 0; pi < 4; pi++){
103b: 31 db xor %ebx,%ebx
// four processes write different files at the same
// time, to test block allocation.
void
fourfiles(void)
{
103d: 83 ec 34 sub $0x34,%esp
int fd, pid, i, j, n, total, pi;
char *names[] = { "f0", "f1", "f2", "f3" };
1040: c7 45 d8 37 42 00 00 movl $0x4237,-0x28(%ebp)
1047: c7 45 dc 80 43 00 00 movl $0x4380,-0x24(%ebp)
char *fname;
printf(1, "fourfiles test\n");
104e: 68 3d 42 00 00 push $0x423d
1053: 6a 01 push $0x1
// time, to test block allocation.
void
fourfiles(void)
{
int fd, pid, i, j, n, total, pi;
char *names[] = { "f0", "f1", "f2", "f3" };
1055: c7 45 e0 84 43 00 00 movl $0x4384,-0x20(%ebp)
105c: c7 45 e4 3a 42 00 00 movl $0x423a,-0x1c(%ebp)
char *fname;
printf(1, "fourfiles test\n");
1063: e8 48 2a 00 00 call 3ab0 <printf>
1068: 83 c4 10 add $0x10,%esp
for(pi = 0; pi < 4; pi++){
fname = names[pi];
unlink(fname);
106b: 83 ec 0c sub $0xc,%esp
106e: 56 push %esi
106f: e8 3e 29 00 00 call 39b2 <unlink>
pid = fork(0);
1074: c7 04 24 00 00 00 00 movl $0x0,(%esp)
107b: e8 da 28 00 00 call 395a <fork>
if(pid < 0){
1080: 83 c4 10 add $0x10,%esp
1083: 85 c0 test %eax,%eax
1085: 0f 88 84 01 00 00 js 120f <fourfiles+0x1df>
printf(1, "fork failed\n");
exit();
}
if(pid == 0){
108b: 0f 84 e4 00 00 00 je 1175 <fourfiles+0x145>
char *names[] = { "f0", "f1", "f2", "f3" };
char *fname;
printf(1, "fourfiles test\n");
for(pi = 0; pi < 4; pi++){
1091: 83 c3 01 add $0x1,%ebx
1094: 83 fb 04 cmp $0x4,%ebx
1097: 74 06 je 109f <fourfiles+0x6f>
1099: 8b 74 9d d8 mov -0x28(%ebp,%ebx,4),%esi
109d: eb cc jmp 106b <fourfiles+0x3b>
exit();
}
}
for(pi = 0; pi < 4; pi++){
wait();
109f: e8 c6 28 00 00 call 396a <wait>
10a4: bf 30 00 00 00 mov $0x30,%edi
10a9: e8 bc 28 00 00 call 396a <wait>
10ae: e8 b7 28 00 00 call 396a <wait>
10b3: e8 b2 28 00 00 call 396a <wait>
10b8: c7 45 d4 37 42 00 00 movl $0x4237,-0x2c(%ebp)
}
for(i = 0; i < 2; i++){
fname = names[i];
fd = open(fname, 0);
10bf: 83 ec 08 sub $0x8,%esp
total = 0;
10c2: 31 db xor %ebx,%ebx
wait();
}
for(i = 0; i < 2; i++){
fname = names[i];
fd = open(fname, 0);
10c4: 6a 00 push $0x0
10c6: ff 75 d4 pushl -0x2c(%ebp)
10c9: e8 d4 28 00 00 call 39a2 <open>
total = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
10ce: 83 c4 10 add $0x10,%esp
wait();
}
for(i = 0; i < 2; i++){
fname = names[i];
fd = open(fname, 0);
10d1: 89 c6 mov %eax,%esi
10d3: 90 nop
10d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
total = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
10d8: 83 ec 04 sub $0x4,%esp
10db: 68 00 20 00 00 push $0x2000
10e0: 68 40 86 00 00 push $0x8640
10e5: 56 push %esi
10e6: e8 8f 28 00 00 call 397a <read>
10eb: 83 c4 10 add $0x10,%esp
10ee: 85 c0 test %eax,%eax
10f0: 7e 1c jle 110e <fourfiles+0xde>
10f2: 31 d2 xor %edx,%edx
10f4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(j = 0; j < n; j++){
if(buf[j] != '0'+i){
10f8: 0f be 8a 40 86 00 00 movsbl 0x8640(%edx),%ecx
10ff: 39 cf cmp %ecx,%edi
1101: 75 5e jne 1161 <fourfiles+0x131>
for(i = 0; i < 2; i++){
fname = names[i];
fd = open(fname, 0);
total = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(j = 0; j < n; j++){
1103: 83 c2 01 add $0x1,%edx
1106: 39 d0 cmp %edx,%eax
1108: 75 ee jne 10f8 <fourfiles+0xc8>
if(buf[j] != '0'+i){
printf(1, "wrong char\n");
exit();
}
}
total += n;
110a: 01 c3 add %eax,%ebx
110c: eb ca jmp 10d8 <fourfiles+0xa8>
}
close(fd);
110e: 83 ec 0c sub $0xc,%esp
1111: 56 push %esi
1112: e8 73 28 00 00 call 398a <close>
if(total != 12*500){
1117: 83 c4 10 add $0x10,%esp
111a: 81 fb 70 17 00 00 cmp $0x1770,%ebx
1120: 0f 85 d4 00 00 00 jne 11fa <fourfiles+0x1ca>
printf(1, "wrong length %d\n", total);
exit();
}
unlink(fname);
1126: 83 ec 0c sub $0xc,%esp
1129: ff 75 d4 pushl -0x2c(%ebp)
112c: 83 c7 01 add $0x1,%edi
112f: e8 7e 28 00 00 call 39b2 <unlink>
for(pi = 0; pi < 4; pi++){
wait();
}
for(i = 0; i < 2; i++){
1134: 83 c4 10 add $0x10,%esp
1137: 83 ff 32 cmp $0x32,%edi
113a: 75 1a jne 1156 <fourfiles+0x126>
exit();
}
unlink(fname);
}
printf(1, "fourfiles ok\n");
113c: 83 ec 08 sub $0x8,%esp
113f: 68 7b 42 00 00 push $0x427b
1144: 6a 01 push $0x1
1146: e8 65 29 00 00 call 3ab0 <printf>
}
114b: 83 c4 10 add $0x10,%esp
114e: 8d 65 f4 lea -0xc(%ebp),%esp
1151: 5b pop %ebx
1152: 5e pop %esi
1153: 5f pop %edi
1154: 5d pop %ebp
1155: c3 ret
1156: 8b 45 dc mov -0x24(%ebp),%eax
1159: 89 45 d4 mov %eax,-0x2c(%ebp)
115c: e9 5e ff ff ff jmp 10bf <fourfiles+0x8f>
fd = open(fname, 0);
total = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(j = 0; j < n; j++){
if(buf[j] != '0'+i){
printf(1, "wrong char\n");
1161: 83 ec 08 sub $0x8,%esp
1164: 68 5e 42 00 00 push $0x425e
1169: 6a 01 push $0x1
116b: e8 40 29 00 00 call 3ab0 <printf>
exit();
1170: e8 ed 27 00 00 call 3962 <exit>
printf(1, "fork failed\n");
exit();
}
if(pid == 0){
fd = open(fname, O_CREATE | O_RDWR);
1175: 83 ec 08 sub $0x8,%esp
1178: 68 02 02 00 00 push $0x202
117d: 56 push %esi
117e: e8 1f 28 00 00 call 39a2 <open>
if(fd < 0){
1183: 83 c4 10 add $0x10,%esp
1186: 85 c0 test %eax,%eax
printf(1, "fork failed\n");
exit();
}
if(pid == 0){
fd = open(fname, O_CREATE | O_RDWR);
1188: 89 c6 mov %eax,%esi
if(fd < 0){
118a: 78 5a js 11e6 <fourfiles+0x1b6>
printf(1, "create failed\n");
exit();
}
memset(buf, '0'+pi, 512);
118c: 83 ec 04 sub $0x4,%esp
118f: 83 c3 30 add $0x30,%ebx
1192: 68 00 02 00 00 push $0x200
1197: 53 push %ebx
1198: bb 0c 00 00 00 mov $0xc,%ebx
119d: 68 40 86 00 00 push $0x8640
11a2: e8 29 26 00 00 call 37d0 <memset>
11a7: 83 c4 10 add $0x10,%esp
for(i = 0; i < 12; i++){
if((n = write(fd, buf, 500)) != 500){
11aa: 83 ec 04 sub $0x4,%esp
11ad: 68 f4 01 00 00 push $0x1f4
11b2: 68 40 86 00 00 push $0x8640
11b7: 56 push %esi
11b8: e8 c5 27 00 00 call 3982 <write>
11bd: 83 c4 10 add $0x10,%esp
11c0: 3d f4 01 00 00 cmp $0x1f4,%eax
11c5: 75 0a jne 11d1 <fourfiles+0x1a1>
printf(1, "create failed\n");
exit();
}
memset(buf, '0'+pi, 512);
for(i = 0; i < 12; i++){
11c7: 83 eb 01 sub $0x1,%ebx
11ca: 75 de jne 11aa <fourfiles+0x17a>
if((n = write(fd, buf, 500)) != 500){
printf(1, "write failed %d\n", n);
exit();
}
}
exit();
11cc: e8 91 27 00 00 call 3962 <exit>
}
memset(buf, '0'+pi, 512);
for(i = 0; i < 12; i++){
if((n = write(fd, buf, 500)) != 500){
printf(1, "write failed %d\n", n);
11d1: 83 ec 04 sub $0x4,%esp
11d4: 50 push %eax
11d5: 68 4d 42 00 00 push $0x424d
11da: 6a 01 push $0x1
11dc: e8 cf 28 00 00 call 3ab0 <printf>
exit();
11e1: e8 7c 27 00 00 call 3962 <exit>
}
if(pid == 0){
fd = open(fname, O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "create failed\n");
11e6: 83 ec 08 sub $0x8,%esp
11e9: 68 d8 44 00 00 push $0x44d8
11ee: 6a 01 push $0x1
11f0: e8 bb 28 00 00 call 3ab0 <printf>
exit();
11f5: e8 68 27 00 00 call 3962 <exit>
}
total += n;
}
close(fd);
if(total != 12*500){
printf(1, "wrong length %d\n", total);
11fa: 83 ec 04 sub $0x4,%esp
11fd: 53 push %ebx
11fe: 68 6a 42 00 00 push $0x426a
1203: 6a 01 push $0x1
1205: e8 a6 28 00 00 call 3ab0 <printf>
exit();
120a: e8 53 27 00 00 call 3962 <exit>
fname = names[pi];
unlink(fname);
pid = fork(0);
if(pid < 0){
printf(1, "fork failed\n");
120f: 83 ec 08 sub $0x8,%esp
1212: 68 12 4d 00 00 push $0x4d12
1217: 6a 01 push $0x1
1219: e8 92 28 00 00 call 3ab0 <printf>
exit();
121e: e8 3f 27 00 00 call 3962 <exit>
1223: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1229: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00001230 <createdelete>:
}
// four processes create and delete different files in same directory
void
createdelete(void)
{
1230: 55 push %ebp
1231: 89 e5 mov %esp,%ebp
1233: 57 push %edi
1234: 56 push %esi
1235: 53 push %ebx
int pid, i, fd, pi;
char name[32];
printf(1, "createdelete test\n");
for(pi = 0; pi < 4; pi++){
1236: 31 db xor %ebx,%ebx
}
// four processes create and delete different files in same directory
void
createdelete(void)
{
1238: 83 ec 44 sub $0x44,%esp
enum { N = 20 };
int pid, i, fd, pi;
char name[32];
printf(1, "createdelete test\n");
123b: 68 89 42 00 00 push $0x4289
1240: 6a 01 push $0x1
1242: e8 69 28 00 00 call 3ab0 <printf>
1247: 83 c4 10 add $0x10,%esp
for(pi = 0; pi < 4; pi++){
pid = fork(0);
124a: 83 ec 0c sub $0xc,%esp
124d: 6a 00 push $0x0
124f: e8 06 27 00 00 call 395a <fork>
if(pid < 0){
1254: 83 c4 10 add $0x10,%esp
1257: 85 c0 test %eax,%eax
1259: 0f 88 b7 01 00 00 js 1416 <createdelete+0x1e6>
printf(1, "fork failed\n");
exit();
}
if(pid == 0){
125f: 0f 84 f6 00 00 00 je 135b <createdelete+0x12b>
int pid, i, fd, pi;
char name[32];
printf(1, "createdelete test\n");
for(pi = 0; pi < 4; pi++){
1265: 83 c3 01 add $0x1,%ebx
1268: 83 fb 04 cmp $0x4,%ebx
126b: 75 dd jne 124a <createdelete+0x1a>
126d: 8d 7d c8 lea -0x38(%ebp),%edi
for(pi = 0; pi < 4; pi++){
wait();
}
name[0] = name[1] = name[2] = 0;
for(i = 0; i < N; i++){
1270: 31 f6 xor %esi,%esi
exit();
}
}
for(pi = 0; pi < 4; pi++){
wait();
1272: e8 f3 26 00 00 call 396a <wait>
1277: e8 ee 26 00 00 call 396a <wait>
127c: e8 e9 26 00 00 call 396a <wait>
1281: e8 e4 26 00 00 call 396a <wait>
}
name[0] = name[1] = name[2] = 0;
1286: c6 45 ca 00 movb $0x0,-0x36(%ebp)
128a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1290: 8d 46 30 lea 0x30(%esi),%eax
1293: 83 fe 09 cmp $0x9,%esi
exit();
}
if(pid == 0){
name[0] = 'p' + pi;
name[2] = '\0';
1296: bb 70 00 00 00 mov $0x70,%ebx
129b: 0f 9f c2 setg %dl
129e: 85 f6 test %esi,%esi
12a0: 88 45 c7 mov %al,-0x39(%ebp)
12a3: 0f 94 c0 sete %al
12a6: 09 c2 or %eax,%edx
name[1] = '0' + i;
fd = open(name, 0);
if((i == 0 || i >= N/2) && fd < 0){
printf(1, "oops createdelete %s didn't exist\n", name);
exit();
} else if((i >= 1 && i < N/2) && fd >= 0){
12a8: 8d 46 ff lea -0x1(%esi),%eax
12ab: 88 55 c6 mov %dl,-0x3a(%ebp)
12ae: 89 45 c0 mov %eax,-0x40(%ebp)
name[0] = name[1] = name[2] = 0;
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
name[0] = 'p' + pi;
name[1] = '0' + i;
12b1: 0f b6 45 c7 movzbl -0x39(%ebp),%eax
fd = open(name, 0);
12b5: 83 ec 08 sub $0x8,%esp
}
name[0] = name[1] = name[2] = 0;
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
name[0] = 'p' + pi;
12b8: 88 5d c8 mov %bl,-0x38(%ebp)
name[1] = '0' + i;
fd = open(name, 0);
12bb: 6a 00 push $0x0
12bd: 57 push %edi
name[0] = name[1] = name[2] = 0;
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
name[0] = 'p' + pi;
name[1] = '0' + i;
12be: 88 45 c9 mov %al,-0x37(%ebp)
fd = open(name, 0);
12c1: e8 dc 26 00 00 call 39a2 <open>
if((i == 0 || i >= N/2) && fd < 0){
12c6: 89 c1 mov %eax,%ecx
12c8: 83 c4 10 add $0x10,%esp
12cb: c1 e9 1f shr $0x1f,%ecx
12ce: 84 c9 test %cl,%cl
12d0: 74 0a je 12dc <createdelete+0xac>
12d2: 80 7d c6 00 cmpb $0x0,-0x3a(%ebp)
12d6: 0f 85 11 01 00 00 jne 13ed <createdelete+0x1bd>
printf(1, "oops createdelete %s didn't exist\n", name);
exit();
} else if((i >= 1 && i < N/2) && fd >= 0){
12dc: 83 7d c0 08 cmpl $0x8,-0x40(%ebp)
12e0: 0f 86 44 01 00 00 jbe 142a <createdelete+0x1fa>
printf(1, "oops createdelete %s did exist\n", name);
exit();
}
if(fd >= 0)
12e6: 85 c0 test %eax,%eax
12e8: 78 0c js 12f6 <createdelete+0xc6>
close(fd);
12ea: 83 ec 0c sub $0xc,%esp
12ed: 50 push %eax
12ee: e8 97 26 00 00 call 398a <close>
12f3: 83 c4 10 add $0x10,%esp
12f6: 83 c3 01 add $0x1,%ebx
wait();
}
name[0] = name[1] = name[2] = 0;
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
12f9: 80 fb 74 cmp $0x74,%bl
12fc: 75 b3 jne 12b1 <createdelete+0x81>
for(pi = 0; pi < 4; pi++){
wait();
}
name[0] = name[1] = name[2] = 0;
for(i = 0; i < N; i++){
12fe: 83 c6 01 add $0x1,%esi
1301: 83 fe 14 cmp $0x14,%esi
1304: 75 8a jne 1290 <createdelete+0x60>
1306: be 70 00 00 00 mov $0x70,%esi
130b: 90 nop
130c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1310: 8d 46 c0 lea -0x40(%esi),%eax
1313: bb 04 00 00 00 mov $0x4,%ebx
1318: 88 45 c7 mov %al,-0x39(%ebp)
}
}
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
name[0] = 'p' + i;
131b: 89 f0 mov %esi,%eax
name[1] = '0' + i;
unlink(name);
131d: 83 ec 0c sub $0xc,%esp
}
}
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
name[0] = 'p' + i;
1320: 88 45 c8 mov %al,-0x38(%ebp)
name[1] = '0' + i;
1323: 0f b6 45 c7 movzbl -0x39(%ebp),%eax
unlink(name);
1327: 57 push %edi
}
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
name[0] = 'p' + i;
name[1] = '0' + i;
1328: 88 45 c9 mov %al,-0x37(%ebp)
unlink(name);
132b: e8 82 26 00 00 call 39b2 <unlink>
close(fd);
}
}
for(i = 0; i < N; i++){
for(pi = 0; pi < 4; pi++){
1330: 83 c4 10 add $0x10,%esp
1333: 83 eb 01 sub $0x1,%ebx
1336: 75 e3 jne 131b <createdelete+0xeb>
1338: 83 c6 01 add $0x1,%esi
if(fd >= 0)
close(fd);
}
}
for(i = 0; i < N; i++){
133b: 89 f0 mov %esi,%eax
133d: 3c 84 cmp $0x84,%al
133f: 75 cf jne 1310 <createdelete+0xe0>
name[1] = '0' + i;
unlink(name);
}
}
printf(1, "createdelete ok\n");
1341: 83 ec 08 sub $0x8,%esp
1344: 68 9c 42 00 00 push $0x429c
1349: 6a 01 push $0x1
134b: e8 60 27 00 00 call 3ab0 <printf>
}
1350: 83 c4 10 add $0x10,%esp
1353: 8d 65 f4 lea -0xc(%ebp),%esp
1356: 5b pop %ebx
1357: 5e pop %esi
1358: 5f pop %edi
1359: 5d pop %ebp
135a: c3 ret
printf(1, "fork failed\n");
exit();
}
if(pid == 0){
name[0] = 'p' + pi;
135b: 83 c3 70 add $0x70,%ebx
name[2] = '\0';
135e: c6 45 ca 00 movb $0x0,-0x36(%ebp)
1362: be 01 00 00 00 mov $0x1,%esi
printf(1, "fork failed\n");
exit();
}
if(pid == 0){
name[0] = 'p' + pi;
1367: 88 5d c8 mov %bl,-0x38(%ebp)
136a: 8d 7d c8 lea -0x38(%ebp),%edi
name[2] = '\0';
136d: 31 db xor %ebx,%ebx
136f: eb 12 jmp 1383 <createdelete+0x153>
1371: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(i = 0; i < N; i++){
1378: 83 fe 14 cmp $0x14,%esi
137b: 74 6b je 13e8 <createdelete+0x1b8>
137d: 83 c3 01 add $0x1,%ebx
1380: 83 c6 01 add $0x1,%esi
name[1] = '0' + i;
fd = open(name, O_CREATE | O_RDWR);
1383: 83 ec 08 sub $0x8,%esp
if(pid == 0){
name[0] = 'p' + pi;
name[2] = '\0';
for(i = 0; i < N; i++){
name[1] = '0' + i;
1386: 8d 43 30 lea 0x30(%ebx),%eax
fd = open(name, O_CREATE | O_RDWR);
1389: 68 02 02 00 00 push $0x202
138e: 57 push %edi
if(pid == 0){
name[0] = 'p' + pi;
name[2] = '\0';
for(i = 0; i < N; i++){
name[1] = '0' + i;
138f: 88 45 c9 mov %al,-0x37(%ebp)
fd = open(name, O_CREATE | O_RDWR);
1392: e8 0b 26 00 00 call 39a2 <open>
if(fd < 0){
1397: 83 c4 10 add $0x10,%esp
139a: 85 c0 test %eax,%eax
139c: 78 64 js 1402 <createdelete+0x1d2>
printf(1, "create failed\n");
exit();
}
close(fd);
139e: 83 ec 0c sub $0xc,%esp
13a1: 50 push %eax
13a2: e8 e3 25 00 00 call 398a <close>
if(i > 0 && (i % 2 ) == 0){
13a7: 83 c4 10 add $0x10,%esp
13aa: 85 db test %ebx,%ebx
13ac: 74 cf je 137d <createdelete+0x14d>
13ae: f6 c3 01 test $0x1,%bl
13b1: 75 c5 jne 1378 <createdelete+0x148>
name[1] = '0' + (i / 2);
if(unlink(name) < 0){
13b3: 83 ec 0c sub $0xc,%esp
printf(1, "create failed\n");
exit();
}
close(fd);
if(i > 0 && (i % 2 ) == 0){
name[1] = '0' + (i / 2);
13b6: 89 d8 mov %ebx,%eax
13b8: d1 f8 sar %eax
if(unlink(name) < 0){
13ba: 57 push %edi
printf(1, "create failed\n");
exit();
}
close(fd);
if(i > 0 && (i % 2 ) == 0){
name[1] = '0' + (i / 2);
13bb: 83 c0 30 add $0x30,%eax
13be: 88 45 c9 mov %al,-0x37(%ebp)
if(unlink(name) < 0){
13c1: e8 ec 25 00 00 call 39b2 <unlink>
13c6: 83 c4 10 add $0x10,%esp
13c9: 85 c0 test %eax,%eax
13cb: 79 ab jns 1378 <createdelete+0x148>
printf(1, "unlink failed\n");
13cd: 83 ec 08 sub $0x8,%esp
13d0: 68 89 3e 00 00 push $0x3e89
13d5: 6a 01 push $0x1
13d7: e8 d4 26 00 00 call 3ab0 <printf>
exit();
13dc: e8 81 25 00 00 call 3962 <exit>
13e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
}
}
}
exit();
13e8: e8 75 25 00 00 call 3962 <exit>
for(pi = 0; pi < 4; pi++){
name[0] = 'p' + pi;
name[1] = '0' + i;
fd = open(name, 0);
if((i == 0 || i >= N/2) && fd < 0){
printf(1, "oops createdelete %s didn't exist\n", name);
13ed: 83 ec 04 sub $0x4,%esp
13f0: 57 push %edi
13f1: 68 48 4f 00 00 push $0x4f48
13f6: 6a 01 push $0x1
13f8: e8 b3 26 00 00 call 3ab0 <printf>
exit();
13fd: e8 60 25 00 00 call 3962 <exit>
name[2] = '\0';
for(i = 0; i < N; i++){
name[1] = '0' + i;
fd = open(name, O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "create failed\n");
1402: 83 ec 08 sub $0x8,%esp
1405: 68 d8 44 00 00 push $0x44d8
140a: 6a 01 push $0x1
140c: e8 9f 26 00 00 call 3ab0 <printf>
exit();
1411: e8 4c 25 00 00 call 3962 <exit>
printf(1, "createdelete test\n");
for(pi = 0; pi < 4; pi++){
pid = fork(0);
if(pid < 0){
printf(1, "fork failed\n");
1416: 83 ec 08 sub $0x8,%esp
1419: 68 12 4d 00 00 push $0x4d12
141e: 6a 01 push $0x1
1420: e8 8b 26 00 00 call 3ab0 <printf>
exit();
1425: e8 38 25 00 00 call 3962 <exit>
name[1] = '0' + i;
fd = open(name, 0);
if((i == 0 || i >= N/2) && fd < 0){
printf(1, "oops createdelete %s didn't exist\n", name);
exit();
} else if((i >= 1 && i < N/2) && fd >= 0){
142a: 85 c0 test %eax,%eax
142c: 0f 88 c4 fe ff ff js 12f6 <createdelete+0xc6>
printf(1, "oops createdelete %s did exist\n", name);
1432: 83 ec 04 sub $0x4,%esp
1435: 57 push %edi
1436: 68 6c 4f 00 00 push $0x4f6c
143b: 6a 01 push $0x1
143d: e8 6e 26 00 00 call 3ab0 <printf>
exit();
1442: e8 1b 25 00 00 call 3962 <exit>
1447: 89 f6 mov %esi,%esi
1449: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00001450 <unlinkread>:
}
// can I unlink a file and still read it?
void
unlinkread(void)
{
1450: 55 push %ebp
1451: 89 e5 mov %esp,%ebp
1453: 56 push %esi
1454: 53 push %ebx
int fd, fd1;
printf(1, "unlinkread test\n");
1455: 83 ec 08 sub $0x8,%esp
1458: 68 ad 42 00 00 push $0x42ad
145d: 6a 01 push $0x1
145f: e8 4c 26 00 00 call 3ab0 <printf>
fd = open("unlinkread", O_CREATE | O_RDWR);
1464: 5b pop %ebx
1465: 5e pop %esi
1466: 68 02 02 00 00 push $0x202
146b: 68 be 42 00 00 push $0x42be
1470: e8 2d 25 00 00 call 39a2 <open>
if(fd < 0){
1475: 83 c4 10 add $0x10,%esp
1478: 85 c0 test %eax,%eax
147a: 0f 88 e6 00 00 00 js 1566 <unlinkread+0x116>
printf(1, "create unlinkread failed\n");
exit();
}
write(fd, "hello", 5);
1480: 83 ec 04 sub $0x4,%esp
1483: 89 c3 mov %eax,%ebx
1485: 6a 05 push $0x5
1487: 68 e3 42 00 00 push $0x42e3
148c: 50 push %eax
148d: e8 f0 24 00 00 call 3982 <write>
close(fd);
1492: 89 1c 24 mov %ebx,(%esp)
1495: e8 f0 24 00 00 call 398a <close>
fd = open("unlinkread", O_RDWR);
149a: 58 pop %eax
149b: 5a pop %edx
149c: 6a 02 push $0x2
149e: 68 be 42 00 00 push $0x42be
14a3: e8 fa 24 00 00 call 39a2 <open>
if(fd < 0){
14a8: 83 c4 10 add $0x10,%esp
14ab: 85 c0 test %eax,%eax
exit();
}
write(fd, "hello", 5);
close(fd);
fd = open("unlinkread", O_RDWR);
14ad: 89 c3 mov %eax,%ebx
if(fd < 0){
14af: 0f 88 10 01 00 00 js 15c5 <unlinkread+0x175>
printf(1, "open unlinkread failed\n");
exit();
}
if(unlink("unlinkread") != 0){
14b5: 83 ec 0c sub $0xc,%esp
14b8: 68 be 42 00 00 push $0x42be
14bd: e8 f0 24 00 00 call 39b2 <unlink>
14c2: 83 c4 10 add $0x10,%esp
14c5: 85 c0 test %eax,%eax
14c7: 0f 85 e5 00 00 00 jne 15b2 <unlinkread+0x162>
printf(1, "unlink unlinkread failed\n");
exit();
}
fd1 = open("unlinkread", O_CREATE | O_RDWR);
14cd: 83 ec 08 sub $0x8,%esp
14d0: 68 02 02 00 00 push $0x202
14d5: 68 be 42 00 00 push $0x42be
14da: e8 c3 24 00 00 call 39a2 <open>
write(fd1, "yyy", 3);
14df: 83 c4 0c add $0xc,%esp
if(unlink("unlinkread") != 0){
printf(1, "unlink unlinkread failed\n");
exit();
}
fd1 = open("unlinkread", O_CREATE | O_RDWR);
14e2: 89 c6 mov %eax,%esi
write(fd1, "yyy", 3);
14e4: 6a 03 push $0x3
14e6: 68 1b 43 00 00 push $0x431b
14eb: 50 push %eax
14ec: e8 91 24 00 00 call 3982 <write>
close(fd1);
14f1: 89 34 24 mov %esi,(%esp)
14f4: e8 91 24 00 00 call 398a <close>
if(read(fd, buf, sizeof(buf)) != 5){
14f9: 83 c4 0c add $0xc,%esp
14fc: 68 00 20 00 00 push $0x2000
1501: 68 40 86 00 00 push $0x8640
1506: 53 push %ebx
1507: e8 6e 24 00 00 call 397a <read>
150c: 83 c4 10 add $0x10,%esp
150f: 83 f8 05 cmp $0x5,%eax
1512: 0f 85 87 00 00 00 jne 159f <unlinkread+0x14f>
printf(1, "unlinkread read failed");
exit();
}
if(buf[0] != 'h'){
1518: 80 3d 40 86 00 00 68 cmpb $0x68,0x8640
151f: 75 6b jne 158c <unlinkread+0x13c>
printf(1, "unlinkread wrong data\n");
exit();
}
if(write(fd, buf, 10) != 10){
1521: 83 ec 04 sub $0x4,%esp
1524: 6a 0a push $0xa
1526: 68 40 86 00 00 push $0x8640
152b: 53 push %ebx
152c: e8 51 24 00 00 call 3982 <write>
1531: 83 c4 10 add $0x10,%esp
1534: 83 f8 0a cmp $0xa,%eax
1537: 75 40 jne 1579 <unlinkread+0x129>
printf(1, "unlinkread write failed\n");
exit();
}
close(fd);
1539: 83 ec 0c sub $0xc,%esp
153c: 53 push %ebx
153d: e8 48 24 00 00 call 398a <close>
unlink("unlinkread");
1542: c7 04 24 be 42 00 00 movl $0x42be,(%esp)
1549: e8 64 24 00 00 call 39b2 <unlink>
printf(1, "unlinkread ok\n");
154e: 58 pop %eax
154f: 5a pop %edx
1550: 68 66 43 00 00 push $0x4366
1555: 6a 01 push $0x1
1557: e8 54 25 00 00 call 3ab0 <printf>
}
155c: 83 c4 10 add $0x10,%esp
155f: 8d 65 f8 lea -0x8(%ebp),%esp
1562: 5b pop %ebx
1563: 5e pop %esi
1564: 5d pop %ebp
1565: c3 ret
int fd, fd1;
printf(1, "unlinkread test\n");
fd = open("unlinkread", O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "create unlinkread failed\n");
1566: 51 push %ecx
1567: 51 push %ecx
1568: 68 c9 42 00 00 push $0x42c9
156d: 6a 01 push $0x1
156f: e8 3c 25 00 00 call 3ab0 <printf>
exit();
1574: e8 e9 23 00 00 call 3962 <exit>
if(buf[0] != 'h'){
printf(1, "unlinkread wrong data\n");
exit();
}
if(write(fd, buf, 10) != 10){
printf(1, "unlinkread write failed\n");
1579: 51 push %ecx
157a: 51 push %ecx
157b: 68 4d 43 00 00 push $0x434d
1580: 6a 01 push $0x1
1582: e8 29 25 00 00 call 3ab0 <printf>
exit();
1587: e8 d6 23 00 00 call 3962 <exit>
if(read(fd, buf, sizeof(buf)) != 5){
printf(1, "unlinkread read failed");
exit();
}
if(buf[0] != 'h'){
printf(1, "unlinkread wrong data\n");
158c: 53 push %ebx
158d: 53 push %ebx
158e: 68 36 43 00 00 push $0x4336
1593: 6a 01 push $0x1
1595: e8 16 25 00 00 call 3ab0 <printf>
exit();
159a: e8 c3 23 00 00 call 3962 <exit>
fd1 = open("unlinkread", O_CREATE | O_RDWR);
write(fd1, "yyy", 3);
close(fd1);
if(read(fd, buf, sizeof(buf)) != 5){
printf(1, "unlinkread read failed");
159f: 56 push %esi
15a0: 56 push %esi
15a1: 68 1f 43 00 00 push $0x431f
15a6: 6a 01 push $0x1
15a8: e8 03 25 00 00 call 3ab0 <printf>
exit();
15ad: e8 b0 23 00 00 call 3962 <exit>
if(fd < 0){
printf(1, "open unlinkread failed\n");
exit();
}
if(unlink("unlinkread") != 0){
printf(1, "unlink unlinkread failed\n");
15b2: 50 push %eax
15b3: 50 push %eax
15b4: 68 01 43 00 00 push $0x4301
15b9: 6a 01 push $0x1
15bb: e8 f0 24 00 00 call 3ab0 <printf>
exit();
15c0: e8 9d 23 00 00 call 3962 <exit>
write(fd, "hello", 5);
close(fd);
fd = open("unlinkread", O_RDWR);
if(fd < 0){
printf(1, "open unlinkread failed\n");
15c5: 50 push %eax
15c6: 50 push %eax
15c7: 68 e9 42 00 00 push $0x42e9
15cc: 6a 01 push $0x1
15ce: e8 dd 24 00 00 call 3ab0 <printf>
exit();
15d3: e8 8a 23 00 00 call 3962 <exit>
15d8: 90 nop
15d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000015e0 <linktest>:
printf(1, "unlinkread ok\n");
}
void
linktest(void)
{
15e0: 55 push %ebp
15e1: 89 e5 mov %esp,%ebp
15e3: 53 push %ebx
15e4: 83 ec 0c sub $0xc,%esp
int fd;
printf(1, "linktest\n");
15e7: 68 75 43 00 00 push $0x4375
15ec: 6a 01 push $0x1
15ee: e8 bd 24 00 00 call 3ab0 <printf>
unlink("lf1");
15f3: c7 04 24 7f 43 00 00 movl $0x437f,(%esp)
15fa: e8 b3 23 00 00 call 39b2 <unlink>
unlink("lf2");
15ff: c7 04 24 83 43 00 00 movl $0x4383,(%esp)
1606: e8 a7 23 00 00 call 39b2 <unlink>
fd = open("lf1", O_CREATE|O_RDWR);
160b: 58 pop %eax
160c: 5a pop %edx
160d: 68 02 02 00 00 push $0x202
1612: 68 7f 43 00 00 push $0x437f
1617: e8 86 23 00 00 call 39a2 <open>
if(fd < 0){
161c: 83 c4 10 add $0x10,%esp
161f: 85 c0 test %eax,%eax
1621: 0f 88 1e 01 00 00 js 1745 <linktest+0x165>
printf(1, "create lf1 failed\n");
exit();
}
if(write(fd, "hello", 5) != 5){
1627: 83 ec 04 sub $0x4,%esp
162a: 89 c3 mov %eax,%ebx
162c: 6a 05 push $0x5
162e: 68 e3 42 00 00 push $0x42e3
1633: 50 push %eax
1634: e8 49 23 00 00 call 3982 <write>
1639: 83 c4 10 add $0x10,%esp
163c: 83 f8 05 cmp $0x5,%eax
163f: 0f 85 98 01 00 00 jne 17dd <linktest+0x1fd>
printf(1, "write lf1 failed\n");
exit();
}
close(fd);
1645: 83 ec 0c sub $0xc,%esp
1648: 53 push %ebx
1649: e8 3c 23 00 00 call 398a <close>
if(link("lf1", "lf2") < 0){
164e: 5b pop %ebx
164f: 58 pop %eax
1650: 68 83 43 00 00 push $0x4383
1655: 68 7f 43 00 00 push $0x437f
165a: e8 63 23 00 00 call 39c2 <link>
165f: 83 c4 10 add $0x10,%esp
1662: 85 c0 test %eax,%eax
1664: 0f 88 60 01 00 00 js 17ca <linktest+0x1ea>
printf(1, "link lf1 lf2 failed\n");
exit();
}
unlink("lf1");
166a: 83 ec 0c sub $0xc,%esp
166d: 68 7f 43 00 00 push $0x437f
1672: e8 3b 23 00 00 call 39b2 <unlink>
if(open("lf1", 0) >= 0){
1677: 58 pop %eax
1678: 5a pop %edx
1679: 6a 00 push $0x0
167b: 68 7f 43 00 00 push $0x437f
1680: e8 1d 23 00 00 call 39a2 <open>
1685: 83 c4 10 add $0x10,%esp
1688: 85 c0 test %eax,%eax
168a: 0f 89 27 01 00 00 jns 17b7 <linktest+0x1d7>
printf(1, "unlinked lf1 but it is still there!\n");
exit();
}
fd = open("lf2", 0);
1690: 83 ec 08 sub $0x8,%esp
1693: 6a 00 push $0x0
1695: 68 83 43 00 00 push $0x4383
169a: e8 03 23 00 00 call 39a2 <open>
if(fd < 0){
169f: 83 c4 10 add $0x10,%esp
16a2: 85 c0 test %eax,%eax
if(open("lf1", 0) >= 0){
printf(1, "unlinked lf1 but it is still there!\n");
exit();
}
fd = open("lf2", 0);
16a4: 89 c3 mov %eax,%ebx
if(fd < 0){
16a6: 0f 88 f8 00 00 00 js 17a4 <linktest+0x1c4>
printf(1, "open lf2 failed\n");
exit();
}
if(read(fd, buf, sizeof(buf)) != 5){
16ac: 83 ec 04 sub $0x4,%esp
16af: 68 00 20 00 00 push $0x2000
16b4: 68 40 86 00 00 push $0x8640
16b9: 50 push %eax
16ba: e8 bb 22 00 00 call 397a <read>
16bf: 83 c4 10 add $0x10,%esp
16c2: 83 f8 05 cmp $0x5,%eax
16c5: 0f 85 c6 00 00 00 jne 1791 <linktest+0x1b1>
printf(1, "read lf2 failed\n");
exit();
}
close(fd);
16cb: 83 ec 0c sub $0xc,%esp
16ce: 53 push %ebx
16cf: e8 b6 22 00 00 call 398a <close>
if(link("lf2", "lf2") >= 0){
16d4: 58 pop %eax
16d5: 5a pop %edx
16d6: 68 83 43 00 00 push $0x4383
16db: 68 83 43 00 00 push $0x4383
16e0: e8 dd 22 00 00 call 39c2 <link>
16e5: 83 c4 10 add $0x10,%esp
16e8: 85 c0 test %eax,%eax
16ea: 0f 89 8e 00 00 00 jns 177e <linktest+0x19e>
printf(1, "link lf2 lf2 succeeded! oops\n");
exit();
}
unlink("lf2");
16f0: 83 ec 0c sub $0xc,%esp
16f3: 68 83 43 00 00 push $0x4383
16f8: e8 b5 22 00 00 call 39b2 <unlink>
if(link("lf2", "lf1") >= 0){
16fd: 59 pop %ecx
16fe: 5b pop %ebx
16ff: 68 7f 43 00 00 push $0x437f
1704: 68 83 43 00 00 push $0x4383
1709: e8 b4 22 00 00 call 39c2 <link>
170e: 83 c4 10 add $0x10,%esp
1711: 85 c0 test %eax,%eax
1713: 79 56 jns 176b <linktest+0x18b>
printf(1, "link non-existant succeeded! oops\n");
exit();
}
if(link(".", "lf1") >= 0){
1715: 83 ec 08 sub $0x8,%esp
1718: 68 7f 43 00 00 push $0x437f
171d: 68 47 46 00 00 push $0x4647
1722: e8 9b 22 00 00 call 39c2 <link>
1727: 83 c4 10 add $0x10,%esp
172a: 85 c0 test %eax,%eax
172c: 79 2a jns 1758 <linktest+0x178>
printf(1, "link . lf1 succeeded! oops\n");
exit();
}
printf(1, "linktest ok\n");
172e: 83 ec 08 sub $0x8,%esp
1731: 68 1d 44 00 00 push $0x441d
1736: 6a 01 push $0x1
1738: e8 73 23 00 00 call 3ab0 <printf>
}
173d: 83 c4 10 add $0x10,%esp
1740: 8b 5d fc mov -0x4(%ebp),%ebx
1743: c9 leave
1744: c3 ret
unlink("lf1");
unlink("lf2");
fd = open("lf1", O_CREATE|O_RDWR);
if(fd < 0){
printf(1, "create lf1 failed\n");
1745: 50 push %eax
1746: 50 push %eax
1747: 68 87 43 00 00 push $0x4387
174c: 6a 01 push $0x1
174e: e8 5d 23 00 00 call 3ab0 <printf>
exit();
1753: e8 0a 22 00 00 call 3962 <exit>
printf(1, "link non-existant succeeded! oops\n");
exit();
}
if(link(".", "lf1") >= 0){
printf(1, "link . lf1 succeeded! oops\n");
1758: 50 push %eax
1759: 50 push %eax
175a: 68 01 44 00 00 push $0x4401
175f: 6a 01 push $0x1
1761: e8 4a 23 00 00 call 3ab0 <printf>
exit();
1766: e8 f7 21 00 00 call 3962 <exit>
exit();
}
unlink("lf2");
if(link("lf2", "lf1") >= 0){
printf(1, "link non-existant succeeded! oops\n");
176b: 52 push %edx
176c: 52 push %edx
176d: 68 b4 4f 00 00 push $0x4fb4
1772: 6a 01 push $0x1
1774: e8 37 23 00 00 call 3ab0 <printf>
exit();
1779: e8 e4 21 00 00 call 3962 <exit>
exit();
}
close(fd);
if(link("lf2", "lf2") >= 0){
printf(1, "link lf2 lf2 succeeded! oops\n");
177e: 50 push %eax
177f: 50 push %eax
1780: 68 e3 43 00 00 push $0x43e3
1785: 6a 01 push $0x1
1787: e8 24 23 00 00 call 3ab0 <printf>
exit();
178c: e8 d1 21 00 00 call 3962 <exit>
if(fd < 0){
printf(1, "open lf2 failed\n");
exit();
}
if(read(fd, buf, sizeof(buf)) != 5){
printf(1, "read lf2 failed\n");
1791: 51 push %ecx
1792: 51 push %ecx
1793: 68 d2 43 00 00 push $0x43d2
1798: 6a 01 push $0x1
179a: e8 11 23 00 00 call 3ab0 <printf>
exit();
179f: e8 be 21 00 00 call 3962 <exit>
exit();
}
fd = open("lf2", 0);
if(fd < 0){
printf(1, "open lf2 failed\n");
17a4: 53 push %ebx
17a5: 53 push %ebx
17a6: 68 c1 43 00 00 push $0x43c1
17ab: 6a 01 push $0x1
17ad: e8 fe 22 00 00 call 3ab0 <printf>
exit();
17b2: e8 ab 21 00 00 call 3962 <exit>
exit();
}
unlink("lf1");
if(open("lf1", 0) >= 0){
printf(1, "unlinked lf1 but it is still there!\n");
17b7: 50 push %eax
17b8: 50 push %eax
17b9: 68 8c 4f 00 00 push $0x4f8c
17be: 6a 01 push $0x1
17c0: e8 eb 22 00 00 call 3ab0 <printf>
exit();
17c5: e8 98 21 00 00 call 3962 <exit>
exit();
}
close(fd);
if(link("lf1", "lf2") < 0){
printf(1, "link lf1 lf2 failed\n");
17ca: 51 push %ecx
17cb: 51 push %ecx
17cc: 68 ac 43 00 00 push $0x43ac
17d1: 6a 01 push $0x1
17d3: e8 d8 22 00 00 call 3ab0 <printf>
exit();
17d8: e8 85 21 00 00 call 3962 <exit>
if(fd < 0){
printf(1, "create lf1 failed\n");
exit();
}
if(write(fd, "hello", 5) != 5){
printf(1, "write lf1 failed\n");
17dd: 50 push %eax
17de: 50 push %eax
17df: 68 9a 43 00 00 push $0x439a
17e4: 6a 01 push $0x1
17e6: e8 c5 22 00 00 call 3ab0 <printf>
exit();
17eb: e8 72 21 00 00 call 3962 <exit>
000017f0 <concreate>:
}
// test concurrent create/link/unlink of the same file
void
concreate(void)
{
17f0: 55 push %ebp
17f1: 89 e5 mov %esp,%ebp
17f3: 57 push %edi
17f4: 56 push %esi
17f5: 53 push %ebx
} de;
printf(1, "concreate test\n");
file[0] = 'C';
file[2] = '\0';
for(i = 0; i < 40; i++){
17f6: 31 f6 xor %esi,%esi
17f8: 8d 5d ad lea -0x53(%ebp),%ebx
file[1] = '0' + i;
unlink(file);
pid = fork(0);
if(pid && (i % 3) == 1){
17fb: bf 56 55 55 55 mov $0x55555556,%edi
}
// test concurrent create/link/unlink of the same file
void
concreate(void)
{
1800: 83 ec 64 sub $0x64,%esp
struct {
ushort inum;
char name[14];
} de;
printf(1, "concreate test\n");
1803: 68 2a 44 00 00 push $0x442a
1808: 6a 01 push $0x1
180a: e8 a1 22 00 00 call 3ab0 <printf>
file[0] = 'C';
180f: c6 45 ad 43 movb $0x43,-0x53(%ebp)
file[2] = '\0';
1813: c6 45 af 00 movb $0x0,-0x51(%ebp)
1817: 83 c4 10 add $0x10,%esp
181a: eb 51 jmp 186d <concreate+0x7d>
181c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(i = 0; i < 40; i++){
file[1] = '0' + i;
unlink(file);
pid = fork(0);
if(pid && (i % 3) == 1){
1820: 89 f0 mov %esi,%eax
1822: 89 f1 mov %esi,%ecx
1824: f7 ef imul %edi
1826: 89 f0 mov %esi,%eax
1828: c1 f8 1f sar $0x1f,%eax
182b: 29 c2 sub %eax,%edx
182d: 8d 04 52 lea (%edx,%edx,2),%eax
1830: 29 c1 sub %eax,%ecx
1832: 83 f9 01 cmp $0x1,%ecx
1835: 0f 84 c5 00 00 00 je 1900 <concreate+0x110>
link("C0", file);
} else if(pid == 0 && (i % 5) == 1){
link("C0", file);
} else {
fd = open(file, O_CREATE | O_RDWR);
183b: 83 ec 08 sub $0x8,%esp
183e: 68 02 02 00 00 push $0x202
1843: 53 push %ebx
1844: e8 59 21 00 00 call 39a2 <open>
if(fd < 0){
1849: 83 c4 10 add $0x10,%esp
184c: 85 c0 test %eax,%eax
184e: 78 74 js 18c4 <concreate+0xd4>
printf(1, "concreate create %s failed\n", file);
exit();
}
close(fd);
1850: 83 ec 0c sub $0xc,%esp
} de;
printf(1, "concreate test\n");
file[0] = 'C';
file[2] = '\0';
for(i = 0; i < 40; i++){
1853: 83 c6 01 add $0x1,%esi
fd = open(file, O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "concreate create %s failed\n", file);
exit();
}
close(fd);
1856: 50 push %eax
1857: e8 2e 21 00 00 call 398a <close>
185c: 83 c4 10 add $0x10,%esp
}
if(pid == 0)
exit();
else
wait();
185f: e8 06 21 00 00 call 396a <wait>
} de;
printf(1, "concreate test\n");
file[0] = 'C';
file[2] = '\0';
for(i = 0; i < 40; i++){
1864: 83 fe 28 cmp $0x28,%esi
1867: 0f 84 bb 00 00 00 je 1928 <concreate+0x138>
file[1] = '0' + i;
unlink(file);
186d: 83 ec 0c sub $0xc,%esp
printf(1, "concreate test\n");
file[0] = 'C';
file[2] = '\0';
for(i = 0; i < 40; i++){
file[1] = '0' + i;
1870: 8d 46 30 lea 0x30(%esi),%eax
unlink(file);
1873: 53 push %ebx
printf(1, "concreate test\n");
file[0] = 'C';
file[2] = '\0';
for(i = 0; i < 40; i++){
file[1] = '0' + i;
1874: 88 45 ae mov %al,-0x52(%ebp)
unlink(file);
1877: e8 36 21 00 00 call 39b2 <unlink>
pid = fork(0);
187c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1883: e8 d2 20 00 00 call 395a <fork>
if(pid && (i % 3) == 1){
1888: 83 c4 10 add $0x10,%esp
188b: 85 c0 test %eax,%eax
188d: 75 91 jne 1820 <concreate+0x30>
link("C0", file);
} else if(pid == 0 && (i % 5) == 1){
188f: 89 f0 mov %esi,%eax
1891: ba 67 66 66 66 mov $0x66666667,%edx
1896: f7 ea imul %edx
1898: 89 f0 mov %esi,%eax
189a: c1 f8 1f sar $0x1f,%eax
189d: d1 fa sar %edx
189f: 29 c2 sub %eax,%edx
18a1: 8d 04 92 lea (%edx,%edx,4),%eax
18a4: 29 c6 sub %eax,%esi
18a6: 83 fe 01 cmp $0x1,%esi
18a9: 74 35 je 18e0 <concreate+0xf0>
link("C0", file);
} else {
fd = open(file, O_CREATE | O_RDWR);
18ab: 83 ec 08 sub $0x8,%esp
18ae: 68 02 02 00 00 push $0x202
18b3: 53 push %ebx
18b4: e8 e9 20 00 00 call 39a2 <open>
if(fd < 0){
18b9: 83 c4 10 add $0x10,%esp
18bc: 85 c0 test %eax,%eax
18be: 0f 89 4b 02 00 00 jns 1b0f <concreate+0x31f>
printf(1, "concreate create %s failed\n", file);
18c4: 83 ec 04 sub $0x4,%esp
18c7: 53 push %ebx
18c8: 68 3d 44 00 00 push $0x443d
18cd: 6a 01 push $0x1
18cf: e8 dc 21 00 00 call 3ab0 <printf>
exit();
18d4: e8 89 20 00 00 call 3962 <exit>
18d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
unlink(file);
pid = fork(0);
if(pid && (i % 3) == 1){
link("C0", file);
} else if(pid == 0 && (i % 5) == 1){
link("C0", file);
18e0: 83 ec 08 sub $0x8,%esp
18e3: 53 push %ebx
18e4: 68 3a 44 00 00 push $0x443a
18e9: e8 d4 20 00 00 call 39c2 <link>
18ee: 83 c4 10 add $0x10,%esp
exit();
}
close(fd);
}
if(pid == 0)
exit();
18f1: e8 6c 20 00 00 call 3962 <exit>
18f6: 8d 76 00 lea 0x0(%esi),%esi
18f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
for(i = 0; i < 40; i++){
file[1] = '0' + i;
unlink(file);
pid = fork(0);
if(pid && (i % 3) == 1){
link("C0", file);
1900: 83 ec 08 sub $0x8,%esp
} de;
printf(1, "concreate test\n");
file[0] = 'C';
file[2] = '\0';
for(i = 0; i < 40; i++){
1903: 83 c6 01 add $0x1,%esi
file[1] = '0' + i;
unlink(file);
pid = fork(0);
if(pid && (i % 3) == 1){
link("C0", file);
1906: 53 push %ebx
1907: 68 3a 44 00 00 push $0x443a
190c: e8 b1 20 00 00 call 39c2 <link>
1911: 83 c4 10 add $0x10,%esp
close(fd);
}
if(pid == 0)
exit();
else
wait();
1914: e8 51 20 00 00 call 396a <wait>
} de;
printf(1, "concreate test\n");
file[0] = 'C';
file[2] = '\0';
for(i = 0; i < 40; i++){
1919: 83 fe 28 cmp $0x28,%esi
191c: 0f 85 4b ff ff ff jne 186d <concreate+0x7d>
1922: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
exit();
else
wait();
}
memset(fa, 0, sizeof(fa));
1928: 8d 45 c0 lea -0x40(%ebp),%eax
192b: 83 ec 04 sub $0x4,%esp
192e: 8d 7d b0 lea -0x50(%ebp),%edi
1931: 6a 28 push $0x28
1933: 6a 00 push $0x0
1935: 50 push %eax
1936: e8 95 1e 00 00 call 37d0 <memset>
fd = open(".", 0);
193b: 59 pop %ecx
193c: 5e pop %esi
193d: 6a 00 push $0x0
193f: 68 47 46 00 00 push $0x4647
1944: e8 59 20 00 00 call 39a2 <open>
n = 0;
while(read(fd, &de, sizeof(de)) > 0){
1949: 83 c4 10 add $0x10,%esp
else
wait();
}
memset(fa, 0, sizeof(fa));
fd = open(".", 0);
194c: 89 c6 mov %eax,%esi
n = 0;
194e: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
1955: 8d 76 00 lea 0x0(%esi),%esi
while(read(fd, &de, sizeof(de)) > 0){
1958: 83 ec 04 sub $0x4,%esp
195b: 6a 10 push $0x10
195d: 57 push %edi
195e: 56 push %esi
195f: e8 16 20 00 00 call 397a <read>
1964: 83 c4 10 add $0x10,%esp
1967: 85 c0 test %eax,%eax
1969: 7e 3d jle 19a8 <concreate+0x1b8>
if(de.inum == 0)
196b: 66 83 7d b0 00 cmpw $0x0,-0x50(%ebp)
1970: 74 e6 je 1958 <concreate+0x168>
continue;
if(de.name[0] == 'C' && de.name[2] == '\0'){
1972: 80 7d b2 43 cmpb $0x43,-0x4e(%ebp)
1976: 75 e0 jne 1958 <concreate+0x168>
1978: 80 7d b4 00 cmpb $0x0,-0x4c(%ebp)
197c: 75 da jne 1958 <concreate+0x168>
i = de.name[1] - '0';
197e: 0f be 45 b3 movsbl -0x4d(%ebp),%eax
1982: 83 e8 30 sub $0x30,%eax
if(i < 0 || i >= sizeof(fa)){
1985: 83 f8 27 cmp $0x27,%eax
1988: 0f 87 69 01 00 00 ja 1af7 <concreate+0x307>
printf(1, "concreate weird file %s\n", de.name);
exit();
}
if(fa[i]){
198e: 80 7c 05 c0 00 cmpb $0x0,-0x40(%ebp,%eax,1)
1993: 0f 85 46 01 00 00 jne 1adf <concreate+0x2ef>
printf(1, "concreate duplicate file %s\n", de.name);
exit();
}
fa[i] = 1;
1999: c6 44 05 c0 01 movb $0x1,-0x40(%ebp,%eax,1)
n++;
199e: 83 45 a4 01 addl $0x1,-0x5c(%ebp)
19a2: eb b4 jmp 1958 <concreate+0x168>
19a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
}
close(fd);
19a8: 83 ec 0c sub $0xc,%esp
19ab: 56 push %esi
19ac: e8 d9 1f 00 00 call 398a <close>
if(n != 40){
19b1: 83 c4 10 add $0x10,%esp
19b4: 83 7d a4 28 cmpl $0x28,-0x5c(%ebp)
19b8: 0f 85 0d 01 00 00 jne 1acb <concreate+0x2db>
19be: 31 f6 xor %esi,%esi
19c0: eb 70 jmp 1a32 <concreate+0x242>
19c2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(pid < 0){
printf(1, "fork failed\n");
exit();
}
if(((i % 3) == 0 && pid == 0) ||
((i % 3) == 1 && pid != 0)){
19c8: 83 fa 01 cmp $0x1,%edx
19cb: 0f 85 a1 00 00 00 jne 1a72 <concreate+0x282>
close(open(file, 0));
19d1: 83 ec 08 sub $0x8,%esp
19d4: 6a 00 push $0x0
19d6: 53 push %ebx
19d7: e8 c6 1f 00 00 call 39a2 <open>
19dc: 89 04 24 mov %eax,(%esp)
19df: e8 a6 1f 00 00 call 398a <close>
close(open(file, 0));
19e4: 58 pop %eax
19e5: 5a pop %edx
19e6: 6a 00 push $0x0
19e8: 53 push %ebx
19e9: e8 b4 1f 00 00 call 39a2 <open>
19ee: 89 04 24 mov %eax,(%esp)
19f1: e8 94 1f 00 00 call 398a <close>
close(open(file, 0));
19f6: 59 pop %ecx
19f7: 58 pop %eax
19f8: 6a 00 push $0x0
19fa: 53 push %ebx
19fb: e8 a2 1f 00 00 call 39a2 <open>
1a00: 89 04 24 mov %eax,(%esp)
1a03: e8 82 1f 00 00 call 398a <close>
close(open(file, 0));
1a08: 58 pop %eax
1a09: 5a pop %edx
1a0a: 6a 00 push $0x0
1a0c: 53 push %ebx
1a0d: e8 90 1f 00 00 call 39a2 <open>
1a12: 89 04 24 mov %eax,(%esp)
1a15: e8 70 1f 00 00 call 398a <close>
1a1a: 83 c4 10 add $0x10,%esp
unlink(file);
unlink(file);
unlink(file);
unlink(file);
}
if(pid == 0)
1a1d: 85 ff test %edi,%edi
1a1f: 0f 84 cc fe ff ff je 18f1 <concreate+0x101>
if(n != 40){
printf(1, "concreate not enough files in directory listing\n");
exit();
}
for(i = 0; i < 40; i++){
1a25: 83 c6 01 add $0x1,%esi
unlink(file);
}
if(pid == 0)
exit();
else
wait();
1a28: e8 3d 1f 00 00 call 396a <wait>
if(n != 40){
printf(1, "concreate not enough files in directory listing\n");
exit();
}
for(i = 0; i < 40; i++){
1a2d: 83 fe 28 cmp $0x28,%esi
1a30: 74 6e je 1aa0 <concreate+0x2b0>
file[1] = '0' + i;
pid = fork(0);
1a32: 83 ec 0c sub $0xc,%esp
printf(1, "concreate not enough files in directory listing\n");
exit();
}
for(i = 0; i < 40; i++){
file[1] = '0' + i;
1a35: 8d 46 30 lea 0x30(%esi),%eax
pid = fork(0);
1a38: 6a 00 push $0x0
printf(1, "concreate not enough files in directory listing\n");
exit();
}
for(i = 0; i < 40; i++){
file[1] = '0' + i;
1a3a: 88 45 ae mov %al,-0x52(%ebp)
pid = fork(0);
1a3d: e8 18 1f 00 00 call 395a <fork>
if(pid < 0){
1a42: 83 c4 10 add $0x10,%esp
1a45: 85 c0 test %eax,%eax
exit();
}
for(i = 0; i < 40; i++){
file[1] = '0' + i;
pid = fork(0);
1a47: 89 c7 mov %eax,%edi
if(pid < 0){
1a49: 78 6c js 1ab7 <concreate+0x2c7>
printf(1, "fork failed\n");
exit();
}
if(((i % 3) == 0 && pid == 0) ||
1a4b: b8 56 55 55 55 mov $0x55555556,%eax
1a50: f7 ee imul %esi
1a52: 89 f0 mov %esi,%eax
1a54: c1 f8 1f sar $0x1f,%eax
1a57: 29 c2 sub %eax,%edx
1a59: 8d 04 52 lea (%edx,%edx,2),%eax
1a5c: 89 f2 mov %esi,%edx
1a5e: 29 c2 sub %eax,%edx
1a60: 89 f8 mov %edi,%eax
1a62: 09 d0 or %edx,%eax
1a64: 0f 84 67 ff ff ff je 19d1 <concreate+0x1e1>
((i % 3) == 1 && pid != 0)){
1a6a: 85 ff test %edi,%edi
1a6c: 0f 85 56 ff ff ff jne 19c8 <concreate+0x1d8>
close(open(file, 0));
close(open(file, 0));
close(open(file, 0));
close(open(file, 0));
} else {
unlink(file);
1a72: 83 ec 0c sub $0xc,%esp
1a75: 53 push %ebx
1a76: e8 37 1f 00 00 call 39b2 <unlink>
unlink(file);
1a7b: 89 1c 24 mov %ebx,(%esp)
1a7e: e8 2f 1f 00 00 call 39b2 <unlink>
unlink(file);
1a83: 89 1c 24 mov %ebx,(%esp)
1a86: e8 27 1f 00 00 call 39b2 <unlink>
unlink(file);
1a8b: 89 1c 24 mov %ebx,(%esp)
1a8e: e8 1f 1f 00 00 call 39b2 <unlink>
1a93: 83 c4 10 add $0x10,%esp
1a96: eb 85 jmp 1a1d <concreate+0x22d>
1a98: 90 nop
1a99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
exit();
else
wait();
}
printf(1, "concreate ok\n");
1aa0: 83 ec 08 sub $0x8,%esp
1aa3: 68 8f 44 00 00 push $0x448f
1aa8: 6a 01 push $0x1
1aaa: e8 01 20 00 00 call 3ab0 <printf>
}
1aaf: 8d 65 f4 lea -0xc(%ebp),%esp
1ab2: 5b pop %ebx
1ab3: 5e pop %esi
1ab4: 5f pop %edi
1ab5: 5d pop %ebp
1ab6: c3 ret
for(i = 0; i < 40; i++){
file[1] = '0' + i;
pid = fork(0);
if(pid < 0){
printf(1, "fork failed\n");
1ab7: 83 ec 08 sub $0x8,%esp
1aba: 68 12 4d 00 00 push $0x4d12
1abf: 6a 01 push $0x1
1ac1: e8 ea 1f 00 00 call 3ab0 <printf>
exit();
1ac6: e8 97 1e 00 00 call 3962 <exit>
}
}
close(fd);
if(n != 40){
printf(1, "concreate not enough files in directory listing\n");
1acb: 83 ec 08 sub $0x8,%esp
1ace: 68 d8 4f 00 00 push $0x4fd8
1ad3: 6a 01 push $0x1
1ad5: e8 d6 1f 00 00 call 3ab0 <printf>
exit();
1ada: e8 83 1e 00 00 call 3962 <exit>
if(i < 0 || i >= sizeof(fa)){
printf(1, "concreate weird file %s\n", de.name);
exit();
}
if(fa[i]){
printf(1, "concreate duplicate file %s\n", de.name);
1adf: 8d 45 b2 lea -0x4e(%ebp),%eax
1ae2: 83 ec 04 sub $0x4,%esp
1ae5: 50 push %eax
1ae6: 68 72 44 00 00 push $0x4472
1aeb: 6a 01 push $0x1
1aed: e8 be 1f 00 00 call 3ab0 <printf>
exit();
1af2: e8 6b 1e 00 00 call 3962 <exit>
if(de.inum == 0)
continue;
if(de.name[0] == 'C' && de.name[2] == '\0'){
i = de.name[1] - '0';
if(i < 0 || i >= sizeof(fa)){
printf(1, "concreate weird file %s\n", de.name);
1af7: 8d 45 b2 lea -0x4e(%ebp),%eax
1afa: 83 ec 04 sub $0x4,%esp
1afd: 50 push %eax
1afe: 68 59 44 00 00 push $0x4459
1b03: 6a 01 push $0x1
1b05: e8 a6 1f 00 00 call 3ab0 <printf>
exit();
1b0a: e8 53 1e 00 00 call 3962 <exit>
fd = open(file, O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "concreate create %s failed\n", file);
exit();
}
close(fd);
1b0f: 83 ec 0c sub $0xc,%esp
1b12: 50 push %eax
1b13: e8 72 1e 00 00 call 398a <close>
1b18: 83 c4 10 add $0x10,%esp
1b1b: e9 d1 fd ff ff jmp 18f1 <concreate+0x101>
00001b20 <linkunlink>:
// another concurrent link/unlink/create test,
// to look for deadlocks.
void
linkunlink()
{
1b20: 55 push %ebp
1b21: 89 e5 mov %esp,%ebp
1b23: 57 push %edi
1b24: 56 push %esi
1b25: 53 push %ebx
1b26: 83 ec 24 sub $0x24,%esp
int pid, i;
printf(1, "linkunlink test\n");
1b29: 68 9d 44 00 00 push $0x449d
1b2e: 6a 01 push $0x1
1b30: e8 7b 1f 00 00 call 3ab0 <printf>
unlink("x");
1b35: c7 04 24 2a 47 00 00 movl $0x472a,(%esp)
1b3c: e8 71 1e 00 00 call 39b2 <unlink>
pid = fork(0);
1b41: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1b48: e8 0d 1e 00 00 call 395a <fork>
if(pid < 0){
1b4d: 83 c4 10 add $0x10,%esp
1b50: 85 c0 test %eax,%eax
int pid, i;
printf(1, "linkunlink test\n");
unlink("x");
pid = fork(0);
1b52: 89 45 e4 mov %eax,-0x1c(%ebp)
if(pid < 0){
1b55: 0f 88 b7 00 00 00 js 1c12 <linkunlink+0xf2>
printf(1, "fork failed\n");
exit();
}
unsigned int x = (pid ? 1 : 97);
1b5b: 83 7d e4 01 cmpl $0x1,-0x1c(%ebp)
1b5f: bb 64 00 00 00 mov $0x64,%ebx
for(i = 0; i < 100; i++){
x = x * 1103515245 + 12345;
if((x % 3) == 0){
1b64: be ab aa aa aa mov $0xaaaaaaab,%esi
if(pid < 0){
printf(1, "fork failed\n");
exit();
}
unsigned int x = (pid ? 1 : 97);
1b69: 19 ff sbb %edi,%edi
1b6b: 83 e7 60 and $0x60,%edi
1b6e: 83 c7 01 add $0x1,%edi
1b71: eb 1f jmp 1b92 <linkunlink+0x72>
1b73: 90 nop
1b74: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(i = 0; i < 100; i++){
x = x * 1103515245 + 12345;
if((x % 3) == 0){
close(open("x", O_RDWR | O_CREATE));
} else if((x % 3) == 1){
1b78: 83 fa 01 cmp $0x1,%edx
1b7b: 74 7b je 1bf8 <linkunlink+0xd8>
link("cat", "x");
} else {
unlink("x");
1b7d: 83 ec 0c sub $0xc,%esp
1b80: 68 2a 47 00 00 push $0x472a
1b85: e8 28 1e 00 00 call 39b2 <unlink>
1b8a: 83 c4 10 add $0x10,%esp
printf(1, "fork failed\n");
exit();
}
unsigned int x = (pid ? 1 : 97);
for(i = 0; i < 100; i++){
1b8d: 83 eb 01 sub $0x1,%ebx
1b90: 74 3d je 1bcf <linkunlink+0xaf>
x = x * 1103515245 + 12345;
1b92: 69 cf 6d 4e c6 41 imul $0x41c64e6d,%edi,%ecx
1b98: 8d b9 39 30 00 00 lea 0x3039(%ecx),%edi
if((x % 3) == 0){
1b9e: 89 f8 mov %edi,%eax
1ba0: f7 e6 mul %esi
1ba2: d1 ea shr %edx
1ba4: 8d 04 52 lea (%edx,%edx,2),%eax
1ba7: 89 fa mov %edi,%edx
1ba9: 29 c2 sub %eax,%edx
1bab: 75 cb jne 1b78 <linkunlink+0x58>
close(open("x", O_RDWR | O_CREATE));
1bad: 83 ec 08 sub $0x8,%esp
1bb0: 68 02 02 00 00 push $0x202
1bb5: 68 2a 47 00 00 push $0x472a
1bba: e8 e3 1d 00 00 call 39a2 <open>
1bbf: 89 04 24 mov %eax,(%esp)
1bc2: e8 c3 1d 00 00 call 398a <close>
1bc7: 83 c4 10 add $0x10,%esp
printf(1, "fork failed\n");
exit();
}
unsigned int x = (pid ? 1 : 97);
for(i = 0; i < 100; i++){
1bca: 83 eb 01 sub $0x1,%ebx
1bcd: 75 c3 jne 1b92 <linkunlink+0x72>
} else {
unlink("x");
}
}
if(pid)
1bcf: 8b 45 e4 mov -0x1c(%ebp),%eax
1bd2: 85 c0 test %eax,%eax
1bd4: 74 50 je 1c26 <linkunlink+0x106>
wait();
1bd6: e8 8f 1d 00 00 call 396a <wait>
else
exit();
printf(1, "linkunlink ok\n");
1bdb: 83 ec 08 sub $0x8,%esp
1bde: 68 b2 44 00 00 push $0x44b2
1be3: 6a 01 push $0x1
1be5: e8 c6 1e 00 00 call 3ab0 <printf>
}
1bea: 8d 65 f4 lea -0xc(%ebp),%esp
1bed: 5b pop %ebx
1bee: 5e pop %esi
1bef: 5f pop %edi
1bf0: 5d pop %ebp
1bf1: c3 ret
1bf2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(i = 0; i < 100; i++){
x = x * 1103515245 + 12345;
if((x % 3) == 0){
close(open("x", O_RDWR | O_CREATE));
} else if((x % 3) == 1){
link("cat", "x");
1bf8: 83 ec 08 sub $0x8,%esp
1bfb: 68 2a 47 00 00 push $0x472a
1c00: 68 ae 44 00 00 push $0x44ae
1c05: e8 b8 1d 00 00 call 39c2 <link>
1c0a: 83 c4 10 add $0x10,%esp
1c0d: e9 7b ff ff ff jmp 1b8d <linkunlink+0x6d>
printf(1, "linkunlink test\n");
unlink("x");
pid = fork(0);
if(pid < 0){
printf(1, "fork failed\n");
1c12: 83 ec 08 sub $0x8,%esp
1c15: 68 12 4d 00 00 push $0x4d12
1c1a: 6a 01 push $0x1
1c1c: e8 8f 1e 00 00 call 3ab0 <printf>
exit();
1c21: e8 3c 1d 00 00 call 3962 <exit>
}
if(pid)
wait();
else
exit();
1c26: e8 37 1d 00 00 call 3962 <exit>
1c2b: 90 nop
1c2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00001c30 <bigdir>:
}
// directory that uses indirect blocks
void
bigdir(void)
{
1c30: 55 push %ebp
1c31: 89 e5 mov %esp,%ebp
1c33: 56 push %esi
1c34: 53 push %ebx
1c35: 83 ec 18 sub $0x18,%esp
int i, fd;
char name[10];
printf(1, "bigdir test\n");
1c38: 68 c1 44 00 00 push $0x44c1
1c3d: 6a 01 push $0x1
1c3f: e8 6c 1e 00 00 call 3ab0 <printf>
unlink("bd");
1c44: c7 04 24 ce 44 00 00 movl $0x44ce,(%esp)
1c4b: e8 62 1d 00 00 call 39b2 <unlink>
fd = open("bd", O_CREATE);
1c50: 58 pop %eax
1c51: 5a pop %edx
1c52: 68 00 02 00 00 push $0x200
1c57: 68 ce 44 00 00 push $0x44ce
1c5c: e8 41 1d 00 00 call 39a2 <open>
if(fd < 0){
1c61: 83 c4 10 add $0x10,%esp
1c64: 85 c0 test %eax,%eax
1c66: 0f 88 de 00 00 00 js 1d4a <bigdir+0x11a>
printf(1, "bigdir create failed\n");
exit();
}
close(fd);
1c6c: 83 ec 0c sub $0xc,%esp
1c6f: 8d 75 ee lea -0x12(%ebp),%esi
for(i = 0; i < 500; i++){
1c72: 31 db xor %ebx,%ebx
fd = open("bd", O_CREATE);
if(fd < 0){
printf(1, "bigdir create failed\n");
exit();
}
close(fd);
1c74: 50 push %eax
1c75: e8 10 1d 00 00 call 398a <close>
1c7a: 83 c4 10 add $0x10,%esp
1c7d: 8d 76 00 lea 0x0(%esi),%esi
for(i = 0; i < 500; i++){
name[0] = 'x';
name[1] = '0' + (i / 64);
1c80: 89 d8 mov %ebx,%eax
name[2] = '0' + (i % 64);
name[3] = '\0';
if(link("bd", name) != 0){
1c82: 83 ec 08 sub $0x8,%esp
exit();
}
close(fd);
for(i = 0; i < 500; i++){
name[0] = 'x';
1c85: c6 45 ee 78 movb $0x78,-0x12(%ebp)
name[1] = '0' + (i / 64);
1c89: c1 f8 06 sar $0x6,%eax
name[2] = '0' + (i % 64);
name[3] = '\0';
if(link("bd", name) != 0){
1c8c: 56 push %esi
1c8d: 68 ce 44 00 00 push $0x44ce
}
close(fd);
for(i = 0; i < 500; i++){
name[0] = 'x';
name[1] = '0' + (i / 64);
1c92: 83 c0 30 add $0x30,%eax
name[2] = '0' + (i % 64);
name[3] = '\0';
1c95: c6 45 f1 00 movb $0x0,-0xf(%ebp)
}
close(fd);
for(i = 0; i < 500; i++){
name[0] = 'x';
name[1] = '0' + (i / 64);
1c99: 88 45 ef mov %al,-0x11(%ebp)
name[2] = '0' + (i % 64);
1c9c: 89 d8 mov %ebx,%eax
1c9e: 83 e0 3f and $0x3f,%eax
1ca1: 83 c0 30 add $0x30,%eax
1ca4: 88 45 f0 mov %al,-0x10(%ebp)
name[3] = '\0';
if(link("bd", name) != 0){
1ca7: e8 16 1d 00 00 call 39c2 <link>
1cac: 83 c4 10 add $0x10,%esp
1caf: 85 c0 test %eax,%eax
1cb1: 75 6f jne 1d22 <bigdir+0xf2>
printf(1, "bigdir create failed\n");
exit();
}
close(fd);
for(i = 0; i < 500; i++){
1cb3: 83 c3 01 add $0x1,%ebx
1cb6: 81 fb f4 01 00 00 cmp $0x1f4,%ebx
1cbc: 75 c2 jne 1c80 <bigdir+0x50>
printf(1, "bigdir link failed\n");
exit();
}
}
unlink("bd");
1cbe: 83 ec 0c sub $0xc,%esp
for(i = 0; i < 500; i++){
1cc1: 31 db xor %ebx,%ebx
printf(1, "bigdir link failed\n");
exit();
}
}
unlink("bd");
1cc3: 68 ce 44 00 00 push $0x44ce
1cc8: e8 e5 1c 00 00 call 39b2 <unlink>
1ccd: 83 c4 10 add $0x10,%esp
for(i = 0; i < 500; i++){
name[0] = 'x';
name[1] = '0' + (i / 64);
1cd0: 89 d8 mov %ebx,%eax
name[2] = '0' + (i % 64);
name[3] = '\0';
if(unlink(name) != 0){
1cd2: 83 ec 0c sub $0xc,%esp
}
}
unlink("bd");
for(i = 0; i < 500; i++){
name[0] = 'x';
1cd5: c6 45 ee 78 movb $0x78,-0x12(%ebp)
name[1] = '0' + (i / 64);
1cd9: c1 f8 06 sar $0x6,%eax
name[2] = '0' + (i % 64);
name[3] = '\0';
if(unlink(name) != 0){
1cdc: 56 push %esi
unlink("bd");
for(i = 0; i < 500; i++){
name[0] = 'x';
name[1] = '0' + (i / 64);
name[2] = '0' + (i % 64);
name[3] = '\0';
1cdd: c6 45 f1 00 movb $0x0,-0xf(%ebp)
}
unlink("bd");
for(i = 0; i < 500; i++){
name[0] = 'x';
name[1] = '0' + (i / 64);
1ce1: 83 c0 30 add $0x30,%eax
1ce4: 88 45 ef mov %al,-0x11(%ebp)
name[2] = '0' + (i % 64);
1ce7: 89 d8 mov %ebx,%eax
1ce9: 83 e0 3f and $0x3f,%eax
1cec: 83 c0 30 add $0x30,%eax
1cef: 88 45 f0 mov %al,-0x10(%ebp)
name[3] = '\0';
if(unlink(name) != 0){
1cf2: e8 bb 1c 00 00 call 39b2 <unlink>
1cf7: 83 c4 10 add $0x10,%esp
1cfa: 85 c0 test %eax,%eax
1cfc: 75 38 jne 1d36 <bigdir+0x106>
exit();
}
}
unlink("bd");
for(i = 0; i < 500; i++){
1cfe: 83 c3 01 add $0x1,%ebx
1d01: 81 fb f4 01 00 00 cmp $0x1f4,%ebx
1d07: 75 c7 jne 1cd0 <bigdir+0xa0>
printf(1, "bigdir unlink failed");
exit();
}
}
printf(1, "bigdir ok\n");
1d09: 83 ec 08 sub $0x8,%esp
1d0c: 68 10 45 00 00 push $0x4510
1d11: 6a 01 push $0x1
1d13: e8 98 1d 00 00 call 3ab0 <printf>
}
1d18: 83 c4 10 add $0x10,%esp
1d1b: 8d 65 f8 lea -0x8(%ebp),%esp
1d1e: 5b pop %ebx
1d1f: 5e pop %esi
1d20: 5d pop %ebp
1d21: c3 ret
name[0] = 'x';
name[1] = '0' + (i / 64);
name[2] = '0' + (i % 64);
name[3] = '\0';
if(link("bd", name) != 0){
printf(1, "bigdir link failed\n");
1d22: 83 ec 08 sub $0x8,%esp
1d25: 68 e7 44 00 00 push $0x44e7
1d2a: 6a 01 push $0x1
1d2c: e8 7f 1d 00 00 call 3ab0 <printf>
exit();
1d31: e8 2c 1c 00 00 call 3962 <exit>
name[0] = 'x';
name[1] = '0' + (i / 64);
name[2] = '0' + (i % 64);
name[3] = '\0';
if(unlink(name) != 0){
printf(1, "bigdir unlink failed");
1d36: 83 ec 08 sub $0x8,%esp
1d39: 68 fb 44 00 00 push $0x44fb
1d3e: 6a 01 push $0x1
1d40: e8 6b 1d 00 00 call 3ab0 <printf>
exit();
1d45: e8 18 1c 00 00 call 3962 <exit>
printf(1, "bigdir test\n");
unlink("bd");
fd = open("bd", O_CREATE);
if(fd < 0){
printf(1, "bigdir create failed\n");
1d4a: 83 ec 08 sub $0x8,%esp
1d4d: 68 d1 44 00 00 push $0x44d1
1d52: 6a 01 push $0x1
1d54: e8 57 1d 00 00 call 3ab0 <printf>
exit();
1d59: e8 04 1c 00 00 call 3962 <exit>
1d5e: 66 90 xchg %ax,%ax
00001d60 <subdir>:
printf(1, "bigdir ok\n");
}
void
subdir(void)
{
1d60: 55 push %ebp
1d61: 89 e5 mov %esp,%ebp
1d63: 53 push %ebx
1d64: 83 ec 0c sub $0xc,%esp
int fd, cc;
printf(1, "subdir test\n");
1d67: 68 1b 45 00 00 push $0x451b
1d6c: 6a 01 push $0x1
1d6e: e8 3d 1d 00 00 call 3ab0 <printf>
unlink("ff");
1d73: c7 04 24 a4 45 00 00 movl $0x45a4,(%esp)
1d7a: e8 33 1c 00 00 call 39b2 <unlink>
if(mkdir("dd") != 0){
1d7f: c7 04 24 41 46 00 00 movl $0x4641,(%esp)
1d86: e8 3f 1c 00 00 call 39ca <mkdir>
1d8b: 83 c4 10 add $0x10,%esp
1d8e: 85 c0 test %eax,%eax
1d90: 0f 85 b3 05 00 00 jne 2349 <subdir+0x5e9>
printf(1, "subdir mkdir dd failed\n");
exit();
}
fd = open("dd/ff", O_CREATE | O_RDWR);
1d96: 83 ec 08 sub $0x8,%esp
1d99: 68 02 02 00 00 push $0x202
1d9e: 68 7a 45 00 00 push $0x457a
1da3: e8 fa 1b 00 00 call 39a2 <open>
if(fd < 0){
1da8: 83 c4 10 add $0x10,%esp
1dab: 85 c0 test %eax,%eax
if(mkdir("dd") != 0){
printf(1, "subdir mkdir dd failed\n");
exit();
}
fd = open("dd/ff", O_CREATE | O_RDWR);
1dad: 89 c3 mov %eax,%ebx
if(fd < 0){
1daf: 0f 88 81 05 00 00 js 2336 <subdir+0x5d6>
printf(1, "create dd/ff failed\n");
exit();
}
write(fd, "ff", 2);
1db5: 83 ec 04 sub $0x4,%esp
1db8: 6a 02 push $0x2
1dba: 68 a4 45 00 00 push $0x45a4
1dbf: 50 push %eax
1dc0: e8 bd 1b 00 00 call 3982 <write>
close(fd);
1dc5: 89 1c 24 mov %ebx,(%esp)
1dc8: e8 bd 1b 00 00 call 398a <close>
if(unlink("dd") >= 0){
1dcd: c7 04 24 41 46 00 00 movl $0x4641,(%esp)
1dd4: e8 d9 1b 00 00 call 39b2 <unlink>
1dd9: 83 c4 10 add $0x10,%esp
1ddc: 85 c0 test %eax,%eax
1dde: 0f 89 3f 05 00 00 jns 2323 <subdir+0x5c3>
printf(1, "unlink dd (non-empty dir) succeeded!\n");
exit();
}
if(mkdir("/dd/dd") != 0){
1de4: 83 ec 0c sub $0xc,%esp
1de7: 68 55 45 00 00 push $0x4555
1dec: e8 d9 1b 00 00 call 39ca <mkdir>
1df1: 83 c4 10 add $0x10,%esp
1df4: 85 c0 test %eax,%eax
1df6: 0f 85 14 05 00 00 jne 2310 <subdir+0x5b0>
printf(1, "subdir mkdir dd/dd failed\n");
exit();
}
fd = open("dd/dd/ff", O_CREATE | O_RDWR);
1dfc: 83 ec 08 sub $0x8,%esp
1dff: 68 02 02 00 00 push $0x202
1e04: 68 77 45 00 00 push $0x4577
1e09: e8 94 1b 00 00 call 39a2 <open>
if(fd < 0){
1e0e: 83 c4 10 add $0x10,%esp
1e11: 85 c0 test %eax,%eax
if(mkdir("/dd/dd") != 0){
printf(1, "subdir mkdir dd/dd failed\n");
exit();
}
fd = open("dd/dd/ff", O_CREATE | O_RDWR);
1e13: 89 c3 mov %eax,%ebx
if(fd < 0){
1e15: 0f 88 24 04 00 00 js 223f <subdir+0x4df>
printf(1, "create dd/dd/ff failed\n");
exit();
}
write(fd, "FF", 2);
1e1b: 83 ec 04 sub $0x4,%esp
1e1e: 6a 02 push $0x2
1e20: 68 98 45 00 00 push $0x4598
1e25: 50 push %eax
1e26: e8 57 1b 00 00 call 3982 <write>
close(fd);
1e2b: 89 1c 24 mov %ebx,(%esp)
1e2e: e8 57 1b 00 00 call 398a <close>
fd = open("dd/dd/../ff", 0);
1e33: 58 pop %eax
1e34: 5a pop %edx
1e35: 6a 00 push $0x0
1e37: 68 9b 45 00 00 push $0x459b
1e3c: e8 61 1b 00 00 call 39a2 <open>
if(fd < 0){
1e41: 83 c4 10 add $0x10,%esp
1e44: 85 c0 test %eax,%eax
exit();
}
write(fd, "FF", 2);
close(fd);
fd = open("dd/dd/../ff", 0);
1e46: 89 c3 mov %eax,%ebx
if(fd < 0){
1e48: 0f 88 de 03 00 00 js 222c <subdir+0x4cc>
printf(1, "open dd/dd/../ff failed\n");
exit();
}
cc = read(fd, buf, sizeof(buf));
1e4e: 83 ec 04 sub $0x4,%esp
1e51: 68 00 20 00 00 push $0x2000
1e56: 68 40 86 00 00 push $0x8640
1e5b: 50 push %eax
1e5c: e8 19 1b 00 00 call 397a <read>
if(cc != 2 || buf[0] != 'f'){
1e61: 83 c4 10 add $0x10,%esp
1e64: 83 f8 02 cmp $0x2,%eax
1e67: 0f 85 3a 03 00 00 jne 21a7 <subdir+0x447>
1e6d: 80 3d 40 86 00 00 66 cmpb $0x66,0x8640
1e74: 0f 85 2d 03 00 00 jne 21a7 <subdir+0x447>
printf(1, "dd/dd/../ff wrong content\n");
exit();
}
close(fd);
1e7a: 83 ec 0c sub $0xc,%esp
1e7d: 53 push %ebx
1e7e: e8 07 1b 00 00 call 398a <close>
if(link("dd/dd/ff", "dd/dd/ffff") != 0){
1e83: 5b pop %ebx
1e84: 58 pop %eax
1e85: 68 db 45 00 00 push $0x45db
1e8a: 68 77 45 00 00 push $0x4577
1e8f: e8 2e 1b 00 00 call 39c2 <link>
1e94: 83 c4 10 add $0x10,%esp
1e97: 85 c0 test %eax,%eax
1e99: 0f 85 c6 03 00 00 jne 2265 <subdir+0x505>
printf(1, "link dd/dd/ff dd/dd/ffff failed\n");
exit();
}
if(unlink("dd/dd/ff") != 0){
1e9f: 83 ec 0c sub $0xc,%esp
1ea2: 68 77 45 00 00 push $0x4577
1ea7: e8 06 1b 00 00 call 39b2 <unlink>
1eac: 83 c4 10 add $0x10,%esp
1eaf: 85 c0 test %eax,%eax
1eb1: 0f 85 16 03 00 00 jne 21cd <subdir+0x46d>
printf(1, "unlink dd/dd/ff failed\n");
exit();
}
if(open("dd/dd/ff", O_RDONLY) >= 0){
1eb7: 83 ec 08 sub $0x8,%esp
1eba: 6a 00 push $0x0
1ebc: 68 77 45 00 00 push $0x4577
1ec1: e8 dc 1a 00 00 call 39a2 <open>
1ec6: 83 c4 10 add $0x10,%esp
1ec9: 85 c0 test %eax,%eax
1ecb: 0f 89 2c 04 00 00 jns 22fd <subdir+0x59d>
printf(1, "open (unlinked) dd/dd/ff succeeded\n");
exit();
}
if(chdir("dd") != 0){
1ed1: 83 ec 0c sub $0xc,%esp
1ed4: 68 41 46 00 00 push $0x4641
1ed9: e8 f4 1a 00 00 call 39d2 <chdir>
1ede: 83 c4 10 add $0x10,%esp
1ee1: 85 c0 test %eax,%eax
1ee3: 0f 85 01 04 00 00 jne 22ea <subdir+0x58a>
printf(1, "chdir dd failed\n");
exit();
}
if(chdir("dd/../../dd") != 0){
1ee9: 83 ec 0c sub $0xc,%esp
1eec: 68 0f 46 00 00 push $0x460f
1ef1: e8 dc 1a 00 00 call 39d2 <chdir>
1ef6: 83 c4 10 add $0x10,%esp
1ef9: 85 c0 test %eax,%eax
1efb: 0f 85 b9 02 00 00 jne 21ba <subdir+0x45a>
printf(1, "chdir dd/../../dd failed\n");
exit();
}
if(chdir("dd/../../../dd") != 0){
1f01: 83 ec 0c sub $0xc,%esp
1f04: 68 35 46 00 00 push $0x4635
1f09: e8 c4 1a 00 00 call 39d2 <chdir>
1f0e: 83 c4 10 add $0x10,%esp
1f11: 85 c0 test %eax,%eax
1f13: 0f 85 a1 02 00 00 jne 21ba <subdir+0x45a>
printf(1, "chdir dd/../../dd failed\n");
exit();
}
if(chdir("./..") != 0){
1f19: 83 ec 0c sub $0xc,%esp
1f1c: 68 44 46 00 00 push $0x4644
1f21: e8 ac 1a 00 00 call 39d2 <chdir>
1f26: 83 c4 10 add $0x10,%esp
1f29: 85 c0 test %eax,%eax
1f2b: 0f 85 21 03 00 00 jne 2252 <subdir+0x4f2>
printf(1, "chdir ./.. failed\n");
exit();
}
fd = open("dd/dd/ffff", 0);
1f31: 83 ec 08 sub $0x8,%esp
1f34: 6a 00 push $0x0
1f36: 68 db 45 00 00 push $0x45db
1f3b: e8 62 1a 00 00 call 39a2 <open>
if(fd < 0){
1f40: 83 c4 10 add $0x10,%esp
1f43: 85 c0 test %eax,%eax
if(chdir("./..") != 0){
printf(1, "chdir ./.. failed\n");
exit();
}
fd = open("dd/dd/ffff", 0);
1f45: 89 c3 mov %eax,%ebx
if(fd < 0){
1f47: 0f 88 e0 04 00 00 js 242d <subdir+0x6cd>
printf(1, "open dd/dd/ffff failed\n");
exit();
}
if(read(fd, buf, sizeof(buf)) != 2){
1f4d: 83 ec 04 sub $0x4,%esp
1f50: 68 00 20 00 00 push $0x2000
1f55: 68 40 86 00 00 push $0x8640
1f5a: 50 push %eax
1f5b: e8 1a 1a 00 00 call 397a <read>
1f60: 83 c4 10 add $0x10,%esp
1f63: 83 f8 02 cmp $0x2,%eax
1f66: 0f 85 ae 04 00 00 jne 241a <subdir+0x6ba>
printf(1, "read dd/dd/ffff wrong len\n");
exit();
}
close(fd);
1f6c: 83 ec 0c sub $0xc,%esp
1f6f: 53 push %ebx
1f70: e8 15 1a 00 00 call 398a <close>
if(open("dd/dd/ff", O_RDONLY) >= 0){
1f75: 59 pop %ecx
1f76: 5b pop %ebx
1f77: 6a 00 push $0x0
1f79: 68 77 45 00 00 push $0x4577
1f7e: e8 1f 1a 00 00 call 39a2 <open>
1f83: 83 c4 10 add $0x10,%esp
1f86: 85 c0 test %eax,%eax
1f88: 0f 89 65 02 00 00 jns 21f3 <subdir+0x493>
printf(1, "open (unlinked) dd/dd/ff succeeded!\n");
exit();
}
if(open("dd/ff/ff", O_CREATE|O_RDWR) >= 0){
1f8e: 83 ec 08 sub $0x8,%esp
1f91: 68 02 02 00 00 push $0x202
1f96: 68 8f 46 00 00 push $0x468f
1f9b: e8 02 1a 00 00 call 39a2 <open>
1fa0: 83 c4 10 add $0x10,%esp
1fa3: 85 c0 test %eax,%eax
1fa5: 0f 89 35 02 00 00 jns 21e0 <subdir+0x480>
printf(1, "create dd/ff/ff succeeded!\n");
exit();
}
if(open("dd/xx/ff", O_CREATE|O_RDWR) >= 0){
1fab: 83 ec 08 sub $0x8,%esp
1fae: 68 02 02 00 00 push $0x202
1fb3: 68 b4 46 00 00 push $0x46b4
1fb8: e8 e5 19 00 00 call 39a2 <open>
1fbd: 83 c4 10 add $0x10,%esp
1fc0: 85 c0 test %eax,%eax
1fc2: 0f 89 0f 03 00 00 jns 22d7 <subdir+0x577>
printf(1, "create dd/xx/ff succeeded!\n");
exit();
}
if(open("dd", O_CREATE) >= 0){
1fc8: 83 ec 08 sub $0x8,%esp
1fcb: 68 00 02 00 00 push $0x200
1fd0: 68 41 46 00 00 push $0x4641
1fd5: e8 c8 19 00 00 call 39a2 <open>
1fda: 83 c4 10 add $0x10,%esp
1fdd: 85 c0 test %eax,%eax
1fdf: 0f 89 df 02 00 00 jns 22c4 <subdir+0x564>
printf(1, "create dd succeeded!\n");
exit();
}
if(open("dd", O_RDWR) >= 0){
1fe5: 83 ec 08 sub $0x8,%esp
1fe8: 6a 02 push $0x2
1fea: 68 41 46 00 00 push $0x4641
1fef: e8 ae 19 00 00 call 39a2 <open>
1ff4: 83 c4 10 add $0x10,%esp
1ff7: 85 c0 test %eax,%eax
1ff9: 0f 89 b2 02 00 00 jns 22b1 <subdir+0x551>
printf(1, "open dd rdwr succeeded!\n");
exit();
}
if(open("dd", O_WRONLY) >= 0){
1fff: 83 ec 08 sub $0x8,%esp
2002: 6a 01 push $0x1
2004: 68 41 46 00 00 push $0x4641
2009: e8 94 19 00 00 call 39a2 <open>
200e: 83 c4 10 add $0x10,%esp
2011: 85 c0 test %eax,%eax
2013: 0f 89 85 02 00 00 jns 229e <subdir+0x53e>
printf(1, "open dd wronly succeeded!\n");
exit();
}
if(link("dd/ff/ff", "dd/dd/xx") == 0){
2019: 83 ec 08 sub $0x8,%esp
201c: 68 23 47 00 00 push $0x4723
2021: 68 8f 46 00 00 push $0x468f
2026: e8 97 19 00 00 call 39c2 <link>
202b: 83 c4 10 add $0x10,%esp
202e: 85 c0 test %eax,%eax
2030: 0f 84 55 02 00 00 je 228b <subdir+0x52b>
printf(1, "link dd/ff/ff dd/dd/xx succeeded!\n");
exit();
}
if(link("dd/xx/ff", "dd/dd/xx") == 0){
2036: 83 ec 08 sub $0x8,%esp
2039: 68 23 47 00 00 push $0x4723
203e: 68 b4 46 00 00 push $0x46b4
2043: e8 7a 19 00 00 call 39c2 <link>
2048: 83 c4 10 add $0x10,%esp
204b: 85 c0 test %eax,%eax
204d: 0f 84 25 02 00 00 je 2278 <subdir+0x518>
printf(1, "link dd/xx/ff dd/dd/xx succeeded!\n");
exit();
}
if(link("dd/ff", "dd/dd/ffff") == 0){
2053: 83 ec 08 sub $0x8,%esp
2056: 68 db 45 00 00 push $0x45db
205b: 68 7a 45 00 00 push $0x457a
2060: e8 5d 19 00 00 call 39c2 <link>
2065: 83 c4 10 add $0x10,%esp
2068: 85 c0 test %eax,%eax
206a: 0f 84 a9 01 00 00 je 2219 <subdir+0x4b9>
printf(1, "link dd/ff dd/dd/ffff succeeded!\n");
exit();
}
if(mkdir("dd/ff/ff") == 0){
2070: 83 ec 0c sub $0xc,%esp
2073: 68 8f 46 00 00 push $0x468f
2078: e8 4d 19 00 00 call 39ca <mkdir>
207d: 83 c4 10 add $0x10,%esp
2080: 85 c0 test %eax,%eax
2082: 0f 84 7e 01 00 00 je 2206 <subdir+0x4a6>
printf(1, "mkdir dd/ff/ff succeeded!\n");
exit();
}
if(mkdir("dd/xx/ff") == 0){
2088: 83 ec 0c sub $0xc,%esp
208b: 68 b4 46 00 00 push $0x46b4
2090: e8 35 19 00 00 call 39ca <mkdir>
2095: 83 c4 10 add $0x10,%esp
2098: 85 c0 test %eax,%eax
209a: 0f 84 67 03 00 00 je 2407 <subdir+0x6a7>
printf(1, "mkdir dd/xx/ff succeeded!\n");
exit();
}
if(mkdir("dd/dd/ffff") == 0){
20a0: 83 ec 0c sub $0xc,%esp
20a3: 68 db 45 00 00 push $0x45db
20a8: e8 1d 19 00 00 call 39ca <mkdir>
20ad: 83 c4 10 add $0x10,%esp
20b0: 85 c0 test %eax,%eax
20b2: 0f 84 3c 03 00 00 je 23f4 <subdir+0x694>
printf(1, "mkdir dd/dd/ffff succeeded!\n");
exit();
}
if(unlink("dd/xx/ff") == 0){
20b8: 83 ec 0c sub $0xc,%esp
20bb: 68 b4 46 00 00 push $0x46b4
20c0: e8 ed 18 00 00 call 39b2 <unlink>
20c5: 83 c4 10 add $0x10,%esp
20c8: 85 c0 test %eax,%eax
20ca: 0f 84 11 03 00 00 je 23e1 <subdir+0x681>
printf(1, "unlink dd/xx/ff succeeded!\n");
exit();
}
if(unlink("dd/ff/ff") == 0){
20d0: 83 ec 0c sub $0xc,%esp
20d3: 68 8f 46 00 00 push $0x468f
20d8: e8 d5 18 00 00 call 39b2 <unlink>
20dd: 83 c4 10 add $0x10,%esp
20e0: 85 c0 test %eax,%eax
20e2: 0f 84 e6 02 00 00 je 23ce <subdir+0x66e>
printf(1, "unlink dd/ff/ff succeeded!\n");
exit();
}
if(chdir("dd/ff") == 0){
20e8: 83 ec 0c sub $0xc,%esp
20eb: 68 7a 45 00 00 push $0x457a
20f0: e8 dd 18 00 00 call 39d2 <chdir>
20f5: 83 c4 10 add $0x10,%esp
20f8: 85 c0 test %eax,%eax
20fa: 0f 84 bb 02 00 00 je 23bb <subdir+0x65b>
printf(1, "chdir dd/ff succeeded!\n");
exit();
}
if(chdir("dd/xx") == 0){
2100: 83 ec 0c sub $0xc,%esp
2103: 68 26 47 00 00 push $0x4726
2108: e8 c5 18 00 00 call 39d2 <chdir>
210d: 83 c4 10 add $0x10,%esp
2110: 85 c0 test %eax,%eax
2112: 0f 84 90 02 00 00 je 23a8 <subdir+0x648>
printf(1, "chdir dd/xx succeeded!\n");
exit();
}
if(unlink("dd/dd/ffff") != 0){
2118: 83 ec 0c sub $0xc,%esp
211b: 68 db 45 00 00 push $0x45db
2120: e8 8d 18 00 00 call 39b2 <unlink>
2125: 83 c4 10 add $0x10,%esp
2128: 85 c0 test %eax,%eax
212a: 0f 85 9d 00 00 00 jne 21cd <subdir+0x46d>
printf(1, "unlink dd/dd/ff failed\n");
exit();
}
if(unlink("dd/ff") != 0){
2130: 83 ec 0c sub $0xc,%esp
2133: 68 7a 45 00 00 push $0x457a
2138: e8 75 18 00 00 call 39b2 <unlink>
213d: 83 c4 10 add $0x10,%esp
2140: 85 c0 test %eax,%eax
2142: 0f 85 4d 02 00 00 jne 2395 <subdir+0x635>
printf(1, "unlink dd/ff failed\n");
exit();
}
if(unlink("dd") == 0){
2148: 83 ec 0c sub $0xc,%esp
214b: 68 41 46 00 00 push $0x4641
2150: e8 5d 18 00 00 call 39b2 <unlink>
2155: 83 c4 10 add $0x10,%esp
2158: 85 c0 test %eax,%eax
215a: 0f 84 22 02 00 00 je 2382 <subdir+0x622>
printf(1, "unlink non-empty dd succeeded!\n");
exit();
}
if(unlink("dd/dd") < 0){
2160: 83 ec 0c sub $0xc,%esp
2163: 68 56 45 00 00 push $0x4556
2168: e8 45 18 00 00 call 39b2 <unlink>
216d: 83 c4 10 add $0x10,%esp
2170: 85 c0 test %eax,%eax
2172: 0f 88 f7 01 00 00 js 236f <subdir+0x60f>
printf(1, "unlink dd/dd failed\n");
exit();
}
if(unlink("dd") < 0){
2178: 83 ec 0c sub $0xc,%esp
217b: 68 41 46 00 00 push $0x4641
2180: e8 2d 18 00 00 call 39b2 <unlink>
2185: 83 c4 10 add $0x10,%esp
2188: 85 c0 test %eax,%eax
218a: 0f 88 cc 01 00 00 js 235c <subdir+0x5fc>
printf(1, "unlink dd failed\n");
exit();
}
printf(1, "subdir ok\n");
2190: 83 ec 08 sub $0x8,%esp
2193: 68 23 48 00 00 push $0x4823
2198: 6a 01 push $0x1
219a: e8 11 19 00 00 call 3ab0 <printf>
}
219f: 83 c4 10 add $0x10,%esp
21a2: 8b 5d fc mov -0x4(%ebp),%ebx
21a5: c9 leave
21a6: c3 ret
printf(1, "open dd/dd/../ff failed\n");
exit();
}
cc = read(fd, buf, sizeof(buf));
if(cc != 2 || buf[0] != 'f'){
printf(1, "dd/dd/../ff wrong content\n");
21a7: 50 push %eax
21a8: 50 push %eax
21a9: 68 c0 45 00 00 push $0x45c0
21ae: 6a 01 push $0x1
21b0: e8 fb 18 00 00 call 3ab0 <printf>
exit();
21b5: e8 a8 17 00 00 call 3962 <exit>
if(chdir("dd") != 0){
printf(1, "chdir dd failed\n");
exit();
}
if(chdir("dd/../../dd") != 0){
printf(1, "chdir dd/../../dd failed\n");
21ba: 50 push %eax
21bb: 50 push %eax
21bc: 68 1b 46 00 00 push $0x461b
21c1: 6a 01 push $0x1
21c3: e8 e8 18 00 00 call 3ab0 <printf>
exit();
21c8: e8 95 17 00 00 call 3962 <exit>
printf(1, "link dd/dd/ff dd/dd/ffff failed\n");
exit();
}
if(unlink("dd/dd/ff") != 0){
printf(1, "unlink dd/dd/ff failed\n");
21cd: 52 push %edx
21ce: 52 push %edx
21cf: 68 e6 45 00 00 push $0x45e6
21d4: 6a 01 push $0x1
21d6: e8 d5 18 00 00 call 3ab0 <printf>
exit();
21db: e8 82 17 00 00 call 3962 <exit>
printf(1, "open (unlinked) dd/dd/ff succeeded!\n");
exit();
}
if(open("dd/ff/ff", O_CREATE|O_RDWR) >= 0){
printf(1, "create dd/ff/ff succeeded!\n");
21e0: 50 push %eax
21e1: 50 push %eax
21e2: 68 98 46 00 00 push $0x4698
21e7: 6a 01 push $0x1
21e9: e8 c2 18 00 00 call 3ab0 <printf>
exit();
21ee: e8 6f 17 00 00 call 3962 <exit>
exit();
}
close(fd);
if(open("dd/dd/ff", O_RDONLY) >= 0){
printf(1, "open (unlinked) dd/dd/ff succeeded!\n");
21f3: 52 push %edx
21f4: 52 push %edx
21f5: 68 7c 50 00 00 push $0x507c
21fa: 6a 01 push $0x1
21fc: e8 af 18 00 00 call 3ab0 <printf>
exit();
2201: e8 5c 17 00 00 call 3962 <exit>
if(link("dd/ff", "dd/dd/ffff") == 0){
printf(1, "link dd/ff dd/dd/ffff succeeded!\n");
exit();
}
if(mkdir("dd/ff/ff") == 0){
printf(1, "mkdir dd/ff/ff succeeded!\n");
2206: 52 push %edx
2207: 52 push %edx
2208: 68 2c 47 00 00 push $0x472c
220d: 6a 01 push $0x1
220f: e8 9c 18 00 00 call 3ab0 <printf>
exit();
2214: e8 49 17 00 00 call 3962 <exit>
if(link("dd/xx/ff", "dd/dd/xx") == 0){
printf(1, "link dd/xx/ff dd/dd/xx succeeded!\n");
exit();
}
if(link("dd/ff", "dd/dd/ffff") == 0){
printf(1, "link dd/ff dd/dd/ffff succeeded!\n");
2219: 51 push %ecx
221a: 51 push %ecx
221b: 68 ec 50 00 00 push $0x50ec
2220: 6a 01 push $0x1
2222: e8 89 18 00 00 call 3ab0 <printf>
exit();
2227: e8 36 17 00 00 call 3962 <exit>
write(fd, "FF", 2);
close(fd);
fd = open("dd/dd/../ff", 0);
if(fd < 0){
printf(1, "open dd/dd/../ff failed\n");
222c: 50 push %eax
222d: 50 push %eax
222e: 68 a7 45 00 00 push $0x45a7
2233: 6a 01 push $0x1
2235: e8 76 18 00 00 call 3ab0 <printf>
exit();
223a: e8 23 17 00 00 call 3962 <exit>
exit();
}
fd = open("dd/dd/ff", O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "create dd/dd/ff failed\n");
223f: 51 push %ecx
2240: 51 push %ecx
2241: 68 80 45 00 00 push $0x4580
2246: 6a 01 push $0x1
2248: e8 63 18 00 00 call 3ab0 <printf>
exit();
224d: e8 10 17 00 00 call 3962 <exit>
if(chdir("dd/../../../dd") != 0){
printf(1, "chdir dd/../../dd failed\n");
exit();
}
if(chdir("./..") != 0){
printf(1, "chdir ./.. failed\n");
2252: 50 push %eax
2253: 50 push %eax
2254: 68 49 46 00 00 push $0x4649
2259: 6a 01 push $0x1
225b: e8 50 18 00 00 call 3ab0 <printf>
exit();
2260: e8 fd 16 00 00 call 3962 <exit>
exit();
}
close(fd);
if(link("dd/dd/ff", "dd/dd/ffff") != 0){
printf(1, "link dd/dd/ff dd/dd/ffff failed\n");
2265: 51 push %ecx
2266: 51 push %ecx
2267: 68 34 50 00 00 push $0x5034
226c: 6a 01 push $0x1
226e: e8 3d 18 00 00 call 3ab0 <printf>
exit();
2273: e8 ea 16 00 00 call 3962 <exit>
if(link("dd/ff/ff", "dd/dd/xx") == 0){
printf(1, "link dd/ff/ff dd/dd/xx succeeded!\n");
exit();
}
if(link("dd/xx/ff", "dd/dd/xx") == 0){
printf(1, "link dd/xx/ff dd/dd/xx succeeded!\n");
2278: 53 push %ebx
2279: 53 push %ebx
227a: 68 c8 50 00 00 push $0x50c8
227f: 6a 01 push $0x1
2281: e8 2a 18 00 00 call 3ab0 <printf>
exit();
2286: e8 d7 16 00 00 call 3962 <exit>
if(open("dd", O_WRONLY) >= 0){
printf(1, "open dd wronly succeeded!\n");
exit();
}
if(link("dd/ff/ff", "dd/dd/xx") == 0){
printf(1, "link dd/ff/ff dd/dd/xx succeeded!\n");
228b: 50 push %eax
228c: 50 push %eax
228d: 68 a4 50 00 00 push $0x50a4
2292: 6a 01 push $0x1
2294: e8 17 18 00 00 call 3ab0 <printf>
exit();
2299: e8 c4 16 00 00 call 3962 <exit>
if(open("dd", O_RDWR) >= 0){
printf(1, "open dd rdwr succeeded!\n");
exit();
}
if(open("dd", O_WRONLY) >= 0){
printf(1, "open dd wronly succeeded!\n");
229e: 50 push %eax
229f: 50 push %eax
22a0: 68 08 47 00 00 push $0x4708
22a5: 6a 01 push $0x1
22a7: e8 04 18 00 00 call 3ab0 <printf>
exit();
22ac: e8 b1 16 00 00 call 3962 <exit>
if(open("dd", O_CREATE) >= 0){
printf(1, "create dd succeeded!\n");
exit();
}
if(open("dd", O_RDWR) >= 0){
printf(1, "open dd rdwr succeeded!\n");
22b1: 50 push %eax
22b2: 50 push %eax
22b3: 68 ef 46 00 00 push $0x46ef
22b8: 6a 01 push $0x1
22ba: e8 f1 17 00 00 call 3ab0 <printf>
exit();
22bf: e8 9e 16 00 00 call 3962 <exit>
if(open("dd/xx/ff", O_CREATE|O_RDWR) >= 0){
printf(1, "create dd/xx/ff succeeded!\n");
exit();
}
if(open("dd", O_CREATE) >= 0){
printf(1, "create dd succeeded!\n");
22c4: 50 push %eax
22c5: 50 push %eax
22c6: 68 d9 46 00 00 push $0x46d9
22cb: 6a 01 push $0x1
22cd: e8 de 17 00 00 call 3ab0 <printf>
exit();
22d2: e8 8b 16 00 00 call 3962 <exit>
if(open("dd/ff/ff", O_CREATE|O_RDWR) >= 0){
printf(1, "create dd/ff/ff succeeded!\n");
exit();
}
if(open("dd/xx/ff", O_CREATE|O_RDWR) >= 0){
printf(1, "create dd/xx/ff succeeded!\n");
22d7: 50 push %eax
22d8: 50 push %eax
22d9: 68 bd 46 00 00 push $0x46bd
22de: 6a 01 push $0x1
22e0: e8 cb 17 00 00 call 3ab0 <printf>
exit();
22e5: e8 78 16 00 00 call 3962 <exit>
printf(1, "open (unlinked) dd/dd/ff succeeded\n");
exit();
}
if(chdir("dd") != 0){
printf(1, "chdir dd failed\n");
22ea: 50 push %eax
22eb: 50 push %eax
22ec: 68 fe 45 00 00 push $0x45fe
22f1: 6a 01 push $0x1
22f3: e8 b8 17 00 00 call 3ab0 <printf>
exit();
22f8: e8 65 16 00 00 call 3962 <exit>
if(unlink("dd/dd/ff") != 0){
printf(1, "unlink dd/dd/ff failed\n");
exit();
}
if(open("dd/dd/ff", O_RDONLY) >= 0){
printf(1, "open (unlinked) dd/dd/ff succeeded\n");
22fd: 50 push %eax
22fe: 50 push %eax
22ff: 68 58 50 00 00 push $0x5058
2304: 6a 01 push $0x1
2306: e8 a5 17 00 00 call 3ab0 <printf>
exit();
230b: e8 52 16 00 00 call 3962 <exit>
printf(1, "unlink dd (non-empty dir) succeeded!\n");
exit();
}
if(mkdir("/dd/dd") != 0){
printf(1, "subdir mkdir dd/dd failed\n");
2310: 53 push %ebx
2311: 53 push %ebx
2312: 68 5c 45 00 00 push $0x455c
2317: 6a 01 push $0x1
2319: e8 92 17 00 00 call 3ab0 <printf>
exit();
231e: e8 3f 16 00 00 call 3962 <exit>
}
write(fd, "ff", 2);
close(fd);
if(unlink("dd") >= 0){
printf(1, "unlink dd (non-empty dir) succeeded!\n");
2323: 50 push %eax
2324: 50 push %eax
2325: 68 0c 50 00 00 push $0x500c
232a: 6a 01 push $0x1
232c: e8 7f 17 00 00 call 3ab0 <printf>
exit();
2331: e8 2c 16 00 00 call 3962 <exit>
exit();
}
fd = open("dd/ff", O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "create dd/ff failed\n");
2336: 50 push %eax
2337: 50 push %eax
2338: 68 40 45 00 00 push $0x4540
233d: 6a 01 push $0x1
233f: e8 6c 17 00 00 call 3ab0 <printf>
exit();
2344: e8 19 16 00 00 call 3962 <exit>
printf(1, "subdir test\n");
unlink("ff");
if(mkdir("dd") != 0){
printf(1, "subdir mkdir dd failed\n");
2349: 50 push %eax
234a: 50 push %eax
234b: 68 28 45 00 00 push $0x4528
2350: 6a 01 push $0x1
2352: e8 59 17 00 00 call 3ab0 <printf>
exit();
2357: e8 06 16 00 00 call 3962 <exit>
if(unlink("dd/dd") < 0){
printf(1, "unlink dd/dd failed\n");
exit();
}
if(unlink("dd") < 0){
printf(1, "unlink dd failed\n");
235c: 50 push %eax
235d: 50 push %eax
235e: 68 11 48 00 00 push $0x4811
2363: 6a 01 push $0x1
2365: e8 46 17 00 00 call 3ab0 <printf>
exit();
236a: e8 f3 15 00 00 call 3962 <exit>
if(unlink("dd") == 0){
printf(1, "unlink non-empty dd succeeded!\n");
exit();
}
if(unlink("dd/dd") < 0){
printf(1, "unlink dd/dd failed\n");
236f: 52 push %edx
2370: 52 push %edx
2371: 68 fc 47 00 00 push $0x47fc
2376: 6a 01 push $0x1
2378: e8 33 17 00 00 call 3ab0 <printf>
exit();
237d: e8 e0 15 00 00 call 3962 <exit>
if(unlink("dd/ff") != 0){
printf(1, "unlink dd/ff failed\n");
exit();
}
if(unlink("dd") == 0){
printf(1, "unlink non-empty dd succeeded!\n");
2382: 51 push %ecx
2383: 51 push %ecx
2384: 68 10 51 00 00 push $0x5110
2389: 6a 01 push $0x1
238b: e8 20 17 00 00 call 3ab0 <printf>
exit();
2390: e8 cd 15 00 00 call 3962 <exit>
if(unlink("dd/dd/ffff") != 0){
printf(1, "unlink dd/dd/ff failed\n");
exit();
}
if(unlink("dd/ff") != 0){
printf(1, "unlink dd/ff failed\n");
2395: 53 push %ebx
2396: 53 push %ebx
2397: 68 e7 47 00 00 push $0x47e7
239c: 6a 01 push $0x1
239e: e8 0d 17 00 00 call 3ab0 <printf>
exit();
23a3: e8 ba 15 00 00 call 3962 <exit>
if(chdir("dd/ff") == 0){
printf(1, "chdir dd/ff succeeded!\n");
exit();
}
if(chdir("dd/xx") == 0){
printf(1, "chdir dd/xx succeeded!\n");
23a8: 50 push %eax
23a9: 50 push %eax
23aa: 68 cf 47 00 00 push $0x47cf
23af: 6a 01 push $0x1
23b1: e8 fa 16 00 00 call 3ab0 <printf>
exit();
23b6: e8 a7 15 00 00 call 3962 <exit>
if(unlink("dd/ff/ff") == 0){
printf(1, "unlink dd/ff/ff succeeded!\n");
exit();
}
if(chdir("dd/ff") == 0){
printf(1, "chdir dd/ff succeeded!\n");
23bb: 50 push %eax
23bc: 50 push %eax
23bd: 68 b7 47 00 00 push $0x47b7
23c2: 6a 01 push $0x1
23c4: e8 e7 16 00 00 call 3ab0 <printf>
exit();
23c9: e8 94 15 00 00 call 3962 <exit>
if(unlink("dd/xx/ff") == 0){
printf(1, "unlink dd/xx/ff succeeded!\n");
exit();
}
if(unlink("dd/ff/ff") == 0){
printf(1, "unlink dd/ff/ff succeeded!\n");
23ce: 50 push %eax
23cf: 50 push %eax
23d0: 68 9b 47 00 00 push $0x479b
23d5: 6a 01 push $0x1
23d7: e8 d4 16 00 00 call 3ab0 <printf>
exit();
23dc: e8 81 15 00 00 call 3962 <exit>
if(mkdir("dd/dd/ffff") == 0){
printf(1, "mkdir dd/dd/ffff succeeded!\n");
exit();
}
if(unlink("dd/xx/ff") == 0){
printf(1, "unlink dd/xx/ff succeeded!\n");
23e1: 50 push %eax
23e2: 50 push %eax
23e3: 68 7f 47 00 00 push $0x477f
23e8: 6a 01 push $0x1
23ea: e8 c1 16 00 00 call 3ab0 <printf>
exit();
23ef: e8 6e 15 00 00 call 3962 <exit>
if(mkdir("dd/xx/ff") == 0){
printf(1, "mkdir dd/xx/ff succeeded!\n");
exit();
}
if(mkdir("dd/dd/ffff") == 0){
printf(1, "mkdir dd/dd/ffff succeeded!\n");
23f4: 50 push %eax
23f5: 50 push %eax
23f6: 68 62 47 00 00 push $0x4762
23fb: 6a 01 push $0x1
23fd: e8 ae 16 00 00 call 3ab0 <printf>
exit();
2402: e8 5b 15 00 00 call 3962 <exit>
if(mkdir("dd/ff/ff") == 0){
printf(1, "mkdir dd/ff/ff succeeded!\n");
exit();
}
if(mkdir("dd/xx/ff") == 0){
printf(1, "mkdir dd/xx/ff succeeded!\n");
2407: 50 push %eax
2408: 50 push %eax
2409: 68 47 47 00 00 push $0x4747
240e: 6a 01 push $0x1
2410: e8 9b 16 00 00 call 3ab0 <printf>
exit();
2415: e8 48 15 00 00 call 3962 <exit>
if(fd < 0){
printf(1, "open dd/dd/ffff failed\n");
exit();
}
if(read(fd, buf, sizeof(buf)) != 2){
printf(1, "read dd/dd/ffff wrong len\n");
241a: 50 push %eax
241b: 50 push %eax
241c: 68 74 46 00 00 push $0x4674
2421: 6a 01 push $0x1
2423: e8 88 16 00 00 call 3ab0 <printf>
exit();
2428: e8 35 15 00 00 call 3962 <exit>
exit();
}
fd = open("dd/dd/ffff", 0);
if(fd < 0){
printf(1, "open dd/dd/ffff failed\n");
242d: 50 push %eax
242e: 50 push %eax
242f: 68 5c 46 00 00 push $0x465c
2434: 6a 01 push $0x1
2436: e8 75 16 00 00 call 3ab0 <printf>
exit();
243b: e8 22 15 00 00 call 3962 <exit>
00002440 <bigwrite>:
}
// test writes that are larger than the log.
void
bigwrite(void)
{
2440: 55 push %ebp
2441: 89 e5 mov %esp,%ebp
2443: 56 push %esi
2444: 53 push %ebx
int fd, sz;
printf(1, "bigwrite test\n");
unlink("bigwrite");
for(sz = 499; sz < 12*512; sz += 471){
2445: bb f3 01 00 00 mov $0x1f3,%ebx
void
bigwrite(void)
{
int fd, sz;
printf(1, "bigwrite test\n");
244a: 83 ec 08 sub $0x8,%esp
244d: 68 2e 48 00 00 push $0x482e
2452: 6a 01 push $0x1
2454: e8 57 16 00 00 call 3ab0 <printf>
unlink("bigwrite");
2459: c7 04 24 3d 48 00 00 movl $0x483d,(%esp)
2460: e8 4d 15 00 00 call 39b2 <unlink>
2465: 83 c4 10 add $0x10,%esp
2468: 90 nop
2469: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(sz = 499; sz < 12*512; sz += 471){
fd = open("bigwrite", O_CREATE | O_RDWR);
2470: 83 ec 08 sub $0x8,%esp
2473: 68 02 02 00 00 push $0x202
2478: 68 3d 48 00 00 push $0x483d
247d: e8 20 15 00 00 call 39a2 <open>
if(fd < 0){
2482: 83 c4 10 add $0x10,%esp
2485: 85 c0 test %eax,%eax
printf(1, "bigwrite test\n");
unlink("bigwrite");
for(sz = 499; sz < 12*512; sz += 471){
fd = open("bigwrite", O_CREATE | O_RDWR);
2487: 89 c6 mov %eax,%esi
if(fd < 0){
2489: 78 7e js 2509 <bigwrite+0xc9>
printf(1, "cannot create bigwrite\n");
exit();
}
int i;
for(i = 0; i < 2; i++){
int cc = write(fd, buf, sz);
248b: 83 ec 04 sub $0x4,%esp
248e: 53 push %ebx
248f: 68 40 86 00 00 push $0x8640
2494: 50 push %eax
2495: e8 e8 14 00 00 call 3982 <write>
if(cc != sz){
249a: 83 c4 10 add $0x10,%esp
249d: 39 c3 cmp %eax,%ebx
249f: 75 55 jne 24f6 <bigwrite+0xb6>
printf(1, "cannot create bigwrite\n");
exit();
}
int i;
for(i = 0; i < 2; i++){
int cc = write(fd, buf, sz);
24a1: 83 ec 04 sub $0x4,%esp
24a4: 53 push %ebx
24a5: 68 40 86 00 00 push $0x8640
24aa: 56 push %esi
24ab: e8 d2 14 00 00 call 3982 <write>
if(cc != sz){
24b0: 83 c4 10 add $0x10,%esp
24b3: 39 c3 cmp %eax,%ebx
24b5: 75 3f jne 24f6 <bigwrite+0xb6>
printf(1, "write(%d) ret %d\n", sz, cc);
exit();
}
}
close(fd);
24b7: 83 ec 0c sub $0xc,%esp
int fd, sz;
printf(1, "bigwrite test\n");
unlink("bigwrite");
for(sz = 499; sz < 12*512; sz += 471){
24ba: 81 c3 d7 01 00 00 add $0x1d7,%ebx
if(cc != sz){
printf(1, "write(%d) ret %d\n", sz, cc);
exit();
}
}
close(fd);
24c0: 56 push %esi
24c1: e8 c4 14 00 00 call 398a <close>
unlink("bigwrite");
24c6: c7 04 24 3d 48 00 00 movl $0x483d,(%esp)
24cd: e8 e0 14 00 00 call 39b2 <unlink>
int fd, sz;
printf(1, "bigwrite test\n");
unlink("bigwrite");
for(sz = 499; sz < 12*512; sz += 471){
24d2: 83 c4 10 add $0x10,%esp
24d5: 81 fb 07 18 00 00 cmp $0x1807,%ebx
24db: 75 93 jne 2470 <bigwrite+0x30>
}
close(fd);
unlink("bigwrite");
}
printf(1, "bigwrite ok\n");
24dd: 83 ec 08 sub $0x8,%esp
24e0: 68 70 48 00 00 push $0x4870
24e5: 6a 01 push $0x1
24e7: e8 c4 15 00 00 call 3ab0 <printf>
}
24ec: 83 c4 10 add $0x10,%esp
24ef: 8d 65 f8 lea -0x8(%ebp),%esp
24f2: 5b pop %ebx
24f3: 5e pop %esi
24f4: 5d pop %ebp
24f5: c3 ret
}
int i;
for(i = 0; i < 2; i++){
int cc = write(fd, buf, sz);
if(cc != sz){
printf(1, "write(%d) ret %d\n", sz, cc);
24f6: 50 push %eax
24f7: 53 push %ebx
24f8: 68 5e 48 00 00 push $0x485e
24fd: 6a 01 push $0x1
24ff: e8 ac 15 00 00 call 3ab0 <printf>
exit();
2504: e8 59 14 00 00 call 3962 <exit>
unlink("bigwrite");
for(sz = 499; sz < 12*512; sz += 471){
fd = open("bigwrite", O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "cannot create bigwrite\n");
2509: 83 ec 08 sub $0x8,%esp
250c: 68 46 48 00 00 push $0x4846
2511: 6a 01 push $0x1
2513: e8 98 15 00 00 call 3ab0 <printf>
exit();
2518: e8 45 14 00 00 call 3962 <exit>
251d: 8d 76 00 lea 0x0(%esi),%esi
00002520 <bigfile>:
printf(1, "bigwrite ok\n");
}
void
bigfile(void)
{
2520: 55 push %ebp
2521: 89 e5 mov %esp,%ebp
2523: 57 push %edi
2524: 56 push %esi
2525: 53 push %ebx
2526: 83 ec 14 sub $0x14,%esp
int fd, i, total, cc;
printf(1, "bigfile test\n");
2529: 68 7d 48 00 00 push $0x487d
252e: 6a 01 push $0x1
2530: e8 7b 15 00 00 call 3ab0 <printf>
unlink("bigfile");
2535: c7 04 24 99 48 00 00 movl $0x4899,(%esp)
253c: e8 71 14 00 00 call 39b2 <unlink>
fd = open("bigfile", O_CREATE | O_RDWR);
2541: 5e pop %esi
2542: 5f pop %edi
2543: 68 02 02 00 00 push $0x202
2548: 68 99 48 00 00 push $0x4899
254d: e8 50 14 00 00 call 39a2 <open>
if(fd < 0){
2552: 83 c4 10 add $0x10,%esp
2555: 85 c0 test %eax,%eax
2557: 0f 88 5f 01 00 00 js 26bc <bigfile+0x19c>
255d: 89 c6 mov %eax,%esi
255f: 31 db xor %ebx,%ebx
2561: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
printf(1, "cannot create bigfile");
exit();
}
for(i = 0; i < 20; i++){
memset(buf, i, 600);
2568: 83 ec 04 sub $0x4,%esp
256b: 68 58 02 00 00 push $0x258
2570: 53 push %ebx
2571: 68 40 86 00 00 push $0x8640
2576: e8 55 12 00 00 call 37d0 <memset>
if(write(fd, buf, 600) != 600){
257b: 83 c4 0c add $0xc,%esp
257e: 68 58 02 00 00 push $0x258
2583: 68 40 86 00 00 push $0x8640
2588: 56 push %esi
2589: e8 f4 13 00 00 call 3982 <write>
258e: 83 c4 10 add $0x10,%esp
2591: 3d 58 02 00 00 cmp $0x258,%eax
2596: 0f 85 f8 00 00 00 jne 2694 <bigfile+0x174>
fd = open("bigfile", O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "cannot create bigfile");
exit();
}
for(i = 0; i < 20; i++){
259c: 83 c3 01 add $0x1,%ebx
259f: 83 fb 14 cmp $0x14,%ebx
25a2: 75 c4 jne 2568 <bigfile+0x48>
if(write(fd, buf, 600) != 600){
printf(1, "write bigfile failed\n");
exit();
}
}
close(fd);
25a4: 83 ec 0c sub $0xc,%esp
25a7: 56 push %esi
25a8: e8 dd 13 00 00 call 398a <close>
fd = open("bigfile", 0);
25ad: 59 pop %ecx
25ae: 5b pop %ebx
25af: 6a 00 push $0x0
25b1: 68 99 48 00 00 push $0x4899
25b6: e8 e7 13 00 00 call 39a2 <open>
if(fd < 0){
25bb: 83 c4 10 add $0x10,%esp
25be: 85 c0 test %eax,%eax
exit();
}
}
close(fd);
fd = open("bigfile", 0);
25c0: 89 c6 mov %eax,%esi
if(fd < 0){
25c2: 0f 88 e0 00 00 00 js 26a8 <bigfile+0x188>
25c8: 31 db xor %ebx,%ebx
25ca: 31 ff xor %edi,%edi
25cc: eb 30 jmp 25fe <bigfile+0xde>
25ce: 66 90 xchg %ax,%ax
printf(1, "read bigfile failed\n");
exit();
}
if(cc == 0)
break;
if(cc != 300){
25d0: 3d 2c 01 00 00 cmp $0x12c,%eax
25d5: 0f 85 91 00 00 00 jne 266c <bigfile+0x14c>
printf(1, "short read bigfile\n");
exit();
}
if(buf[0] != i/2 || buf[299] != i/2){
25db: 0f be 05 40 86 00 00 movsbl 0x8640,%eax
25e2: 89 fa mov %edi,%edx
25e4: d1 fa sar %edx
25e6: 39 d0 cmp %edx,%eax
25e8: 75 6e jne 2658 <bigfile+0x138>
25ea: 0f be 15 6b 87 00 00 movsbl 0x876b,%edx
25f1: 39 d0 cmp %edx,%eax
25f3: 75 63 jne 2658 <bigfile+0x138>
printf(1, "read bigfile wrong data\n");
exit();
}
total += cc;
25f5: 81 c3 2c 01 00 00 add $0x12c,%ebx
if(fd < 0){
printf(1, "cannot open bigfile\n");
exit();
}
total = 0;
for(i = 0; ; i++){
25fb: 83 c7 01 add $0x1,%edi
cc = read(fd, buf, 300);
25fe: 83 ec 04 sub $0x4,%esp
2601: 68 2c 01 00 00 push $0x12c
2606: 68 40 86 00 00 push $0x8640
260b: 56 push %esi
260c: e8 69 13 00 00 call 397a <read>
if(cc < 0){
2611: 83 c4 10 add $0x10,%esp
2614: 85 c0 test %eax,%eax
2616: 78 68 js 2680 <bigfile+0x160>
printf(1, "read bigfile failed\n");
exit();
}
if(cc == 0)
2618: 75 b6 jne 25d0 <bigfile+0xb0>
printf(1, "read bigfile wrong data\n");
exit();
}
total += cc;
}
close(fd);
261a: 83 ec 0c sub $0xc,%esp
261d: 56 push %esi
261e: e8 67 13 00 00 call 398a <close>
if(total != 20*600){
2623: 83 c4 10 add $0x10,%esp
2626: 81 fb e0 2e 00 00 cmp $0x2ee0,%ebx
262c: 0f 85 9e 00 00 00 jne 26d0 <bigfile+0x1b0>
printf(1, "read bigfile wrong total\n");
exit();
}
unlink("bigfile");
2632: 83 ec 0c sub $0xc,%esp
2635: 68 99 48 00 00 push $0x4899
263a: e8 73 13 00 00 call 39b2 <unlink>
printf(1, "bigfile test ok\n");
263f: 58 pop %eax
2640: 5a pop %edx
2641: 68 28 49 00 00 push $0x4928
2646: 6a 01 push $0x1
2648: e8 63 14 00 00 call 3ab0 <printf>
}
264d: 83 c4 10 add $0x10,%esp
2650: 8d 65 f4 lea -0xc(%ebp),%esp
2653: 5b pop %ebx
2654: 5e pop %esi
2655: 5f pop %edi
2656: 5d pop %ebp
2657: c3 ret
if(cc != 300){
printf(1, "short read bigfile\n");
exit();
}
if(buf[0] != i/2 || buf[299] != i/2){
printf(1, "read bigfile wrong data\n");
2658: 83 ec 08 sub $0x8,%esp
265b: 68 f5 48 00 00 push $0x48f5
2660: 6a 01 push $0x1
2662: e8 49 14 00 00 call 3ab0 <printf>
exit();
2667: e8 f6 12 00 00 call 3962 <exit>
exit();
}
if(cc == 0)
break;
if(cc != 300){
printf(1, "short read bigfile\n");
266c: 83 ec 08 sub $0x8,%esp
266f: 68 e1 48 00 00 push $0x48e1
2674: 6a 01 push $0x1
2676: e8 35 14 00 00 call 3ab0 <printf>
exit();
267b: e8 e2 12 00 00 call 3962 <exit>
}
total = 0;
for(i = 0; ; i++){
cc = read(fd, buf, 300);
if(cc < 0){
printf(1, "read bigfile failed\n");
2680: 83 ec 08 sub $0x8,%esp
2683: 68 cc 48 00 00 push $0x48cc
2688: 6a 01 push $0x1
268a: e8 21 14 00 00 call 3ab0 <printf>
exit();
268f: e8 ce 12 00 00 call 3962 <exit>
exit();
}
for(i = 0; i < 20; i++){
memset(buf, i, 600);
if(write(fd, buf, 600) != 600){
printf(1, "write bigfile failed\n");
2694: 83 ec 08 sub $0x8,%esp
2697: 68 a1 48 00 00 push $0x48a1
269c: 6a 01 push $0x1
269e: e8 0d 14 00 00 call 3ab0 <printf>
exit();
26a3: e8 ba 12 00 00 call 3962 <exit>
}
close(fd);
fd = open("bigfile", 0);
if(fd < 0){
printf(1, "cannot open bigfile\n");
26a8: 83 ec 08 sub $0x8,%esp
26ab: 68 b7 48 00 00 push $0x48b7
26b0: 6a 01 push $0x1
26b2: e8 f9 13 00 00 call 3ab0 <printf>
exit();
26b7: e8 a6 12 00 00 call 3962 <exit>
printf(1, "bigfile test\n");
unlink("bigfile");
fd = open("bigfile", O_CREATE | O_RDWR);
if(fd < 0){
printf(1, "cannot create bigfile");
26bc: 83 ec 08 sub $0x8,%esp
26bf: 68 8b 48 00 00 push $0x488b
26c4: 6a 01 push $0x1
26c6: e8 e5 13 00 00 call 3ab0 <printf>
exit();
26cb: e8 92 12 00 00 call 3962 <exit>
}
total += cc;
}
close(fd);
if(total != 20*600){
printf(1, "read bigfile wrong total\n");
26d0: 83 ec 08 sub $0x8,%esp
26d3: 68 0e 49 00 00 push $0x490e
26d8: 6a 01 push $0x1
26da: e8 d1 13 00 00 call 3ab0 <printf>
exit();
26df: e8 7e 12 00 00 call 3962 <exit>
26e4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
26ea: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
000026f0 <fourteen>:
printf(1, "bigfile test ok\n");
}
void
fourteen(void)
{
26f0: 55 push %ebp
26f1: 89 e5 mov %esp,%ebp
26f3: 83 ec 10 sub $0x10,%esp
int fd;
// DIRSIZ is 14.
printf(1, "fourteen test\n");
26f6: 68 39 49 00 00 push $0x4939
26fb: 6a 01 push $0x1
26fd: e8 ae 13 00 00 call 3ab0 <printf>
if(mkdir("12345678901234") != 0){
2702: c7 04 24 74 49 00 00 movl $0x4974,(%esp)
2709: e8 bc 12 00 00 call 39ca <mkdir>
270e: 83 c4 10 add $0x10,%esp
2711: 85 c0 test %eax,%eax
2713: 0f 85 97 00 00 00 jne 27b0 <fourteen+0xc0>
printf(1, "mkdir 12345678901234 failed\n");
exit();
}
if(mkdir("12345678901234/123456789012345") != 0){
2719: 83 ec 0c sub $0xc,%esp
271c: 68 30 51 00 00 push $0x5130
2721: e8 a4 12 00 00 call 39ca <mkdir>
2726: 83 c4 10 add $0x10,%esp
2729: 85 c0 test %eax,%eax
272b: 0f 85 de 00 00 00 jne 280f <fourteen+0x11f>
printf(1, "mkdir 12345678901234/123456789012345 failed\n");
exit();
}
fd = open("123456789012345/123456789012345/123456789012345", O_CREATE);
2731: 83 ec 08 sub $0x8,%esp
2734: 68 00 02 00 00 push $0x200
2739: 68 80 51 00 00 push $0x5180
273e: e8 5f 12 00 00 call 39a2 <open>
if(fd < 0){
2743: 83 c4 10 add $0x10,%esp
2746: 85 c0 test %eax,%eax
2748: 0f 88 ae 00 00 00 js 27fc <fourteen+0x10c>
printf(1, "create 123456789012345/123456789012345/123456789012345 failed\n");
exit();
}
close(fd);
274e: 83 ec 0c sub $0xc,%esp
2751: 50 push %eax
2752: e8 33 12 00 00 call 398a <close>
fd = open("12345678901234/12345678901234/12345678901234", 0);
2757: 58 pop %eax
2758: 5a pop %edx
2759: 6a 00 push $0x0
275b: 68 f0 51 00 00 push $0x51f0
2760: e8 3d 12 00 00 call 39a2 <open>
if(fd < 0){
2765: 83 c4 10 add $0x10,%esp
2768: 85 c0 test %eax,%eax
276a: 78 7d js 27e9 <fourteen+0xf9>
printf(1, "open 12345678901234/12345678901234/12345678901234 failed\n");
exit();
}
close(fd);
276c: 83 ec 0c sub $0xc,%esp
276f: 50 push %eax
2770: e8 15 12 00 00 call 398a <close>
if(mkdir("12345678901234/12345678901234") == 0){
2775: c7 04 24 65 49 00 00 movl $0x4965,(%esp)
277c: e8 49 12 00 00 call 39ca <mkdir>
2781: 83 c4 10 add $0x10,%esp
2784: 85 c0 test %eax,%eax
2786: 74 4e je 27d6 <fourteen+0xe6>
printf(1, "mkdir 12345678901234/12345678901234 succeeded!\n");
exit();
}
if(mkdir("123456789012345/12345678901234") == 0){
2788: 83 ec 0c sub $0xc,%esp
278b: 68 8c 52 00 00 push $0x528c
2790: e8 35 12 00 00 call 39ca <mkdir>
2795: 83 c4 10 add $0x10,%esp
2798: 85 c0 test %eax,%eax
279a: 74 27 je 27c3 <fourteen+0xd3>
printf(1, "mkdir 12345678901234/123456789012345 succeeded!\n");
exit();
}
printf(1, "fourteen ok\n");
279c: 83 ec 08 sub $0x8,%esp
279f: 68 83 49 00 00 push $0x4983
27a4: 6a 01 push $0x1
27a6: e8 05 13 00 00 call 3ab0 <printf>
}
27ab: 83 c4 10 add $0x10,%esp
27ae: c9 leave
27af: c3 ret
// DIRSIZ is 14.
printf(1, "fourteen test\n");
if(mkdir("12345678901234") != 0){
printf(1, "mkdir 12345678901234 failed\n");
27b0: 50 push %eax
27b1: 50 push %eax
27b2: 68 48 49 00 00 push $0x4948
27b7: 6a 01 push $0x1
27b9: e8 f2 12 00 00 call 3ab0 <printf>
exit();
27be: e8 9f 11 00 00 call 3962 <exit>
if(mkdir("12345678901234/12345678901234") == 0){
printf(1, "mkdir 12345678901234/12345678901234 succeeded!\n");
exit();
}
if(mkdir("123456789012345/12345678901234") == 0){
printf(1, "mkdir 12345678901234/123456789012345 succeeded!\n");
27c3: 50 push %eax
27c4: 50 push %eax
27c5: 68 ac 52 00 00 push $0x52ac
27ca: 6a 01 push $0x1
27cc: e8 df 12 00 00 call 3ab0 <printf>
exit();
27d1: e8 8c 11 00 00 call 3962 <exit>
exit();
}
close(fd);
if(mkdir("12345678901234/12345678901234") == 0){
printf(1, "mkdir 12345678901234/12345678901234 succeeded!\n");
27d6: 52 push %edx
27d7: 52 push %edx
27d8: 68 5c 52 00 00 push $0x525c
27dd: 6a 01 push $0x1
27df: e8 cc 12 00 00 call 3ab0 <printf>
exit();
27e4: e8 79 11 00 00 call 3962 <exit>
exit();
}
close(fd);
fd = open("12345678901234/12345678901234/12345678901234", 0);
if(fd < 0){
printf(1, "open 12345678901234/12345678901234/12345678901234 failed\n");
27e9: 51 push %ecx
27ea: 51 push %ecx
27eb: 68 20 52 00 00 push $0x5220
27f0: 6a 01 push $0x1
27f2: e8 b9 12 00 00 call 3ab0 <printf>
exit();
27f7: e8 66 11 00 00 call 3962 <exit>
printf(1, "mkdir 12345678901234/123456789012345 failed\n");
exit();
}
fd = open("123456789012345/123456789012345/123456789012345", O_CREATE);
if(fd < 0){
printf(1, "create 123456789012345/123456789012345/123456789012345 failed\n");
27fc: 51 push %ecx
27fd: 51 push %ecx
27fe: 68 b0 51 00 00 push $0x51b0
2803: 6a 01 push $0x1
2805: e8 a6 12 00 00 call 3ab0 <printf>
exit();
280a: e8 53 11 00 00 call 3962 <exit>
if(mkdir("12345678901234") != 0){
printf(1, "mkdir 12345678901234 failed\n");
exit();
}
if(mkdir("12345678901234/123456789012345") != 0){
printf(1, "mkdir 12345678901234/123456789012345 failed\n");
280f: 50 push %eax
2810: 50 push %eax
2811: 68 50 51 00 00 push $0x5150
2816: 6a 01 push $0x1
2818: e8 93 12 00 00 call 3ab0 <printf>
exit();
281d: e8 40 11 00 00 call 3962 <exit>
2822: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
2829: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00002830 <rmdot>:
printf(1, "fourteen ok\n");
}
void
rmdot(void)
{
2830: 55 push %ebp
2831: 89 e5 mov %esp,%ebp
2833: 83 ec 10 sub $0x10,%esp
printf(1, "rmdot test\n");
2836: 68 90 49 00 00 push $0x4990
283b: 6a 01 push $0x1
283d: e8 6e 12 00 00 call 3ab0 <printf>
if(mkdir("dots") != 0){
2842: c7 04 24 9c 49 00 00 movl $0x499c,(%esp)
2849: e8 7c 11 00 00 call 39ca <mkdir>
284e: 83 c4 10 add $0x10,%esp
2851: 85 c0 test %eax,%eax
2853: 0f 85 b0 00 00 00 jne 2909 <rmdot+0xd9>
printf(1, "mkdir dots failed\n");
exit();
}
if(chdir("dots") != 0){
2859: 83 ec 0c sub $0xc,%esp
285c: 68 9c 49 00 00 push $0x499c
2861: e8 6c 11 00 00 call 39d2 <chdir>
2866: 83 c4 10 add $0x10,%esp
2869: 85 c0 test %eax,%eax
286b: 0f 85 1d 01 00 00 jne 298e <rmdot+0x15e>
printf(1, "chdir dots failed\n");
exit();
}
if(unlink(".") == 0){
2871: 83 ec 0c sub $0xc,%esp
2874: 68 47 46 00 00 push $0x4647
2879: e8 34 11 00 00 call 39b2 <unlink>
287e: 83 c4 10 add $0x10,%esp
2881: 85 c0 test %eax,%eax
2883: 0f 84 f2 00 00 00 je 297b <rmdot+0x14b>
printf(1, "rm . worked!\n");
exit();
}
if(unlink("..") == 0){
2889: 83 ec 0c sub $0xc,%esp
288c: 68 46 46 00 00 push $0x4646
2891: e8 1c 11 00 00 call 39b2 <unlink>
2896: 83 c4 10 add $0x10,%esp
2899: 85 c0 test %eax,%eax
289b: 0f 84 c7 00 00 00 je 2968 <rmdot+0x138>
printf(1, "rm .. worked!\n");
exit();
}
if(chdir("/") != 0){
28a1: 83 ec 0c sub $0xc,%esp
28a4: 68 19 3e 00 00 push $0x3e19
28a9: e8 24 11 00 00 call 39d2 <chdir>
28ae: 83 c4 10 add $0x10,%esp
28b1: 85 c0 test %eax,%eax
28b3: 0f 85 9c 00 00 00 jne 2955 <rmdot+0x125>
printf(1, "chdir / failed\n");
exit();
}
if(unlink("dots/.") == 0){
28b9: 83 ec 0c sub $0xc,%esp
28bc: 68 e4 49 00 00 push $0x49e4
28c1: e8 ec 10 00 00 call 39b2 <unlink>
28c6: 83 c4 10 add $0x10,%esp
28c9: 85 c0 test %eax,%eax
28cb: 74 75 je 2942 <rmdot+0x112>
printf(1, "unlink dots/. worked!\n");
exit();
}
if(unlink("dots/..") == 0){
28cd: 83 ec 0c sub $0xc,%esp
28d0: 68 02 4a 00 00 push $0x4a02
28d5: e8 d8 10 00 00 call 39b2 <unlink>
28da: 83 c4 10 add $0x10,%esp
28dd: 85 c0 test %eax,%eax
28df: 74 4e je 292f <rmdot+0xff>
printf(1, "unlink dots/.. worked!\n");
exit();
}
if(unlink("dots") != 0){
28e1: 83 ec 0c sub $0xc,%esp
28e4: 68 9c 49 00 00 push $0x499c
28e9: e8 c4 10 00 00 call 39b2 <unlink>
28ee: 83 c4 10 add $0x10,%esp
28f1: 85 c0 test %eax,%eax
28f3: 75 27 jne 291c <rmdot+0xec>
printf(1, "unlink dots failed!\n");
exit();
}
printf(1, "rmdot ok\n");
28f5: 83 ec 08 sub $0x8,%esp
28f8: 68 37 4a 00 00 push $0x4a37
28fd: 6a 01 push $0x1
28ff: e8 ac 11 00 00 call 3ab0 <printf>
}
2904: 83 c4 10 add $0x10,%esp
2907: c9 leave
2908: c3 ret
void
rmdot(void)
{
printf(1, "rmdot test\n");
if(mkdir("dots") != 0){
printf(1, "mkdir dots failed\n");
2909: 50 push %eax
290a: 50 push %eax
290b: 68 a1 49 00 00 push $0x49a1
2910: 6a 01 push $0x1
2912: e8 99 11 00 00 call 3ab0 <printf>
exit();
2917: e8 46 10 00 00 call 3962 <exit>
if(unlink("dots/..") == 0){
printf(1, "unlink dots/.. worked!\n");
exit();
}
if(unlink("dots") != 0){
printf(1, "unlink dots failed!\n");
291c: 50 push %eax
291d: 50 push %eax
291e: 68 22 4a 00 00 push $0x4a22
2923: 6a 01 push $0x1
2925: e8 86 11 00 00 call 3ab0 <printf>
exit();
292a: e8 33 10 00 00 call 3962 <exit>
if(unlink("dots/.") == 0){
printf(1, "unlink dots/. worked!\n");
exit();
}
if(unlink("dots/..") == 0){
printf(1, "unlink dots/.. worked!\n");
292f: 52 push %edx
2930: 52 push %edx
2931: 68 0a 4a 00 00 push $0x4a0a
2936: 6a 01 push $0x1
2938: e8 73 11 00 00 call 3ab0 <printf>
exit();
293d: e8 20 10 00 00 call 3962 <exit>
if(chdir("/") != 0){
printf(1, "chdir / failed\n");
exit();
}
if(unlink("dots/.") == 0){
printf(1, "unlink dots/. worked!\n");
2942: 51 push %ecx
2943: 51 push %ecx
2944: 68 eb 49 00 00 push $0x49eb
2949: 6a 01 push $0x1
294b: e8 60 11 00 00 call 3ab0 <printf>
exit();
2950: e8 0d 10 00 00 call 3962 <exit>
if(unlink("..") == 0){
printf(1, "rm .. worked!\n");
exit();
}
if(chdir("/") != 0){
printf(1, "chdir / failed\n");
2955: 50 push %eax
2956: 50 push %eax
2957: 68 1b 3e 00 00 push $0x3e1b
295c: 6a 01 push $0x1
295e: e8 4d 11 00 00 call 3ab0 <printf>
exit();
2963: e8 fa 0f 00 00 call 3962 <exit>
if(unlink(".") == 0){
printf(1, "rm . worked!\n");
exit();
}
if(unlink("..") == 0){
printf(1, "rm .. worked!\n");
2968: 50 push %eax
2969: 50 push %eax
296a: 68 d5 49 00 00 push $0x49d5
296f: 6a 01 push $0x1
2971: e8 3a 11 00 00 call 3ab0 <printf>
exit();
2976: e8 e7 0f 00 00 call 3962 <exit>
if(chdir("dots") != 0){
printf(1, "chdir dots failed\n");
exit();
}
if(unlink(".") == 0){
printf(1, "rm . worked!\n");
297b: 50 push %eax
297c: 50 push %eax
297d: 68 c7 49 00 00 push $0x49c7
2982: 6a 01 push $0x1
2984: e8 27 11 00 00 call 3ab0 <printf>
exit();
2989: e8 d4 0f 00 00 call 3962 <exit>
if(mkdir("dots") != 0){
printf(1, "mkdir dots failed\n");
exit();
}
if(chdir("dots") != 0){
printf(1, "chdir dots failed\n");
298e: 50 push %eax
298f: 50 push %eax
2990: 68 b4 49 00 00 push $0x49b4
2995: 6a 01 push $0x1
2997: e8 14 11 00 00 call 3ab0 <printf>
exit();
299c: e8 c1 0f 00 00 call 3962 <exit>
29a1: eb 0d jmp 29b0 <dirfile>
29a3: 90 nop
29a4: 90 nop
29a5: 90 nop
29a6: 90 nop
29a7: 90 nop
29a8: 90 nop
29a9: 90 nop
29aa: 90 nop
29ab: 90 nop
29ac: 90 nop
29ad: 90 nop
29ae: 90 nop
29af: 90 nop
000029b0 <dirfile>:
printf(1, "rmdot ok\n");
}
void
dirfile(void)
{
29b0: 55 push %ebp
29b1: 89 e5 mov %esp,%ebp
29b3: 53 push %ebx
29b4: 83 ec 0c sub $0xc,%esp
int fd;
printf(1, "dir vs file\n");
29b7: 68 41 4a 00 00 push $0x4a41
29bc: 6a 01 push $0x1
29be: e8 ed 10 00 00 call 3ab0 <printf>
fd = open("dirfile", O_CREATE);
29c3: 59 pop %ecx
29c4: 5b pop %ebx
29c5: 68 00 02 00 00 push $0x200
29ca: 68 4e 4a 00 00 push $0x4a4e
29cf: e8 ce 0f 00 00 call 39a2 <open>
if(fd < 0){
29d4: 83 c4 10 add $0x10,%esp
29d7: 85 c0 test %eax,%eax
29d9: 0f 88 43 01 00 00 js 2b22 <dirfile+0x172>
printf(1, "create dirfile failed\n");
exit();
}
close(fd);
29df: 83 ec 0c sub $0xc,%esp
29e2: 50 push %eax
29e3: e8 a2 0f 00 00 call 398a <close>
if(chdir("dirfile") == 0){
29e8: c7 04 24 4e 4a 00 00 movl $0x4a4e,(%esp)
29ef: e8 de 0f 00 00 call 39d2 <chdir>
29f4: 83 c4 10 add $0x10,%esp
29f7: 85 c0 test %eax,%eax
29f9: 0f 84 10 01 00 00 je 2b0f <dirfile+0x15f>
printf(1, "chdir dirfile succeeded!\n");
exit();
}
fd = open("dirfile/xx", 0);
29ff: 83 ec 08 sub $0x8,%esp
2a02: 6a 00 push $0x0
2a04: 68 87 4a 00 00 push $0x4a87
2a09: e8 94 0f 00 00 call 39a2 <open>
if(fd >= 0){
2a0e: 83 c4 10 add $0x10,%esp
2a11: 85 c0 test %eax,%eax
2a13: 0f 89 e3 00 00 00 jns 2afc <dirfile+0x14c>
printf(1, "create dirfile/xx succeeded!\n");
exit();
}
fd = open("dirfile/xx", O_CREATE);
2a19: 83 ec 08 sub $0x8,%esp
2a1c: 68 00 02 00 00 push $0x200
2a21: 68 87 4a 00 00 push $0x4a87
2a26: e8 77 0f 00 00 call 39a2 <open>
if(fd >= 0){
2a2b: 83 c4 10 add $0x10,%esp
2a2e: 85 c0 test %eax,%eax
2a30: 0f 89 c6 00 00 00 jns 2afc <dirfile+0x14c>
printf(1, "create dirfile/xx succeeded!\n");
exit();
}
if(mkdir("dirfile/xx") == 0){
2a36: 83 ec 0c sub $0xc,%esp
2a39: 68 87 4a 00 00 push $0x4a87
2a3e: e8 87 0f 00 00 call 39ca <mkdir>
2a43: 83 c4 10 add $0x10,%esp
2a46: 85 c0 test %eax,%eax
2a48: 0f 84 46 01 00 00 je 2b94 <dirfile+0x1e4>
printf(1, "mkdir dirfile/xx succeeded!\n");
exit();
}
if(unlink("dirfile/xx") == 0){
2a4e: 83 ec 0c sub $0xc,%esp
2a51: 68 87 4a 00 00 push $0x4a87
2a56: e8 57 0f 00 00 call 39b2 <unlink>
2a5b: 83 c4 10 add $0x10,%esp
2a5e: 85 c0 test %eax,%eax
2a60: 0f 84 1b 01 00 00 je 2b81 <dirfile+0x1d1>
printf(1, "unlink dirfile/xx succeeded!\n");
exit();
}
if(link("README", "dirfile/xx") == 0){
2a66: 83 ec 08 sub $0x8,%esp
2a69: 68 87 4a 00 00 push $0x4a87
2a6e: 68 eb 4a 00 00 push $0x4aeb
2a73: e8 4a 0f 00 00 call 39c2 <link>
2a78: 83 c4 10 add $0x10,%esp
2a7b: 85 c0 test %eax,%eax
2a7d: 0f 84 eb 00 00 00 je 2b6e <dirfile+0x1be>
printf(1, "link to dirfile/xx succeeded!\n");
exit();
}
if(unlink("dirfile") != 0){
2a83: 83 ec 0c sub $0xc,%esp
2a86: 68 4e 4a 00 00 push $0x4a4e
2a8b: e8 22 0f 00 00 call 39b2 <unlink>
2a90: 83 c4 10 add $0x10,%esp
2a93: 85 c0 test %eax,%eax
2a95: 0f 85 c0 00 00 00 jne 2b5b <dirfile+0x1ab>
printf(1, "unlink dirfile failed!\n");
exit();
}
fd = open(".", O_RDWR);
2a9b: 83 ec 08 sub $0x8,%esp
2a9e: 6a 02 push $0x2
2aa0: 68 47 46 00 00 push $0x4647
2aa5: e8 f8 0e 00 00 call 39a2 <open>
if(fd >= 0){
2aaa: 83 c4 10 add $0x10,%esp
2aad: 85 c0 test %eax,%eax
2aaf: 0f 89 93 00 00 00 jns 2b48 <dirfile+0x198>
printf(1, "open . for writing succeeded!\n");
exit();
}
fd = open(".", 0);
2ab5: 83 ec 08 sub $0x8,%esp
2ab8: 6a 00 push $0x0
2aba: 68 47 46 00 00 push $0x4647
2abf: e8 de 0e 00 00 call 39a2 <open>
if(write(fd, "x", 1) > 0){
2ac4: 83 c4 0c add $0xc,%esp
fd = open(".", O_RDWR);
if(fd >= 0){
printf(1, "open . for writing succeeded!\n");
exit();
}
fd = open(".", 0);
2ac7: 89 c3 mov %eax,%ebx
if(write(fd, "x", 1) > 0){
2ac9: 6a 01 push $0x1
2acb: 68 2a 47 00 00 push $0x472a
2ad0: 50 push %eax
2ad1: e8 ac 0e 00 00 call 3982 <write>
2ad6: 83 c4 10 add $0x10,%esp
2ad9: 85 c0 test %eax,%eax
2adb: 7f 58 jg 2b35 <dirfile+0x185>
printf(1, "write . succeeded!\n");
exit();
}
close(fd);
2add: 83 ec 0c sub $0xc,%esp
2ae0: 53 push %ebx
2ae1: e8 a4 0e 00 00 call 398a <close>
printf(1, "dir vs file OK\n");
2ae6: 58 pop %eax
2ae7: 5a pop %edx
2ae8: 68 1e 4b 00 00 push $0x4b1e
2aed: 6a 01 push $0x1
2aef: e8 bc 0f 00 00 call 3ab0 <printf>
}
2af4: 83 c4 10 add $0x10,%esp
2af7: 8b 5d fc mov -0x4(%ebp),%ebx
2afa: c9 leave
2afb: c3 ret
printf(1, "chdir dirfile succeeded!\n");
exit();
}
fd = open("dirfile/xx", 0);
if(fd >= 0){
printf(1, "create dirfile/xx succeeded!\n");
2afc: 50 push %eax
2afd: 50 push %eax
2afe: 68 92 4a 00 00 push $0x4a92
2b03: 6a 01 push $0x1
2b05: e8 a6 0f 00 00 call 3ab0 <printf>
exit();
2b0a: e8 53 0e 00 00 call 3962 <exit>
printf(1, "create dirfile failed\n");
exit();
}
close(fd);
if(chdir("dirfile") == 0){
printf(1, "chdir dirfile succeeded!\n");
2b0f: 50 push %eax
2b10: 50 push %eax
2b11: 68 6d 4a 00 00 push $0x4a6d
2b16: 6a 01 push $0x1
2b18: e8 93 0f 00 00 call 3ab0 <printf>
exit();
2b1d: e8 40 0e 00 00 call 3962 <exit>
printf(1, "dir vs file\n");
fd = open("dirfile", O_CREATE);
if(fd < 0){
printf(1, "create dirfile failed\n");
2b22: 52 push %edx
2b23: 52 push %edx
2b24: 68 56 4a 00 00 push $0x4a56
2b29: 6a 01 push $0x1
2b2b: e8 80 0f 00 00 call 3ab0 <printf>
exit();
2b30: e8 2d 0e 00 00 call 3962 <exit>
printf(1, "open . for writing succeeded!\n");
exit();
}
fd = open(".", 0);
if(write(fd, "x", 1) > 0){
printf(1, "write . succeeded!\n");
2b35: 51 push %ecx
2b36: 51 push %ecx
2b37: 68 0a 4b 00 00 push $0x4b0a
2b3c: 6a 01 push $0x1
2b3e: e8 6d 0f 00 00 call 3ab0 <printf>
exit();
2b43: e8 1a 0e 00 00 call 3962 <exit>
exit();
}
fd = open(".", O_RDWR);
if(fd >= 0){
printf(1, "open . for writing succeeded!\n");
2b48: 53 push %ebx
2b49: 53 push %ebx
2b4a: 68 00 53 00 00 push $0x5300
2b4f: 6a 01 push $0x1
2b51: e8 5a 0f 00 00 call 3ab0 <printf>
exit();
2b56: e8 07 0e 00 00 call 3962 <exit>
if(link("README", "dirfile/xx") == 0){
printf(1, "link to dirfile/xx succeeded!\n");
exit();
}
if(unlink("dirfile") != 0){
printf(1, "unlink dirfile failed!\n");
2b5b: 50 push %eax
2b5c: 50 push %eax
2b5d: 68 f2 4a 00 00 push $0x4af2
2b62: 6a 01 push $0x1
2b64: e8 47 0f 00 00 call 3ab0 <printf>
exit();
2b69: e8 f4 0d 00 00 call 3962 <exit>
if(unlink("dirfile/xx") == 0){
printf(1, "unlink dirfile/xx succeeded!\n");
exit();
}
if(link("README", "dirfile/xx") == 0){
printf(1, "link to dirfile/xx succeeded!\n");
2b6e: 50 push %eax
2b6f: 50 push %eax
2b70: 68 e0 52 00 00 push $0x52e0
2b75: 6a 01 push $0x1
2b77: e8 34 0f 00 00 call 3ab0 <printf>
exit();
2b7c: e8 e1 0d 00 00 call 3962 <exit>
if(mkdir("dirfile/xx") == 0){
printf(1, "mkdir dirfile/xx succeeded!\n");
exit();
}
if(unlink("dirfile/xx") == 0){
printf(1, "unlink dirfile/xx succeeded!\n");
2b81: 50 push %eax
2b82: 50 push %eax
2b83: 68 cd 4a 00 00 push $0x4acd
2b88: 6a 01 push $0x1
2b8a: e8 21 0f 00 00 call 3ab0 <printf>
exit();
2b8f: e8 ce 0d 00 00 call 3962 <exit>
if(fd >= 0){
printf(1, "create dirfile/xx succeeded!\n");
exit();
}
if(mkdir("dirfile/xx") == 0){
printf(1, "mkdir dirfile/xx succeeded!\n");
2b94: 50 push %eax
2b95: 50 push %eax
2b96: 68 b0 4a 00 00 push $0x4ab0
2b9b: 6a 01 push $0x1
2b9d: e8 0e 0f 00 00 call 3ab0 <printf>
exit();
2ba2: e8 bb 0d 00 00 call 3962 <exit>
2ba7: 89 f6 mov %esi,%esi
2ba9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00002bb0 <iref>:
}
// test that iput() is called at the end of _namei()
void
iref(void)
{
2bb0: 55 push %ebp
2bb1: 89 e5 mov %esp,%ebp
2bb3: 53 push %ebx
int i, fd;
printf(1, "empty file name\n");
2bb4: bb 33 00 00 00 mov $0x33,%ebx
}
// test that iput() is called at the end of _namei()
void
iref(void)
{
2bb9: 83 ec 0c sub $0xc,%esp
int i, fd;
printf(1, "empty file name\n");
2bbc: 68 2e 4b 00 00 push $0x4b2e
2bc1: 6a 01 push $0x1
2bc3: e8 e8 0e 00 00 call 3ab0 <printf>
2bc8: 83 c4 10 add $0x10,%esp
2bcb: 90 nop
2bcc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
// the 50 is NINODE
for(i = 0; i < 50 + 1; i++){
if(mkdir("irefd") != 0){
2bd0: 83 ec 0c sub $0xc,%esp
2bd3: 68 3f 4b 00 00 push $0x4b3f
2bd8: e8 ed 0d 00 00 call 39ca <mkdir>
2bdd: 83 c4 10 add $0x10,%esp
2be0: 85 c0 test %eax,%eax
2be2: 0f 85 bb 00 00 00 jne 2ca3 <iref+0xf3>
printf(1, "mkdir irefd failed\n");
exit();
}
if(chdir("irefd") != 0){
2be8: 83 ec 0c sub $0xc,%esp
2beb: 68 3f 4b 00 00 push $0x4b3f
2bf0: e8 dd 0d 00 00 call 39d2 <chdir>
2bf5: 83 c4 10 add $0x10,%esp
2bf8: 85 c0 test %eax,%eax
2bfa: 0f 85 b7 00 00 00 jne 2cb7 <iref+0x107>
printf(1, "chdir irefd failed\n");
exit();
}
mkdir("");
2c00: 83 ec 0c sub $0xc,%esp
2c03: 68 f4 41 00 00 push $0x41f4
2c08: e8 bd 0d 00 00 call 39ca <mkdir>
link("README", "");
2c0d: 59 pop %ecx
2c0e: 58 pop %eax
2c0f: 68 f4 41 00 00 push $0x41f4
2c14: 68 eb 4a 00 00 push $0x4aeb
2c19: e8 a4 0d 00 00 call 39c2 <link>
fd = open("", O_CREATE);
2c1e: 58 pop %eax
2c1f: 5a pop %edx
2c20: 68 00 02 00 00 push $0x200
2c25: 68 f4 41 00 00 push $0x41f4
2c2a: e8 73 0d 00 00 call 39a2 <open>
if(fd >= 0)
2c2f: 83 c4 10 add $0x10,%esp
2c32: 85 c0 test %eax,%eax
2c34: 78 0c js 2c42 <iref+0x92>
close(fd);
2c36: 83 ec 0c sub $0xc,%esp
2c39: 50 push %eax
2c3a: e8 4b 0d 00 00 call 398a <close>
2c3f: 83 c4 10 add $0x10,%esp
fd = open("xx", O_CREATE);
2c42: 83 ec 08 sub $0x8,%esp
2c45: 68 00 02 00 00 push $0x200
2c4a: 68 29 47 00 00 push $0x4729
2c4f: e8 4e 0d 00 00 call 39a2 <open>
if(fd >= 0)
2c54: 83 c4 10 add $0x10,%esp
2c57: 85 c0 test %eax,%eax
2c59: 78 0c js 2c67 <iref+0xb7>
close(fd);
2c5b: 83 ec 0c sub $0xc,%esp
2c5e: 50 push %eax
2c5f: e8 26 0d 00 00 call 398a <close>
2c64: 83 c4 10 add $0x10,%esp
unlink("xx");
2c67: 83 ec 0c sub $0xc,%esp
2c6a: 68 29 47 00 00 push $0x4729
2c6f: e8 3e 0d 00 00 call 39b2 <unlink>
int i, fd;
printf(1, "empty file name\n");
// the 50 is NINODE
for(i = 0; i < 50 + 1; i++){
2c74: 83 c4 10 add $0x10,%esp
2c77: 83 eb 01 sub $0x1,%ebx
2c7a: 0f 85 50 ff ff ff jne 2bd0 <iref+0x20>
if(fd >= 0)
close(fd);
unlink("xx");
}
chdir("/");
2c80: 83 ec 0c sub $0xc,%esp
2c83: 68 19 3e 00 00 push $0x3e19
2c88: e8 45 0d 00 00 call 39d2 <chdir>
printf(1, "empty file name OK\n");
2c8d: 58 pop %eax
2c8e: 5a pop %edx
2c8f: 68 6d 4b 00 00 push $0x4b6d
2c94: 6a 01 push $0x1
2c96: e8 15 0e 00 00 call 3ab0 <printf>
}
2c9b: 83 c4 10 add $0x10,%esp
2c9e: 8b 5d fc mov -0x4(%ebp),%ebx
2ca1: c9 leave
2ca2: c3 ret
printf(1, "empty file name\n");
// the 50 is NINODE
for(i = 0; i < 50 + 1; i++){
if(mkdir("irefd") != 0){
printf(1, "mkdir irefd failed\n");
2ca3: 83 ec 08 sub $0x8,%esp
2ca6: 68 45 4b 00 00 push $0x4b45
2cab: 6a 01 push $0x1
2cad: e8 fe 0d 00 00 call 3ab0 <printf>
exit();
2cb2: e8 ab 0c 00 00 call 3962 <exit>
}
if(chdir("irefd") != 0){
printf(1, "chdir irefd failed\n");
2cb7: 83 ec 08 sub $0x8,%esp
2cba: 68 59 4b 00 00 push $0x4b59
2cbf: 6a 01 push $0x1
2cc1: e8 ea 0d 00 00 call 3ab0 <printf>
exit();
2cc6: e8 97 0c 00 00 call 3962 <exit>
2ccb: 90 nop
2ccc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00002cd0 <forktest>:
// test that fork fails gracefully
// the forktest binary also does this, but it runs out of proc entries first.
// inside the bigger usertests binary, we run out of memory first.
void
forktest(void)
{
2cd0: 55 push %ebp
2cd1: 89 e5 mov %esp,%ebp
2cd3: 53 push %ebx
int n, pid;
printf(1, "fork test\n");
for(n=0; n<1000; n++){
2cd4: 31 db xor %ebx,%ebx
// test that fork fails gracefully
// the forktest binary also does this, but it runs out of proc entries first.
// inside the bigger usertests binary, we run out of memory first.
void
forktest(void)
{
2cd6: 83 ec 0c sub $0xc,%esp
int n, pid;
printf(1, "fork test\n");
2cd9: 68 81 4b 00 00 push $0x4b81
2cde: 6a 01 push $0x1
2ce0: e8 cb 0d 00 00 call 3ab0 <printf>
2ce5: 83 c4 10 add $0x10,%esp
2ce8: eb 13 jmp 2cfd <forktest+0x2d>
2cea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(n=0; n<1000; n++){
pid = fork(0);
if(pid < 0)
break;
if(pid == 0)
2cf0: 74 6a je 2d5c <forktest+0x8c>
{
int n, pid;
printf(1, "fork test\n");
for(n=0; n<1000; n++){
2cf2: 83 c3 01 add $0x1,%ebx
2cf5: 81 fb e8 03 00 00 cmp $0x3e8,%ebx
2cfb: 74 4b je 2d48 <forktest+0x78>
pid = fork(0);
2cfd: 83 ec 0c sub $0xc,%esp
2d00: 6a 00 push $0x0
2d02: e8 53 0c 00 00 call 395a <fork>
if(pid < 0)
2d07: 83 c4 10 add $0x10,%esp
2d0a: 85 c0 test %eax,%eax
2d0c: 79 e2 jns 2cf0 <forktest+0x20>
if(n == 1000){
printf(1, "fork claimed to work 1000 times!\n");
exit();
}
for(; n > 0; n--){
2d0e: 85 db test %ebx,%ebx
2d10: 74 14 je 2d26 <forktest+0x56>
2d12: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(wait() < 0){
2d18: e8 4d 0c 00 00 call 396a <wait>
2d1d: 85 c0 test %eax,%eax
2d1f: 78 40 js 2d61 <forktest+0x91>
if(n == 1000){
printf(1, "fork claimed to work 1000 times!\n");
exit();
}
for(; n > 0; n--){
2d21: 83 eb 01 sub $0x1,%ebx
2d24: 75 f2 jne 2d18 <forktest+0x48>
printf(1, "wait stopped early\n");
exit();
}
}
if(wait() != -1){
2d26: e8 3f 0c 00 00 call 396a <wait>
2d2b: 83 f8 ff cmp $0xffffffff,%eax
2d2e: 75 45 jne 2d75 <forktest+0xa5>
printf(1, "wait got too many\n");
exit();
}
printf(1, "fork test OK\n");
2d30: 83 ec 08 sub $0x8,%esp
2d33: 68 b3 4b 00 00 push $0x4bb3
2d38: 6a 01 push $0x1
2d3a: e8 71 0d 00 00 call 3ab0 <printf>
}
2d3f: 8b 5d fc mov -0x4(%ebp),%ebx
2d42: c9 leave
2d43: c3 ret
2d44: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(pid == 0)
exit();
}
if(n == 1000){
printf(1, "fork claimed to work 1000 times!\n");
2d48: 83 ec 08 sub $0x8,%esp
2d4b: 68 20 53 00 00 push $0x5320
2d50: 6a 01 push $0x1
2d52: e8 59 0d 00 00 call 3ab0 <printf>
exit();
2d57: e8 06 0c 00 00 call 3962 <exit>
for(n=0; n<1000; n++){
pid = fork(0);
if(pid < 0)
break;
if(pid == 0)
exit();
2d5c: e8 01 0c 00 00 call 3962 <exit>
exit();
}
for(; n > 0; n--){
if(wait() < 0){
printf(1, "wait stopped early\n");
2d61: 83 ec 08 sub $0x8,%esp
2d64: 68 8c 4b 00 00 push $0x4b8c
2d69: 6a 01 push $0x1
2d6b: e8 40 0d 00 00 call 3ab0 <printf>
exit();
2d70: e8 ed 0b 00 00 call 3962 <exit>
}
}
if(wait() != -1){
printf(1, "wait got too many\n");
2d75: 83 ec 08 sub $0x8,%esp
2d78: 68 a0 4b 00 00 push $0x4ba0
2d7d: 6a 01 push $0x1
2d7f: e8 2c 0d 00 00 call 3ab0 <printf>
exit();
2d84: e8 d9 0b 00 00 call 3962 <exit>
2d89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00002d90 <sbrktest>:
printf(1, "fork test OK\n");
}
void
sbrktest(void)
{
2d90: 55 push %ebp
2d91: 89 e5 mov %esp,%ebp
2d93: 57 push %edi
2d94: 56 push %esi
2d95: 53 push %ebx
oldbrk = sbrk(0);
// can one sbrk() less than a page?
a = sbrk(0);
int i;
for(i = 0; i < 5000; i++){
2d96: 31 ff xor %edi,%edi
printf(1, "fork test OK\n");
}
void
sbrktest(void)
{
2d98: 83 ec 64 sub $0x64,%esp
int fds[2], pid, pids[10], ppid;
char *a, *b, *c, *lastaddr, *oldbrk, *p, scratch;
uint amt;
printf(stdout, "sbrk test\n");
2d9b: 68 c1 4b 00 00 push $0x4bc1
2da0: ff 35 64 5e 00 00 pushl 0x5e64
2da6: e8 05 0d 00 00 call 3ab0 <printf>
oldbrk = sbrk(0);
2dab: c7 04 24 00 00 00 00 movl $0x0,(%esp)
2db2: e8 33 0c 00 00 call 39ea <sbrk>
// can one sbrk() less than a page?
a = sbrk(0);
2db7: c7 04 24 00 00 00 00 movl $0x0,(%esp)
int fds[2], pid, pids[10], ppid;
char *a, *b, *c, *lastaddr, *oldbrk, *p, scratch;
uint amt;
printf(stdout, "sbrk test\n");
oldbrk = sbrk(0);
2dbe: 89 45 a4 mov %eax,-0x5c(%ebp)
// can one sbrk() less than a page?
a = sbrk(0);
2dc1: e8 24 0c 00 00 call 39ea <sbrk>
2dc6: 83 c4 10 add $0x10,%esp
2dc9: 89 c3 mov %eax,%ebx
2dcb: 90 nop
2dcc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
int i;
for(i = 0; i < 5000; i++){
b = sbrk(1);
2dd0: 83 ec 0c sub $0xc,%esp
2dd3: 6a 01 push $0x1
2dd5: e8 10 0c 00 00 call 39ea <sbrk>
if(b != a){
2dda: 83 c4 10 add $0x10,%esp
2ddd: 39 d8 cmp %ebx,%eax
2ddf: 0f 85 9d 02 00 00 jne 3082 <sbrktest+0x2f2>
oldbrk = sbrk(0);
// can one sbrk() less than a page?
a = sbrk(0);
int i;
for(i = 0; i < 5000; i++){
2de5: 83 c7 01 add $0x1,%edi
b = sbrk(1);
if(b != a){
printf(stdout, "sbrk test failed %d %x %x\n", i, a, b);
exit();
}
*b = 1;
2de8: c6 03 01 movb $0x1,(%ebx)
a = b + 1;
2deb: 83 c3 01 add $0x1,%ebx
oldbrk = sbrk(0);
// can one sbrk() less than a page?
a = sbrk(0);
int i;
for(i = 0; i < 5000; i++){
2dee: 81 ff 88 13 00 00 cmp $0x1388,%edi
2df4: 75 da jne 2dd0 <sbrktest+0x40>
exit();
}
*b = 1;
a = b + 1;
}
pid = fork(0);
2df6: 83 ec 0c sub $0xc,%esp
2df9: 6a 00 push $0x0
2dfb: e8 5a 0b 00 00 call 395a <fork>
if(pid < 0){
2e00: 83 c4 10 add $0x10,%esp
2e03: 85 c0 test %eax,%eax
exit();
}
*b = 1;
a = b + 1;
}
pid = fork(0);
2e05: 89 c7 mov %eax,%edi
if(pid < 0){
2e07: 0f 88 a3 03 00 00 js 31b0 <sbrktest+0x420>
printf(stdout, "sbrk test fork failed\n");
exit();
}
c = sbrk(1);
2e0d: 83 ec 0c sub $0xc,%esp
c = sbrk(1);
if(c != a + 1){
2e10: 83 c3 01 add $0x1,%ebx
pid = fork(0);
if(pid < 0){
printf(stdout, "sbrk test fork failed\n");
exit();
}
c = sbrk(1);
2e13: 6a 01 push $0x1
2e15: e8 d0 0b 00 00 call 39ea <sbrk>
c = sbrk(1);
2e1a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
2e21: e8 c4 0b 00 00 call 39ea <sbrk>
if(c != a + 1){
2e26: 83 c4 10 add $0x10,%esp
2e29: 39 d8 cmp %ebx,%eax
2e2b: 0f 85 67 03 00 00 jne 3198 <sbrktest+0x408>
printf(stdout, "sbrk test failed post-fork\n");
exit();
}
if(pid == 0)
2e31: 85 ff test %edi,%edi
2e33: 0f 84 5a 03 00 00 je 3193 <sbrktest+0x403>
exit();
wait();
2e39: e8 2c 0b 00 00 call 396a <wait>
// can one grow address space to something big?
#define BIG (100*1024*1024)
a = sbrk(0);
2e3e: 83 ec 0c sub $0xc,%esp
2e41: 6a 00 push $0x0
2e43: e8 a2 0b 00 00 call 39ea <sbrk>
2e48: 89 c3 mov %eax,%ebx
amt = (BIG) - (uint)a;
p = sbrk(amt);
2e4a: b8 00 00 40 06 mov $0x6400000,%eax
2e4f: 29 d8 sub %ebx,%eax
2e51: 89 04 24 mov %eax,(%esp)
2e54: e8 91 0b 00 00 call 39ea <sbrk>
if (p != a) {
2e59: 83 c4 10 add $0x10,%esp
2e5c: 39 c3 cmp %eax,%ebx
2e5e: 0f 85 17 03 00 00 jne 317b <sbrktest+0x3eb>
}
lastaddr = (char*) (BIG-1);
*lastaddr = 99;
// can one de-allocate?
a = sbrk(0);
2e64: 83 ec 0c sub $0xc,%esp
if (p != a) {
printf(stdout, "sbrk test failed to grow big address space; enough phys mem?\n");
exit();
}
lastaddr = (char*) (BIG-1);
*lastaddr = 99;
2e67: c6 05 ff ff 3f 06 63 movb $0x63,0x63fffff
// can one de-allocate?
a = sbrk(0);
2e6e: 6a 00 push $0x0
2e70: e8 75 0b 00 00 call 39ea <sbrk>
c = sbrk(-4096);
2e75: c7 04 24 00 f0 ff ff movl $0xfffff000,(%esp)
}
lastaddr = (char*) (BIG-1);
*lastaddr = 99;
// can one de-allocate?
a = sbrk(0);
2e7c: 89 c3 mov %eax,%ebx
c = sbrk(-4096);
2e7e: e8 67 0b 00 00 call 39ea <sbrk>
if(c == (char*)0xffffffff){
2e83: 83 c4 10 add $0x10,%esp
2e86: 83 f8 ff cmp $0xffffffff,%eax
2e89: 0f 84 d4 02 00 00 je 3163 <sbrktest+0x3d3>
printf(stdout, "sbrk could not deallocate\n");
exit();
}
c = sbrk(0);
2e8f: 83 ec 0c sub $0xc,%esp
2e92: 6a 00 push $0x0
2e94: e8 51 0b 00 00 call 39ea <sbrk>
if(c != a - 4096){
2e99: 8d 93 00 f0 ff ff lea -0x1000(%ebx),%edx
2e9f: 83 c4 10 add $0x10,%esp
2ea2: 39 d0 cmp %edx,%eax
2ea4: 0f 85 a2 02 00 00 jne 314c <sbrktest+0x3bc>
printf(stdout, "sbrk deallocation produced wrong address, a %x c %x\n", a, c);
exit();
}
// can one re-allocate that page?
a = sbrk(0);
2eaa: 83 ec 0c sub $0xc,%esp
2ead: 6a 00 push $0x0
2eaf: e8 36 0b 00 00 call 39ea <sbrk>
2eb4: 89 c3 mov %eax,%ebx
c = sbrk(4096);
2eb6: c7 04 24 00 10 00 00 movl $0x1000,(%esp)
2ebd: e8 28 0b 00 00 call 39ea <sbrk>
if(c != a || sbrk(0) != a + 4096){
2ec2: 83 c4 10 add $0x10,%esp
2ec5: 39 c3 cmp %eax,%ebx
exit();
}
// can one re-allocate that page?
a = sbrk(0);
c = sbrk(4096);
2ec7: 89 c7 mov %eax,%edi
if(c != a || sbrk(0) != a + 4096){
2ec9: 0f 85 66 02 00 00 jne 3135 <sbrktest+0x3a5>
2ecf: 83 ec 0c sub $0xc,%esp
2ed2: 6a 00 push $0x0
2ed4: e8 11 0b 00 00 call 39ea <sbrk>
2ed9: 8d 93 00 10 00 00 lea 0x1000(%ebx),%edx
2edf: 83 c4 10 add $0x10,%esp
2ee2: 39 d0 cmp %edx,%eax
2ee4: 0f 85 4b 02 00 00 jne 3135 <sbrktest+0x3a5>
printf(stdout, "sbrk re-allocation failed, a %x c %x\n", a, c);
exit();
}
if(*lastaddr == 99){
2eea: 80 3d ff ff 3f 06 63 cmpb $0x63,0x63fffff
2ef1: 0f 84 26 02 00 00 je 311d <sbrktest+0x38d>
// should be zero
printf(stdout, "sbrk de-allocation didn't really deallocate\n");
exit();
}
a = sbrk(0);
2ef7: 83 ec 0c sub $0xc,%esp
2efa: 6a 00 push $0x0
2efc: e8 e9 0a 00 00 call 39ea <sbrk>
c = sbrk(-(sbrk(0) - oldbrk));
2f01: c7 04 24 00 00 00 00 movl $0x0,(%esp)
// should be zero
printf(stdout, "sbrk de-allocation didn't really deallocate\n");
exit();
}
a = sbrk(0);
2f08: 89 c3 mov %eax,%ebx
c = sbrk(-(sbrk(0) - oldbrk));
2f0a: e8 db 0a 00 00 call 39ea <sbrk>
2f0f: 8b 4d a4 mov -0x5c(%ebp),%ecx
2f12: 29 c1 sub %eax,%ecx
2f14: 89 0c 24 mov %ecx,(%esp)
2f17: e8 ce 0a 00 00 call 39ea <sbrk>
if(c != a){
2f1c: 83 c4 10 add $0x10,%esp
2f1f: 39 c3 cmp %eax,%ebx
2f21: 0f 85 df 01 00 00 jne 3106 <sbrktest+0x376>
2f27: bb 00 00 00 80 mov $0x80000000,%ebx
2f2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
exit();
}
// can we read the kernel's memory?
for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
ppid = getpid();
2f30: e8 ad 0a 00 00 call 39e2 <getpid>
pid = fork(0);
2f35: 83 ec 0c sub $0xc,%esp
exit();
}
// can we read the kernel's memory?
for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
ppid = getpid();
2f38: 89 c7 mov %eax,%edi
pid = fork(0);
2f3a: 6a 00 push $0x0
2f3c: e8 19 0a 00 00 call 395a <fork>
if(pid < 0){
2f41: 83 c4 10 add $0x10,%esp
2f44: 85 c0 test %eax,%eax
2f46: 0f 88 a2 01 00 00 js 30ee <sbrktest+0x35e>
printf(stdout, "fork failed\n");
exit();
}
if(pid == 0){
2f4c: 0f 84 7a 01 00 00 je 30cc <sbrktest+0x33c>
printf(stdout, "sbrk downsize failed, a %x c %x\n", a, c);
exit();
}
// can we read the kernel's memory?
for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
2f52: 81 c3 50 c3 00 00 add $0xc350,%ebx
if(pid == 0){
printf(stdout, "oops could read %x = %x\n", a, *a);
kill(ppid);
exit();
}
wait();
2f58: e8 0d 0a 00 00 call 396a <wait>
printf(stdout, "sbrk downsize failed, a %x c %x\n", a, c);
exit();
}
// can we read the kernel's memory?
for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
2f5d: 81 fb 80 84 1e 80 cmp $0x801e8480,%ebx
2f63: 75 cb jne 2f30 <sbrktest+0x1a0>
wait();
}
// if we run the system out of memory, does it clean up the last
// failed allocation?
if(pipe(fds) != 0){
2f65: 8d 45 b8 lea -0x48(%ebp),%eax
2f68: 83 ec 0c sub $0xc,%esp
2f6b: 50 push %eax
2f6c: e8 01 0a 00 00 call 3972 <pipe>
2f71: 83 c4 10 add $0x10,%esp
2f74: 85 c0 test %eax,%eax
2f76: 0f 85 3c 01 00 00 jne 30b8 <sbrktest+0x328>
2f7c: 8d 5d c0 lea -0x40(%ebp),%ebx
2f7f: 8d 7d e8 lea -0x18(%ebp),%edi
2f82: 89 de mov %ebx,%esi
printf(1, "pipe() failed\n");
exit();
}
for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
if((pids[i] = fork(0)) == 0){
2f84: 83 ec 0c sub $0xc,%esp
2f87: 6a 00 push $0x0
2f89: e8 cc 09 00 00 call 395a <fork>
2f8e: 83 c4 10 add $0x10,%esp
2f91: 85 c0 test %eax,%eax
2f93: 89 06 mov %eax,(%esi)
2f95: 0f 84 a1 00 00 00 je 303c <sbrktest+0x2ac>
sbrk(BIG - (uint)sbrk(0));
write(fds[1], "x", 1);
// sit around until killed
for(;;) sleep(1000);
}
if(pids[i] != -1)
2f9b: 83 f8 ff cmp $0xffffffff,%eax
2f9e: 74 14 je 2fb4 <sbrktest+0x224>
read(fds[0], &scratch, 1);
2fa0: 8d 45 b7 lea -0x49(%ebp),%eax
2fa3: 83 ec 04 sub $0x4,%esp
2fa6: 6a 01 push $0x1
2fa8: 50 push %eax
2fa9: ff 75 b8 pushl -0x48(%ebp)
2fac: e8 c9 09 00 00 call 397a <read>
2fb1: 83 c4 10 add $0x10,%esp
2fb4: 83 c6 04 add $0x4,%esi
// failed allocation?
if(pipe(fds) != 0){
printf(1, "pipe() failed\n");
exit();
}
for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
2fb7: 39 f7 cmp %esi,%edi
2fb9: 75 c9 jne 2f84 <sbrktest+0x1f4>
if(pids[i] != -1)
read(fds[0], &scratch, 1);
}
// if those failed allocations freed up the pages they did allocate,
// we'll be able to allocate here
c = sbrk(4096);
2fbb: 83 ec 0c sub $0xc,%esp
2fbe: 68 00 10 00 00 push $0x1000
2fc3: e8 22 0a 00 00 call 39ea <sbrk>
2fc8: 83 c4 10 add $0x10,%esp
2fcb: 89 c6 mov %eax,%esi
for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
if(pids[i] == -1)
2fcd: 8b 03 mov (%ebx),%eax
2fcf: 83 f8 ff cmp $0xffffffff,%eax
2fd2: 74 11 je 2fe5 <sbrktest+0x255>
continue;
kill(pids[i]);
2fd4: 83 ec 0c sub $0xc,%esp
2fd7: 50 push %eax
2fd8: e8 b5 09 00 00 call 3992 <kill>
wait();
2fdd: e8 88 09 00 00 call 396a <wait>
2fe2: 83 c4 10 add $0x10,%esp
2fe5: 83 c3 04 add $0x4,%ebx
read(fds[0], &scratch, 1);
}
// if those failed allocations freed up the pages they did allocate,
// we'll be able to allocate here
c = sbrk(4096);
for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
2fe8: 39 fb cmp %edi,%ebx
2fea: 75 e1 jne 2fcd <sbrktest+0x23d>
if(pids[i] == -1)
continue;
kill(pids[i]);
wait();
}
if(c == (char*)0xffffffff){
2fec: 83 fe ff cmp $0xffffffff,%esi
2fef: 0f 84 ab 00 00 00 je 30a0 <sbrktest+0x310>
printf(stdout, "failed sbrk leaked memory\n");
exit();
}
if(sbrk(0) > oldbrk)
2ff5: 83 ec 0c sub $0xc,%esp
2ff8: 6a 00 push $0x0
2ffa: e8 eb 09 00 00 call 39ea <sbrk>
2fff: 83 c4 10 add $0x10,%esp
3002: 39 45 a4 cmp %eax,-0x5c(%ebp)
3005: 73 1a jae 3021 <sbrktest+0x291>
sbrk(-(sbrk(0) - oldbrk));
3007: 83 ec 0c sub $0xc,%esp
300a: 6a 00 push $0x0
300c: e8 d9 09 00 00 call 39ea <sbrk>
3011: 8b 75 a4 mov -0x5c(%ebp),%esi
3014: 29 c6 sub %eax,%esi
3016: 89 34 24 mov %esi,(%esp)
3019: e8 cc 09 00 00 call 39ea <sbrk>
301e: 83 c4 10 add $0x10,%esp
printf(stdout, "sbrk test OK\n");
3021: 83 ec 08 sub $0x8,%esp
3024: 68 69 4c 00 00 push $0x4c69
3029: ff 35 64 5e 00 00 pushl 0x5e64
302f: e8 7c 0a 00 00 call 3ab0 <printf>
}
3034: 8d 65 f4 lea -0xc(%ebp),%esp
3037: 5b pop %ebx
3038: 5e pop %esi
3039: 5f pop %edi
303a: 5d pop %ebp
303b: c3 ret
exit();
}
for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
if((pids[i] = fork(0)) == 0){
// allocate a lot of memory
sbrk(BIG - (uint)sbrk(0));
303c: 83 ec 0c sub $0xc,%esp
303f: 6a 00 push $0x0
3041: e8 a4 09 00 00 call 39ea <sbrk>
3046: ba 00 00 40 06 mov $0x6400000,%edx
304b: 29 c2 sub %eax,%edx
304d: 89 14 24 mov %edx,(%esp)
3050: e8 95 09 00 00 call 39ea <sbrk>
write(fds[1], "x", 1);
3055: 83 c4 0c add $0xc,%esp
3058: 6a 01 push $0x1
305a: 68 2a 47 00 00 push $0x472a
305f: ff 75 bc pushl -0x44(%ebp)
3062: e8 1b 09 00 00 call 3982 <write>
3067: 83 c4 10 add $0x10,%esp
306a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
// sit around until killed
for(;;) sleep(1000);
3070: 83 ec 0c sub $0xc,%esp
3073: 68 e8 03 00 00 push $0x3e8
3078: e8 75 09 00 00 call 39f2 <sleep>
307d: 83 c4 10 add $0x10,%esp
3080: eb ee jmp 3070 <sbrktest+0x2e0>
a = sbrk(0);
int i;
for(i = 0; i < 5000; i++){
b = sbrk(1);
if(b != a){
printf(stdout, "sbrk test failed %d %x %x\n", i, a, b);
3082: 83 ec 0c sub $0xc,%esp
3085: 50 push %eax
3086: 53 push %ebx
3087: 57 push %edi
3088: 68 cc 4b 00 00 push $0x4bcc
308d: ff 35 64 5e 00 00 pushl 0x5e64
3093: e8 18 0a 00 00 call 3ab0 <printf>
exit();
3098: 83 c4 20 add $0x20,%esp
309b: e8 c2 08 00 00 call 3962 <exit>
continue;
kill(pids[i]);
wait();
}
if(c == (char*)0xffffffff){
printf(stdout, "failed sbrk leaked memory\n");
30a0: 83 ec 08 sub $0x8,%esp
30a3: 68 4e 4c 00 00 push $0x4c4e
30a8: ff 35 64 5e 00 00 pushl 0x5e64
30ae: e8 fd 09 00 00 call 3ab0 <printf>
exit();
30b3: e8 aa 08 00 00 call 3962 <exit>
}
// if we run the system out of memory, does it clean up the last
// failed allocation?
if(pipe(fds) != 0){
printf(1, "pipe() failed\n");
30b8: 83 ec 08 sub $0x8,%esp
30bb: 68 09 41 00 00 push $0x4109
30c0: 6a 01 push $0x1
30c2: e8 e9 09 00 00 call 3ab0 <printf>
exit();
30c7: e8 96 08 00 00 call 3962 <exit>
if(pid < 0){
printf(stdout, "fork failed\n");
exit();
}
if(pid == 0){
printf(stdout, "oops could read %x = %x\n", a, *a);
30cc: 0f be 03 movsbl (%ebx),%eax
30cf: 50 push %eax
30d0: 53 push %ebx
30d1: 68 35 4c 00 00 push $0x4c35
30d6: ff 35 64 5e 00 00 pushl 0x5e64
30dc: e8 cf 09 00 00 call 3ab0 <printf>
kill(ppid);
30e1: 89 3c 24 mov %edi,(%esp)
30e4: e8 a9 08 00 00 call 3992 <kill>
exit();
30e9: e8 74 08 00 00 call 3962 <exit>
// can we read the kernel's memory?
for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
ppid = getpid();
pid = fork(0);
if(pid < 0){
printf(stdout, "fork failed\n");
30ee: 83 ec 08 sub $0x8,%esp
30f1: 68 12 4d 00 00 push $0x4d12
30f6: ff 35 64 5e 00 00 pushl 0x5e64
30fc: e8 af 09 00 00 call 3ab0 <printf>
exit();
3101: e8 5c 08 00 00 call 3962 <exit>
}
a = sbrk(0);
c = sbrk(-(sbrk(0) - oldbrk));
if(c != a){
printf(stdout, "sbrk downsize failed, a %x c %x\n", a, c);
3106: 50 push %eax
3107: 53 push %ebx
3108: 68 14 54 00 00 push $0x5414
310d: ff 35 64 5e 00 00 pushl 0x5e64
3113: e8 98 09 00 00 call 3ab0 <printf>
exit();
3118: e8 45 08 00 00 call 3962 <exit>
printf(stdout, "sbrk re-allocation failed, a %x c %x\n", a, c);
exit();
}
if(*lastaddr == 99){
// should be zero
printf(stdout, "sbrk de-allocation didn't really deallocate\n");
311d: 83 ec 08 sub $0x8,%esp
3120: 68 e4 53 00 00 push $0x53e4
3125: ff 35 64 5e 00 00 pushl 0x5e64
312b: e8 80 09 00 00 call 3ab0 <printf>
exit();
3130: e8 2d 08 00 00 call 3962 <exit>
// can one re-allocate that page?
a = sbrk(0);
c = sbrk(4096);
if(c != a || sbrk(0) != a + 4096){
printf(stdout, "sbrk re-allocation failed, a %x c %x\n", a, c);
3135: 57 push %edi
3136: 53 push %ebx
3137: 68 bc 53 00 00 push $0x53bc
313c: ff 35 64 5e 00 00 pushl 0x5e64
3142: e8 69 09 00 00 call 3ab0 <printf>
exit();
3147: e8 16 08 00 00 call 3962 <exit>
printf(stdout, "sbrk could not deallocate\n");
exit();
}
c = sbrk(0);
if(c != a - 4096){
printf(stdout, "sbrk deallocation produced wrong address, a %x c %x\n", a, c);
314c: 50 push %eax
314d: 53 push %ebx
314e: 68 84 53 00 00 push $0x5384
3153: ff 35 64 5e 00 00 pushl 0x5e64
3159: e8 52 09 00 00 call 3ab0 <printf>
exit();
315e: e8 ff 07 00 00 call 3962 <exit>
// can one de-allocate?
a = sbrk(0);
c = sbrk(-4096);
if(c == (char*)0xffffffff){
printf(stdout, "sbrk could not deallocate\n");
3163: 83 ec 08 sub $0x8,%esp
3166: 68 1a 4c 00 00 push $0x4c1a
316b: ff 35 64 5e 00 00 pushl 0x5e64
3171: e8 3a 09 00 00 call 3ab0 <printf>
exit();
3176: e8 e7 07 00 00 call 3962 <exit>
#define BIG (100*1024*1024)
a = sbrk(0);
amt = (BIG) - (uint)a;
p = sbrk(amt);
if (p != a) {
printf(stdout, "sbrk test failed to grow big address space; enough phys mem?\n");
317b: 83 ec 08 sub $0x8,%esp
317e: 68 44 53 00 00 push $0x5344
3183: ff 35 64 5e 00 00 pushl 0x5e64
3189: e8 22 09 00 00 call 3ab0 <printf>
exit();
318e: e8 cf 07 00 00 call 3962 <exit>
if(c != a + 1){
printf(stdout, "sbrk test failed post-fork\n");
exit();
}
if(pid == 0)
exit();
3193: e8 ca 07 00 00 call 3962 <exit>
exit();
}
c = sbrk(1);
c = sbrk(1);
if(c != a + 1){
printf(stdout, "sbrk test failed post-fork\n");
3198: 83 ec 08 sub $0x8,%esp
319b: 68 fe 4b 00 00 push $0x4bfe
31a0: ff 35 64 5e 00 00 pushl 0x5e64
31a6: e8 05 09 00 00 call 3ab0 <printf>
exit();
31ab: e8 b2 07 00 00 call 3962 <exit>
*b = 1;
a = b + 1;
}
pid = fork(0);
if(pid < 0){
printf(stdout, "sbrk test fork failed\n");
31b0: 83 ec 08 sub $0x8,%esp
31b3: 68 e7 4b 00 00 push $0x4be7
31b8: ff 35 64 5e 00 00 pushl 0x5e64
31be: e8 ed 08 00 00 call 3ab0 <printf>
exit();
31c3: e8 9a 07 00 00 call 3962 <exit>
31c8: 90 nop
31c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000031d0 <validateint>:
printf(stdout, "sbrk test OK\n");
}
void
validateint(int *p)
{
31d0: 55 push %ebp
31d1: 89 e5 mov %esp,%ebp
"int %2\n\t"
"mov %%ebx, %%esp" :
"=a" (res) :
"a" (SYS_sleep), "n" (T_SYSCALL), "c" (p) :
"ebx");
}
31d3: 5d pop %ebp
31d4: c3 ret
31d5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
31d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000031e0 <validatetest>:
void
validatetest(void)
{
31e0: 55 push %ebp
31e1: 89 e5 mov %esp,%ebp
31e3: 56 push %esi
31e4: 53 push %ebx
uint p;
printf(stdout, "validate test\n");
hi = 1100*1024;
for(p = 0; p <= (uint)hi; p += 4096){
31e5: 31 db xor %ebx,%ebx
validatetest(void)
{
int hi, pid;
uint p;
printf(stdout, "validate test\n");
31e7: 83 ec 08 sub $0x8,%esp
31ea: 68 77 4c 00 00 push $0x4c77
31ef: ff 35 64 5e 00 00 pushl 0x5e64
31f5: e8 b6 08 00 00 call 3ab0 <printf>
31fa: 83 c4 10 add $0x10,%esp
31fd: 8d 76 00 lea 0x0(%esi),%esi
hi = 1100*1024;
for(p = 0; p <= (uint)hi; p += 4096){
if((pid = fork(0)) == 0){
3200: 83 ec 0c sub $0xc,%esp
3203: 6a 00 push $0x0
3205: e8 50 07 00 00 call 395a <fork>
320a: 83 c4 10 add $0x10,%esp
320d: 85 c0 test %eax,%eax
320f: 89 c6 mov %eax,%esi
3211: 74 63 je 3276 <validatetest+0x96>
// try to crash the kernel by passing in a badly placed integer
validateint((int*)p);
exit();
}
sleep(0);
3213: 83 ec 0c sub $0xc,%esp
3216: 6a 00 push $0x0
3218: e8 d5 07 00 00 call 39f2 <sleep>
sleep(0);
321d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
3224: e8 c9 07 00 00 call 39f2 <sleep>
kill(pid);
3229: 89 34 24 mov %esi,(%esp)
322c: e8 61 07 00 00 call 3992 <kill>
wait();
3231: e8 34 07 00 00 call 396a <wait>
// try to crash the kernel by passing in a bad string pointer
if(link("nosuchfile", (char*)p) != -1){
3236: 58 pop %eax
3237: 5a pop %edx
3238: 53 push %ebx
3239: 68 86 4c 00 00 push $0x4c86
323e: e8 7f 07 00 00 call 39c2 <link>
3243: 83 c4 10 add $0x10,%esp
3246: 83 f8 ff cmp $0xffffffff,%eax
3249: 75 30 jne 327b <validatetest+0x9b>
uint p;
printf(stdout, "validate test\n");
hi = 1100*1024;
for(p = 0; p <= (uint)hi; p += 4096){
324b: 81 c3 00 10 00 00 add $0x1000,%ebx
3251: 81 fb 00 40 11 00 cmp $0x114000,%ebx
3257: 75 a7 jne 3200 <validatetest+0x20>
printf(stdout, "link should not succeed\n");
exit();
}
}
printf(stdout, "validate ok\n");
3259: 83 ec 08 sub $0x8,%esp
325c: 68 aa 4c 00 00 push $0x4caa
3261: ff 35 64 5e 00 00 pushl 0x5e64
3267: e8 44 08 00 00 call 3ab0 <printf>
}
326c: 83 c4 10 add $0x10,%esp
326f: 8d 65 f8 lea -0x8(%ebp),%esp
3272: 5b pop %ebx
3273: 5e pop %esi
3274: 5d pop %ebp
3275: c3 ret
for(p = 0; p <= (uint)hi; p += 4096){
if((pid = fork(0)) == 0){
// try to crash the kernel by passing in a badly placed integer
validateint((int*)p);
exit();
3276: e8 e7 06 00 00 call 3962 <exit>
kill(pid);
wait();
// try to crash the kernel by passing in a bad string pointer
if(link("nosuchfile", (char*)p) != -1){
printf(stdout, "link should not succeed\n");
327b: 83 ec 08 sub $0x8,%esp
327e: 68 91 4c 00 00 push $0x4c91
3283: ff 35 64 5e 00 00 pushl 0x5e64
3289: e8 22 08 00 00 call 3ab0 <printf>
exit();
328e: e8 cf 06 00 00 call 3962 <exit>
3293: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
3299: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000032a0 <bsstest>:
// does unintialized data start out zero?
char uninit[10000];
void
bsstest(void)
{
32a0: 55 push %ebp
32a1: 89 e5 mov %esp,%ebp
32a3: 83 ec 10 sub $0x10,%esp
int i;
printf(stdout, "bss test\n");
32a6: 68 b7 4c 00 00 push $0x4cb7
32ab: ff 35 64 5e 00 00 pushl 0x5e64
32b1: e8 fa 07 00 00 call 3ab0 <printf>
for(i = 0; i < sizeof(uninit); i++){
if(uninit[i] != '\0'){
32b6: 83 c4 10 add $0x10,%esp
32b9: 80 3d 20 5f 00 00 00 cmpb $0x0,0x5f20
32c0: 75 35 jne 32f7 <bsstest+0x57>
32c2: b8 21 5f 00 00 mov $0x5f21,%eax
32c7: 89 f6 mov %esi,%esi
32c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
32d0: 80 38 00 cmpb $0x0,(%eax)
32d3: 75 22 jne 32f7 <bsstest+0x57>
32d5: 83 c0 01 add $0x1,%eax
bsstest(void)
{
int i;
printf(stdout, "bss test\n");
for(i = 0; i < sizeof(uninit); i++){
32d8: 3d 30 86 00 00 cmp $0x8630,%eax
32dd: 75 f1 jne 32d0 <bsstest+0x30>
if(uninit[i] != '\0'){
printf(stdout, "bss test failed\n");
exit();
}
}
printf(stdout, "bss test ok\n");
32df: 83 ec 08 sub $0x8,%esp
32e2: 68 d2 4c 00 00 push $0x4cd2
32e7: ff 35 64 5e 00 00 pushl 0x5e64
32ed: e8 be 07 00 00 call 3ab0 <printf>
}
32f2: 83 c4 10 add $0x10,%esp
32f5: c9 leave
32f6: c3 ret
int i;
printf(stdout, "bss test\n");
for(i = 0; i < sizeof(uninit); i++){
if(uninit[i] != '\0'){
printf(stdout, "bss test failed\n");
32f7: 83 ec 08 sub $0x8,%esp
32fa: 68 c1 4c 00 00 push $0x4cc1
32ff: ff 35 64 5e 00 00 pushl 0x5e64
3305: e8 a6 07 00 00 call 3ab0 <printf>
exit();
330a: e8 53 06 00 00 call 3962 <exit>
330f: 90 nop
00003310 <bigargtest>:
// does exec return an error if the arguments
// are larger than a page? or does it write
// below the stack and wreck the instructions/data?
void
bigargtest(void)
{
3310: 55 push %ebp
3311: 89 e5 mov %esp,%ebp
3313: 83 ec 14 sub $0x14,%esp
int pid, fd;
unlink("bigarg-ok");
3316: 68 df 4c 00 00 push $0x4cdf
331b: e8 92 06 00 00 call 39b2 <unlink>
pid = fork(0);
3320: c7 04 24 00 00 00 00 movl $0x0,(%esp)
3327: e8 2e 06 00 00 call 395a <fork>
if(pid == 0){
332c: 83 c4 10 add $0x10,%esp
332f: 85 c0 test %eax,%eax
3331: 74 3f je 3372 <bigargtest+0x62>
exec("echo", args);
printf(stdout, "bigarg test ok\n");
fd = open("bigarg-ok", O_CREATE);
close(fd);
exit();
} else if(pid < 0){
3333: 0f 88 cb 00 00 00 js 3404 <bigargtest+0xf4>
printf(stdout, "bigargtest: fork failed\n");
exit();
}
wait();
3339: e8 2c 06 00 00 call 396a <wait>
fd = open("bigarg-ok", 0);
333e: 83 ec 08 sub $0x8,%esp
3341: 6a 00 push $0x0
3343: 68 df 4c 00 00 push $0x4cdf
3348: e8 55 06 00 00 call 39a2 <open>
if(fd < 0){
334d: 83 c4 10 add $0x10,%esp
3350: 85 c0 test %eax,%eax
3352: 0f 88 95 00 00 00 js 33ed <bigargtest+0xdd>
printf(stdout, "bigarg test failed!\n");
exit();
}
close(fd);
3358: 83 ec 0c sub $0xc,%esp
335b: 50 push %eax
335c: e8 29 06 00 00 call 398a <close>
unlink("bigarg-ok");
3361: c7 04 24 df 4c 00 00 movl $0x4cdf,(%esp)
3368: e8 45 06 00 00 call 39b2 <unlink>
}
336d: 83 c4 10 add $0x10,%esp
3370: c9 leave
3371: c3 ret
3372: b8 80 5e 00 00 mov $0x5e80,%eax
3377: 89 f6 mov %esi,%esi
3379: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
pid = fork(0);
if(pid == 0){
static char *args[MAXARG];
int i;
for(i = 0; i < MAXARG-1; i++)
args[i] = "bigargs test: failed\n ";
3380: c7 00 38 54 00 00 movl $0x5438,(%eax)
3386: 83 c0 04 add $0x4,%eax
unlink("bigarg-ok");
pid = fork(0);
if(pid == 0){
static char *args[MAXARG];
int i;
for(i = 0; i < MAXARG-1; i++)
3389: 3d fc 5e 00 00 cmp $0x5efc,%eax
338e: 75 f0 jne 3380 <bigargtest+0x70>
args[i] = "bigargs test: failed\n ";
args[MAXARG-1] = 0;
printf(stdout, "bigarg test\n");
3390: 51 push %ecx
3391: 51 push %ecx
3392: 68 e9 4c 00 00 push $0x4ce9
3397: ff 35 64 5e 00 00 pushl 0x5e64
if(pid == 0){
static char *args[MAXARG];
int i;
for(i = 0; i < MAXARG-1; i++)
args[i] = "bigargs test: failed\n ";
args[MAXARG-1] = 0;
339d: c7 05 fc 5e 00 00 00 movl $0x0,0x5efc
33a4: 00 00 00
printf(stdout, "bigarg test\n");
33a7: e8 04 07 00 00 call 3ab0 <printf>
exec("echo", args);
33ac: 58 pop %eax
33ad: 5a pop %edx
33ae: 68 80 5e 00 00 push $0x5e80
33b3: 68 b5 3e 00 00 push $0x3eb5
33b8: e8 dd 05 00 00 call 399a <exec>
printf(stdout, "bigarg test ok\n");
33bd: 59 pop %ecx
33be: 58 pop %eax
33bf: 68 f6 4c 00 00 push $0x4cf6
33c4: ff 35 64 5e 00 00 pushl 0x5e64
33ca: e8 e1 06 00 00 call 3ab0 <printf>
fd = open("bigarg-ok", O_CREATE);
33cf: 58 pop %eax
33d0: 5a pop %edx
33d1: 68 00 02 00 00 push $0x200
33d6: 68 df 4c 00 00 push $0x4cdf
33db: e8 c2 05 00 00 call 39a2 <open>
close(fd);
33e0: 89 04 24 mov %eax,(%esp)
33e3: e8 a2 05 00 00 call 398a <close>
exit();
33e8: e8 75 05 00 00 call 3962 <exit>
exit();
}
wait();
fd = open("bigarg-ok", 0);
if(fd < 0){
printf(stdout, "bigarg test failed!\n");
33ed: 50 push %eax
33ee: 50 push %eax
33ef: 68 1f 4d 00 00 push $0x4d1f
33f4: ff 35 64 5e 00 00 pushl 0x5e64
33fa: e8 b1 06 00 00 call 3ab0 <printf>
exit();
33ff: e8 5e 05 00 00 call 3962 <exit>
printf(stdout, "bigarg test ok\n");
fd = open("bigarg-ok", O_CREATE);
close(fd);
exit();
} else if(pid < 0){
printf(stdout, "bigargtest: fork failed\n");
3404: 52 push %edx
3405: 52 push %edx
3406: 68 06 4d 00 00 push $0x4d06
340b: ff 35 64 5e 00 00 pushl 0x5e64
3411: e8 9a 06 00 00 call 3ab0 <printf>
exit();
3416: e8 47 05 00 00 call 3962 <exit>
341b: 90 nop
341c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00003420 <fsfull>:
// what happens when the file system runs out of blocks?
// answer: balloc panics, so this test is not useful.
void
fsfull()
{
3420: 55 push %ebp
3421: 89 e5 mov %esp,%ebp
3423: 57 push %edi
3424: 56 push %esi
3425: 53 push %ebx
int nfiles;
int fsblocks = 0;
printf(1, "fsfull test\n");
for(nfiles = 0; ; nfiles++){
3426: 31 db xor %ebx,%ebx
// what happens when the file system runs out of blocks?
// answer: balloc panics, so this test is not useful.
void
fsfull()
{
3428: 83 ec 54 sub $0x54,%esp
int nfiles;
int fsblocks = 0;
printf(1, "fsfull test\n");
342b: 68 34 4d 00 00 push $0x4d34
3430: 6a 01 push $0x1
3432: e8 79 06 00 00 call 3ab0 <printf>
3437: 83 c4 10 add $0x10,%esp
343a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
3440: b8 d3 4d 62 10 mov $0x10624dd3,%eax
3445: 89 de mov %ebx,%esi
name[2] = '0' + (nfiles % 1000) / 100;
3447: 89 d9 mov %ebx,%ecx
printf(1, "fsfull test\n");
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
3449: f7 eb imul %ebx
344b: c1 fe 1f sar $0x1f,%esi
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
344e: 89 df mov %ebx,%edi
name[4] = '0' + (nfiles % 10);
name[5] = '\0';
printf(1, "writing %s\n", name);
3450: 83 ec 04 sub $0x4,%esp
printf(1, "fsfull test\n");
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
3453: c6 45 a8 66 movb $0x66,-0x58(%ebp)
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
name[4] = '0' + (nfiles % 10);
name[5] = '\0';
3457: c6 45 ad 00 movb $0x0,-0x53(%ebp)
printf(1, "fsfull test\n");
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
345b: c1 fa 06 sar $0x6,%edx
345e: 29 f2 sub %esi,%edx
3460: 8d 42 30 lea 0x30(%edx),%eax
name[2] = '0' + (nfiles % 1000) / 100;
3463: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
printf(1, "fsfull test\n");
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
3469: 88 45 a9 mov %al,-0x57(%ebp)
name[2] = '0' + (nfiles % 1000) / 100;
346c: b8 1f 85 eb 51 mov $0x51eb851f,%eax
3471: 29 d1 sub %edx,%ecx
3473: f7 e9 imul %ecx
3475: c1 f9 1f sar $0x1f,%ecx
name[3] = '0' + (nfiles % 100) / 10;
3478: b8 1f 85 eb 51 mov $0x51eb851f,%eax
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
347d: c1 fa 05 sar $0x5,%edx
3480: 29 ca sub %ecx,%edx
name[3] = '0' + (nfiles % 100) / 10;
3482: b9 67 66 66 66 mov $0x66666667,%ecx
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
3487: 83 c2 30 add $0x30,%edx
348a: 88 55 aa mov %dl,-0x56(%ebp)
name[3] = '0' + (nfiles % 100) / 10;
348d: f7 eb imul %ebx
348f: c1 fa 05 sar $0x5,%edx
3492: 29 f2 sub %esi,%edx
3494: 6b d2 64 imul $0x64,%edx,%edx
3497: 29 d7 sub %edx,%edi
3499: 89 f8 mov %edi,%eax
349b: c1 ff 1f sar $0x1f,%edi
349e: f7 e9 imul %ecx
name[4] = '0' + (nfiles % 10);
34a0: 89 d8 mov %ebx,%eax
for(nfiles = 0; ; nfiles++){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
34a2: c1 fa 02 sar $0x2,%edx
34a5: 29 fa sub %edi,%edx
34a7: 83 c2 30 add $0x30,%edx
34aa: 88 55 ab mov %dl,-0x55(%ebp)
name[4] = '0' + (nfiles % 10);
34ad: f7 e9 imul %ecx
34af: 89 d9 mov %ebx,%ecx
34b1: c1 fa 02 sar $0x2,%edx
34b4: 29 f2 sub %esi,%edx
34b6: 8d 04 92 lea (%edx,%edx,4),%eax
34b9: 01 c0 add %eax,%eax
34bb: 29 c1 sub %eax,%ecx
34bd: 89 c8 mov %ecx,%eax
34bf: 83 c0 30 add $0x30,%eax
34c2: 88 45 ac mov %al,-0x54(%ebp)
name[5] = '\0';
printf(1, "writing %s\n", name);
34c5: 8d 45 a8 lea -0x58(%ebp),%eax
34c8: 50 push %eax
34c9: 68 41 4d 00 00 push $0x4d41
34ce: 6a 01 push $0x1
34d0: e8 db 05 00 00 call 3ab0 <printf>
int fd = open(name, O_CREATE|O_RDWR);
34d5: 58 pop %eax
34d6: 8d 45 a8 lea -0x58(%ebp),%eax
34d9: 5a pop %edx
34da: 68 02 02 00 00 push $0x202
34df: 50 push %eax
34e0: e8 bd 04 00 00 call 39a2 <open>
if(fd < 0){
34e5: 83 c4 10 add $0x10,%esp
34e8: 85 c0 test %eax,%eax
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
name[4] = '0' + (nfiles % 10);
name[5] = '\0';
printf(1, "writing %s\n", name);
int fd = open(name, O_CREATE|O_RDWR);
34ea: 89 c7 mov %eax,%edi
if(fd < 0){
34ec: 78 50 js 353e <fsfull+0x11e>
34ee: 31 f6 xor %esi,%esi
34f0: eb 08 jmp 34fa <fsfull+0xda>
34f2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
int total = 0;
while(1){
int cc = write(fd, buf, 512);
if(cc < 512)
break;
total += cc;
34f8: 01 c6 add %eax,%esi
printf(1, "open %s failed\n", name);
break;
}
int total = 0;
while(1){
int cc = write(fd, buf, 512);
34fa: 83 ec 04 sub $0x4,%esp
34fd: 68 00 02 00 00 push $0x200
3502: 68 40 86 00 00 push $0x8640
3507: 57 push %edi
3508: e8 75 04 00 00 call 3982 <write>
if(cc < 512)
350d: 83 c4 10 add $0x10,%esp
3510: 3d ff 01 00 00 cmp $0x1ff,%eax
3515: 7f e1 jg 34f8 <fsfull+0xd8>
break;
total += cc;
fsblocks++;
}
printf(1, "wrote %d bytes\n", total);
3517: 83 ec 04 sub $0x4,%esp
351a: 56 push %esi
351b: 68 5d 4d 00 00 push $0x4d5d
3520: 6a 01 push $0x1
3522: e8 89 05 00 00 call 3ab0 <printf>
close(fd);
3527: 89 3c 24 mov %edi,(%esp)
352a: e8 5b 04 00 00 call 398a <close>
if(total == 0)
352f: 83 c4 10 add $0x10,%esp
3532: 85 f6 test %esi,%esi
3534: 74 22 je 3558 <fsfull+0x138>
int nfiles;
int fsblocks = 0;
printf(1, "fsfull test\n");
for(nfiles = 0; ; nfiles++){
3536: 83 c3 01 add $0x1,%ebx
}
printf(1, "wrote %d bytes\n", total);
close(fd);
if(total == 0)
break;
}
3539: e9 02 ff ff ff jmp 3440 <fsfull+0x20>
name[4] = '0' + (nfiles % 10);
name[5] = '\0';
printf(1, "writing %s\n", name);
int fd = open(name, O_CREATE|O_RDWR);
if(fd < 0){
printf(1, "open %s failed\n", name);
353e: 8d 45 a8 lea -0x58(%ebp),%eax
3541: 83 ec 04 sub $0x4,%esp
3544: 50 push %eax
3545: 68 4d 4d 00 00 push $0x4d4d
354a: 6a 01 push $0x1
354c: e8 5f 05 00 00 call 3ab0 <printf>
break;
3551: 83 c4 10 add $0x10,%esp
3554: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
while(nfiles >= 0){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
3558: b8 d3 4d 62 10 mov $0x10624dd3,%eax
355d: 89 de mov %ebx,%esi
name[2] = '0' + (nfiles % 1000) / 100;
355f: 89 d9 mov %ebx,%ecx
}
while(nfiles >= 0){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
3561: f7 eb imul %ebx
3563: c1 fe 1f sar $0x1f,%esi
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
3566: 89 df mov %ebx,%edi
name[4] = '0' + (nfiles % 10);
name[5] = '\0';
unlink(name);
3568: 83 ec 0c sub $0xc,%esp
break;
}
while(nfiles >= 0){
char name[64];
name[0] = 'f';
356b: c6 45 a8 66 movb $0x66,-0x58(%ebp)
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
name[4] = '0' + (nfiles % 10);
name[5] = '\0';
356f: c6 45 ad 00 movb $0x0,-0x53(%ebp)
}
while(nfiles >= 0){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
3573: c1 fa 06 sar $0x6,%edx
3576: 29 f2 sub %esi,%edx
3578: 8d 42 30 lea 0x30(%edx),%eax
name[2] = '0' + (nfiles % 1000) / 100;
357b: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
}
while(nfiles >= 0){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
3581: 88 45 a9 mov %al,-0x57(%ebp)
name[2] = '0' + (nfiles % 1000) / 100;
3584: b8 1f 85 eb 51 mov $0x51eb851f,%eax
3589: 29 d1 sub %edx,%ecx
358b: f7 e9 imul %ecx
358d: c1 f9 1f sar $0x1f,%ecx
name[3] = '0' + (nfiles % 100) / 10;
3590: b8 1f 85 eb 51 mov $0x51eb851f,%eax
while(nfiles >= 0){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
3595: c1 fa 05 sar $0x5,%edx
3598: 29 ca sub %ecx,%edx
name[3] = '0' + (nfiles % 100) / 10;
359a: b9 67 66 66 66 mov $0x66666667,%ecx
while(nfiles >= 0){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
359f: 83 c2 30 add $0x30,%edx
35a2: 88 55 aa mov %dl,-0x56(%ebp)
name[3] = '0' + (nfiles % 100) / 10;
35a5: f7 eb imul %ebx
35a7: c1 fa 05 sar $0x5,%edx
35aa: 29 f2 sub %esi,%edx
35ac: 6b d2 64 imul $0x64,%edx,%edx
35af: 29 d7 sub %edx,%edi
35b1: 89 f8 mov %edi,%eax
35b3: c1 ff 1f sar $0x1f,%edi
35b6: f7 e9 imul %ecx
name[4] = '0' + (nfiles % 10);
35b8: 89 d8 mov %ebx,%eax
while(nfiles >= 0){
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
35ba: c1 fa 02 sar $0x2,%edx
35bd: 29 fa sub %edi,%edx
35bf: 83 c2 30 add $0x30,%edx
35c2: 88 55 ab mov %dl,-0x55(%ebp)
name[4] = '0' + (nfiles % 10);
35c5: f7 e9 imul %ecx
35c7: 89 d9 mov %ebx,%ecx
name[5] = '\0';
unlink(name);
nfiles--;
35c9: 83 eb 01 sub $0x1,%ebx
char name[64];
name[0] = 'f';
name[1] = '0' + nfiles / 1000;
name[2] = '0' + (nfiles % 1000) / 100;
name[3] = '0' + (nfiles % 100) / 10;
name[4] = '0' + (nfiles % 10);
35cc: c1 fa 02 sar $0x2,%edx
35cf: 29 f2 sub %esi,%edx
35d1: 8d 04 92 lea (%edx,%edx,4),%eax
35d4: 01 c0 add %eax,%eax
35d6: 29 c1 sub %eax,%ecx
35d8: 89 c8 mov %ecx,%eax
35da: 83 c0 30 add $0x30,%eax
35dd: 88 45 ac mov %al,-0x54(%ebp)
name[5] = '\0';
unlink(name);
35e0: 8d 45 a8 lea -0x58(%ebp),%eax
35e3: 50 push %eax
35e4: e8 c9 03 00 00 call 39b2 <unlink>
close(fd);
if(total == 0)
break;
}
while(nfiles >= 0){
35e9: 83 c4 10 add $0x10,%esp
35ec: 83 fb ff cmp $0xffffffff,%ebx
35ef: 0f 85 63 ff ff ff jne 3558 <fsfull+0x138>
name[5] = '\0';
unlink(name);
nfiles--;
}
printf(1, "fsfull test finished\n");
35f5: 83 ec 08 sub $0x8,%esp
35f8: 68 6d 4d 00 00 push $0x4d6d
35fd: 6a 01 push $0x1
35ff: e8 ac 04 00 00 call 3ab0 <printf>
}
3604: 83 c4 10 add $0x10,%esp
3607: 8d 65 f4 lea -0xc(%ebp),%esp
360a: 5b pop %ebx
360b: 5e pop %esi
360c: 5f pop %edi
360d: 5d pop %ebp
360e: c3 ret
360f: 90 nop
00003610 <uio>:
void
uio()
{
3610: 55 push %ebp
3611: 89 e5 mov %esp,%ebp
3613: 83 ec 10 sub $0x10,%esp
ushort port = 0;
uchar val = 0;
int pid;
printf(1, "uio test\n");
3616: 68 83 4d 00 00 push $0x4d83
361b: 6a 01 push $0x1
361d: e8 8e 04 00 00 call 3ab0 <printf>
pid = fork(0);
3622: c7 04 24 00 00 00 00 movl $0x0,(%esp)
3629: e8 2c 03 00 00 call 395a <fork>
if(pid == 0){
362e: 83 c4 10 add $0x10,%esp
3631: 85 c0 test %eax,%eax
3633: 74 1b je 3650 <uio+0x40>
asm volatile("outb %0,%1"::"a"(val), "d" (port));
port = RTC_DATA;
asm volatile("inb %1,%0" : "=a" (val) : "d" (port));
printf(1, "uio: uio succeeded; test FAILED\n");
exit();
} else if(pid < 0){
3635: 78 3d js 3674 <uio+0x64>
printf (1, "fork failed\n");
exit();
}
wait();
3637: e8 2e 03 00 00 call 396a <wait>
printf(1, "uio test done\n");
363c: 83 ec 08 sub $0x8,%esp
363f: 68 8d 4d 00 00 push $0x4d8d
3644: 6a 01 push $0x1
3646: e8 65 04 00 00 call 3ab0 <printf>
}
364b: 83 c4 10 add $0x10,%esp
364e: c9 leave
364f: c3 ret
pid = fork(0);
if(pid == 0){
port = RTC_ADDR;
val = 0x09; /* year */
/* http://wiki.osdev.org/Inline_Assembly/Examples */
asm volatile("outb %0,%1"::"a"(val), "d" (port));
3650: ba 70 00 00 00 mov $0x70,%edx
3655: b8 09 00 00 00 mov $0x9,%eax
365a: ee out %al,(%dx)
port = RTC_DATA;
asm volatile("inb %1,%0" : "=a" (val) : "d" (port));
365b: ba 71 00 00 00 mov $0x71,%edx
3660: ec in (%dx),%al
printf(1, "uio: uio succeeded; test FAILED\n");
3661: 52 push %edx
3662: 52 push %edx
3663: 68 18 55 00 00 push $0x5518
3668: 6a 01 push $0x1
366a: e8 41 04 00 00 call 3ab0 <printf>
exit();
366f: e8 ee 02 00 00 call 3962 <exit>
} else if(pid < 0){
printf (1, "fork failed\n");
3674: 50 push %eax
3675: 50 push %eax
3676: 68 12 4d 00 00 push $0x4d12
367b: 6a 01 push $0x1
367d: e8 2e 04 00 00 call 3ab0 <printf>
exit();
3682: e8 db 02 00 00 call 3962 <exit>
3687: 89 f6 mov %esi,%esi
3689: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00003690 <argptest>:
wait();
printf(1, "uio test done\n");
}
void argptest()
{
3690: 55 push %ebp
3691: 89 e5 mov %esp,%ebp
3693: 53 push %ebx
3694: 83 ec 0c sub $0xc,%esp
int fd;
fd = open("init", O_RDONLY);
3697: 6a 00 push $0x0
3699: 68 9c 4d 00 00 push $0x4d9c
369e: e8 ff 02 00 00 call 39a2 <open>
if (fd < 0) {
36a3: 83 c4 10 add $0x10,%esp
36a6: 85 c0 test %eax,%eax
36a8: 78 39 js 36e3 <argptest+0x53>
printf(2, "open failed\n");
exit();
}
read(fd, sbrk(0) - 1, -1);
36aa: 83 ec 0c sub $0xc,%esp
36ad: 89 c3 mov %eax,%ebx
36af: 6a 00 push $0x0
36b1: e8 34 03 00 00 call 39ea <sbrk>
36b6: 83 c4 0c add $0xc,%esp
36b9: 83 e8 01 sub $0x1,%eax
36bc: 6a ff push $0xffffffff
36be: 50 push %eax
36bf: 53 push %ebx
36c0: e8 b5 02 00 00 call 397a <read>
close(fd);
36c5: 89 1c 24 mov %ebx,(%esp)
36c8: e8 bd 02 00 00 call 398a <close>
printf(1, "arg test passed\n");
36cd: 58 pop %eax
36ce: 5a pop %edx
36cf: 68 ae 4d 00 00 push $0x4dae
36d4: 6a 01 push $0x1
36d6: e8 d5 03 00 00 call 3ab0 <printf>
}
36db: 83 c4 10 add $0x10,%esp
36de: 8b 5d fc mov -0x4(%ebp),%ebx
36e1: c9 leave
36e2: c3 ret
void argptest()
{
int fd;
fd = open("init", O_RDONLY);
if (fd < 0) {
printf(2, "open failed\n");
36e3: 51 push %ecx
36e4: 51 push %ecx
36e5: 68 a1 4d 00 00 push $0x4da1
36ea: 6a 02 push $0x2
36ec: e8 bf 03 00 00 call 3ab0 <printf>
exit();
36f1: e8 6c 02 00 00 call 3962 <exit>
36f6: 8d 76 00 lea 0x0(%esi),%esi
36f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00003700 <rand>:
unsigned long randstate = 1;
unsigned int
rand()
{
randstate = randstate * 1664525 + 1013904223;
3700: 69 05 60 5e 00 00 0d imul $0x19660d,0x5e60,%eax
3707: 66 19 00
}
unsigned long randstate = 1;
unsigned int
rand()
{
370a: 55 push %ebp
370b: 89 e5 mov %esp,%ebp
randstate = randstate * 1664525 + 1013904223;
return randstate;
}
370d: 5d pop %ebp
unsigned long randstate = 1;
unsigned int
rand()
{
randstate = randstate * 1664525 + 1013904223;
370e: 05 5f f3 6e 3c add $0x3c6ef35f,%eax
3713: a3 60 5e 00 00 mov %eax,0x5e60
return randstate;
}
3718: c3 ret
3719: 66 90 xchg %ax,%ax
371b: 66 90 xchg %ax,%ax
371d: 66 90 xchg %ax,%ax
371f: 90 nop
00003720 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
3720: 55 push %ebp
3721: 89 e5 mov %esp,%ebp
3723: 53 push %ebx
3724: 8b 45 08 mov 0x8(%ebp),%eax
3727: 8b 4d 0c mov 0xc(%ebp),%ecx
char *os;
os = s;
while((*s++ = *t++) != 0)
372a: 89 c2 mov %eax,%edx
372c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3730: 83 c1 01 add $0x1,%ecx
3733: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
3737: 83 c2 01 add $0x1,%edx
373a: 84 db test %bl,%bl
373c: 88 5a ff mov %bl,-0x1(%edx)
373f: 75 ef jne 3730 <strcpy+0x10>
;
return os;
}
3741: 5b pop %ebx
3742: 5d pop %ebp
3743: c3 ret
3744: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
374a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00003750 <strcmp>:
int
strcmp(const char *p, const char *q)
{
3750: 55 push %ebp
3751: 89 e5 mov %esp,%ebp
3753: 56 push %esi
3754: 53 push %ebx
3755: 8b 55 08 mov 0x8(%ebp),%edx
3758: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
375b: 0f b6 02 movzbl (%edx),%eax
375e: 0f b6 19 movzbl (%ecx),%ebx
3761: 84 c0 test %al,%al
3763: 75 1e jne 3783 <strcmp+0x33>
3765: eb 29 jmp 3790 <strcmp+0x40>
3767: 89 f6 mov %esi,%esi
3769: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
p++, q++;
3770: 83 c2 01 add $0x1,%edx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
3773: 0f b6 02 movzbl (%edx),%eax
p++, q++;
3776: 8d 71 01 lea 0x1(%ecx),%esi
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
3779: 0f b6 59 01 movzbl 0x1(%ecx),%ebx
377d: 84 c0 test %al,%al
377f: 74 0f je 3790 <strcmp+0x40>
3781: 89 f1 mov %esi,%ecx
3783: 38 d8 cmp %bl,%al
3785: 74 e9 je 3770 <strcmp+0x20>
p++, q++;
return (uchar)*p - (uchar)*q;
3787: 29 d8 sub %ebx,%eax
}
3789: 5b pop %ebx
378a: 5e pop %esi
378b: 5d pop %ebp
378c: c3 ret
378d: 8d 76 00 lea 0x0(%esi),%esi
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
3790: 31 c0 xor %eax,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
3792: 29 d8 sub %ebx,%eax
}
3794: 5b pop %ebx
3795: 5e pop %esi
3796: 5d pop %ebp
3797: c3 ret
3798: 90 nop
3799: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000037a0 <strlen>:
uint
strlen(char *s)
{
37a0: 55 push %ebp
37a1: 89 e5 mov %esp,%ebp
37a3: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
37a6: 80 39 00 cmpb $0x0,(%ecx)
37a9: 74 12 je 37bd <strlen+0x1d>
37ab: 31 d2 xor %edx,%edx
37ad: 8d 76 00 lea 0x0(%esi),%esi
37b0: 83 c2 01 add $0x1,%edx
37b3: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
37b7: 89 d0 mov %edx,%eax
37b9: 75 f5 jne 37b0 <strlen+0x10>
;
return n;
}
37bb: 5d pop %ebp
37bc: c3 ret
uint
strlen(char *s)
{
int n;
for(n = 0; s[n]; n++)
37bd: 31 c0 xor %eax,%eax
;
return n;
}
37bf: 5d pop %ebp
37c0: c3 ret
37c1: eb 0d jmp 37d0 <memset>
37c3: 90 nop
37c4: 90 nop
37c5: 90 nop
37c6: 90 nop
37c7: 90 nop
37c8: 90 nop
37c9: 90 nop
37ca: 90 nop
37cb: 90 nop
37cc: 90 nop
37cd: 90 nop
37ce: 90 nop
37cf: 90 nop
000037d0 <memset>:
void*
memset(void *dst, int c, uint n)
{
37d0: 55 push %ebp
37d1: 89 e5 mov %esp,%ebp
37d3: 57 push %edi
37d4: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
37d7: 8b 4d 10 mov 0x10(%ebp),%ecx
37da: 8b 45 0c mov 0xc(%ebp),%eax
37dd: 89 d7 mov %edx,%edi
37df: fc cld
37e0: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
37e2: 89 d0 mov %edx,%eax
37e4: 5f pop %edi
37e5: 5d pop %ebp
37e6: c3 ret
37e7: 89 f6 mov %esi,%esi
37e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000037f0 <strchr>:
char*
strchr(const char *s, char c)
{
37f0: 55 push %ebp
37f1: 89 e5 mov %esp,%ebp
37f3: 53 push %ebx
37f4: 8b 45 08 mov 0x8(%ebp),%eax
37f7: 8b 5d 0c mov 0xc(%ebp),%ebx
for(; *s; s++)
37fa: 0f b6 10 movzbl (%eax),%edx
37fd: 84 d2 test %dl,%dl
37ff: 74 1d je 381e <strchr+0x2e>
if(*s == c)
3801: 38 d3 cmp %dl,%bl
3803: 89 d9 mov %ebx,%ecx
3805: 75 0d jne 3814 <strchr+0x24>
3807: eb 17 jmp 3820 <strchr+0x30>
3809: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
3810: 38 ca cmp %cl,%dl
3812: 74 0c je 3820 <strchr+0x30>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
3814: 83 c0 01 add $0x1,%eax
3817: 0f b6 10 movzbl (%eax),%edx
381a: 84 d2 test %dl,%dl
381c: 75 f2 jne 3810 <strchr+0x20>
if(*s == c)
return (char*)s;
return 0;
381e: 31 c0 xor %eax,%eax
}
3820: 5b pop %ebx
3821: 5d pop %ebp
3822: c3 ret
3823: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
3829: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00003830 <gets>:
char*
gets(char *buf, int max)
{
3830: 55 push %ebp
3831: 89 e5 mov %esp,%ebp
3833: 57 push %edi
3834: 56 push %esi
3835: 53 push %ebx
int i, cc;
char c;
for(i=0; i+1 < max; ){
3836: 31 f6 xor %esi,%esi
cc = read(0, &c, 1);
3838: 8d 7d e7 lea -0x19(%ebp),%edi
return 0;
}
char*
gets(char *buf, int max)
{
383b: 83 ec 1c sub $0x1c,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
383e: eb 29 jmp 3869 <gets+0x39>
cc = read(0, &c, 1);
3840: 83 ec 04 sub $0x4,%esp
3843: 6a 01 push $0x1
3845: 57 push %edi
3846: 6a 00 push $0x0
3848: e8 2d 01 00 00 call 397a <read>
if(cc < 1)
384d: 83 c4 10 add $0x10,%esp
3850: 85 c0 test %eax,%eax
3852: 7e 1d jle 3871 <gets+0x41>
break;
buf[i++] = c;
3854: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
3858: 8b 55 08 mov 0x8(%ebp),%edx
385b: 89 de mov %ebx,%esi
if(c == '\n' || c == '\r')
385d: 3c 0a cmp $0xa,%al
for(i=0; i+1 < max; ){
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
385f: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
if(c == '\n' || c == '\r')
3863: 74 1b je 3880 <gets+0x50>
3865: 3c 0d cmp $0xd,%al
3867: 74 17 je 3880 <gets+0x50>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
3869: 8d 5e 01 lea 0x1(%esi),%ebx
386c: 3b 5d 0c cmp 0xc(%ebp),%ebx
386f: 7c cf jl 3840 <gets+0x10>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
3871: 8b 45 08 mov 0x8(%ebp),%eax
3874: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
3878: 8d 65 f4 lea -0xc(%ebp),%esp
387b: 5b pop %ebx
387c: 5e pop %esi
387d: 5f pop %edi
387e: 5d pop %ebp
387f: c3 ret
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
3880: 8b 45 08 mov 0x8(%ebp),%eax
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
3883: 89 de mov %ebx,%esi
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
3885: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
3889: 8d 65 f4 lea -0xc(%ebp),%esp
388c: 5b pop %ebx
388d: 5e pop %esi
388e: 5f pop %edi
388f: 5d pop %ebp
3890: c3 ret
3891: eb 0d jmp 38a0 <stat>
3893: 90 nop
3894: 90 nop
3895: 90 nop
3896: 90 nop
3897: 90 nop
3898: 90 nop
3899: 90 nop
389a: 90 nop
389b: 90 nop
389c: 90 nop
389d: 90 nop
389e: 90 nop
389f: 90 nop
000038a0 <stat>:
int
stat(char *n, struct stat *st)
{
38a0: 55 push %ebp
38a1: 89 e5 mov %esp,%ebp
38a3: 56 push %esi
38a4: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
38a5: 83 ec 08 sub $0x8,%esp
38a8: 6a 00 push $0x0
38aa: ff 75 08 pushl 0x8(%ebp)
38ad: e8 f0 00 00 00 call 39a2 <open>
if(fd < 0)
38b2: 83 c4 10 add $0x10,%esp
38b5: 85 c0 test %eax,%eax
38b7: 78 27 js 38e0 <stat+0x40>
return -1;
r = fstat(fd, st);
38b9: 83 ec 08 sub $0x8,%esp
38bc: ff 75 0c pushl 0xc(%ebp)
38bf: 89 c3 mov %eax,%ebx
38c1: 50 push %eax
38c2: e8 f3 00 00 00 call 39ba <fstat>
38c7: 89 c6 mov %eax,%esi
close(fd);
38c9: 89 1c 24 mov %ebx,(%esp)
38cc: e8 b9 00 00 00 call 398a <close>
return r;
38d1: 83 c4 10 add $0x10,%esp
38d4: 89 f0 mov %esi,%eax
}
38d6: 8d 65 f8 lea -0x8(%ebp),%esp
38d9: 5b pop %ebx
38da: 5e pop %esi
38db: 5d pop %ebp
38dc: c3 ret
38dd: 8d 76 00 lea 0x0(%esi),%esi
int fd;
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
return -1;
38e0: b8 ff ff ff ff mov $0xffffffff,%eax
38e5: eb ef jmp 38d6 <stat+0x36>
38e7: 89 f6 mov %esi,%esi
38e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000038f0 <atoi>:
return r;
}
int
atoi(const char *s)
{
38f0: 55 push %ebp
38f1: 89 e5 mov %esp,%ebp
38f3: 53 push %ebx
38f4: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
n = 0;
while('0' <= *s && *s <= '9')
38f7: 0f be 11 movsbl (%ecx),%edx
38fa: 8d 42 d0 lea -0x30(%edx),%eax
38fd: 3c 09 cmp $0x9,%al
38ff: b8 00 00 00 00 mov $0x0,%eax
3904: 77 1f ja 3925 <atoi+0x35>
3906: 8d 76 00 lea 0x0(%esi),%esi
3909: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
n = n*10 + *s++ - '0';
3910: 8d 04 80 lea (%eax,%eax,4),%eax
3913: 83 c1 01 add $0x1,%ecx
3916: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
391a: 0f be 11 movsbl (%ecx),%edx
391d: 8d 5a d0 lea -0x30(%edx),%ebx
3920: 80 fb 09 cmp $0x9,%bl
3923: 76 eb jbe 3910 <atoi+0x20>
n = n*10 + *s++ - '0';
return n;
}
3925: 5b pop %ebx
3926: 5d pop %ebp
3927: c3 ret
3928: 90 nop
3929: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00003930 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
3930: 55 push %ebp
3931: 89 e5 mov %esp,%ebp
3933: 56 push %esi
3934: 53 push %ebx
3935: 8b 5d 10 mov 0x10(%ebp),%ebx
3938: 8b 45 08 mov 0x8(%ebp),%eax
393b: 8b 75 0c mov 0xc(%ebp),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
393e: 85 db test %ebx,%ebx
3940: 7e 14 jle 3956 <memmove+0x26>
3942: 31 d2 xor %edx,%edx
3944: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
3948: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
394c: 88 0c 10 mov %cl,(%eax,%edx,1)
394f: 83 c2 01 add $0x1,%edx
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
3952: 39 da cmp %ebx,%edx
3954: 75 f2 jne 3948 <memmove+0x18>
*dst++ = *src++;
return vdst;
}
3956: 5b pop %ebx
3957: 5e pop %esi
3958: 5d pop %ebp
3959: c3 ret
0000395a <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
395a: b8 01 00 00 00 mov $0x1,%eax
395f: cd 40 int $0x40
3961: c3 ret
00003962 <exit>:
SYSCALL(exit)
3962: b8 02 00 00 00 mov $0x2,%eax
3967: cd 40 int $0x40
3969: c3 ret
0000396a <wait>:
SYSCALL(wait)
396a: b8 03 00 00 00 mov $0x3,%eax
396f: cd 40 int $0x40
3971: c3 ret
00003972 <pipe>:
SYSCALL(pipe)
3972: b8 04 00 00 00 mov $0x4,%eax
3977: cd 40 int $0x40
3979: c3 ret
0000397a <read>:
SYSCALL(read)
397a: b8 05 00 00 00 mov $0x5,%eax
397f: cd 40 int $0x40
3981: c3 ret
00003982 <write>:
SYSCALL(write)
3982: b8 10 00 00 00 mov $0x10,%eax
3987: cd 40 int $0x40
3989: c3 ret
0000398a <close>:
SYSCALL(close)
398a: b8 15 00 00 00 mov $0x15,%eax
398f: cd 40 int $0x40
3991: c3 ret
00003992 <kill>:
SYSCALL(kill)
3992: b8 06 00 00 00 mov $0x6,%eax
3997: cd 40 int $0x40
3999: c3 ret
0000399a <exec>:
SYSCALL(exec)
399a: b8 07 00 00 00 mov $0x7,%eax
399f: cd 40 int $0x40
39a1: c3 ret
000039a2 <open>:
SYSCALL(open)
39a2: b8 0f 00 00 00 mov $0xf,%eax
39a7: cd 40 int $0x40
39a9: c3 ret
000039aa <mknod>:
SYSCALL(mknod)
39aa: b8 11 00 00 00 mov $0x11,%eax
39af: cd 40 int $0x40
39b1: c3 ret
000039b2 <unlink>:
SYSCALL(unlink)
39b2: b8 12 00 00 00 mov $0x12,%eax
39b7: cd 40 int $0x40
39b9: c3 ret
000039ba <fstat>:
SYSCALL(fstat)
39ba: b8 08 00 00 00 mov $0x8,%eax
39bf: cd 40 int $0x40
39c1: c3 ret
000039c2 <link>:
SYSCALL(link)
39c2: b8 13 00 00 00 mov $0x13,%eax
39c7: cd 40 int $0x40
39c9: c3 ret
000039ca <mkdir>:
SYSCALL(mkdir)
39ca: b8 14 00 00 00 mov $0x14,%eax
39cf: cd 40 int $0x40
39d1: c3 ret
000039d2 <chdir>:
SYSCALL(chdir)
39d2: b8 09 00 00 00 mov $0x9,%eax
39d7: cd 40 int $0x40
39d9: c3 ret
000039da <dup>:
SYSCALL(dup)
39da: b8 0a 00 00 00 mov $0xa,%eax
39df: cd 40 int $0x40
39e1: c3 ret
000039e2 <getpid>:
SYSCALL(getpid)
39e2: b8 0b 00 00 00 mov $0xb,%eax
39e7: cd 40 int $0x40
39e9: c3 ret
000039ea <sbrk>:
SYSCALL(sbrk)
39ea: b8 0c 00 00 00 mov $0xc,%eax
39ef: cd 40 int $0x40
39f1: c3 ret
000039f2 <sleep>:
SYSCALL(sleep)
39f2: b8 0d 00 00 00 mov $0xd,%eax
39f7: cd 40 int $0x40
39f9: c3 ret
000039fa <uptime>:
SYSCALL(uptime)
39fa: b8 0e 00 00 00 mov $0xe,%eax
39ff: cd 40 int $0x40
3a01: c3 ret
3a02: 66 90 xchg %ax,%ax
3a04: 66 90 xchg %ax,%ax
3a06: 66 90 xchg %ax,%ax
3a08: 66 90 xchg %ax,%ax
3a0a: 66 90 xchg %ax,%ax
3a0c: 66 90 xchg %ax,%ax
3a0e: 66 90 xchg %ax,%ax
00003a10 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
3a10: 55 push %ebp
3a11: 89 e5 mov %esp,%ebp
3a13: 57 push %edi
3a14: 56 push %esi
3a15: 53 push %ebx
3a16: 89 c6 mov %eax,%esi
3a18: 83 ec 3c sub $0x3c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
3a1b: 8b 5d 08 mov 0x8(%ebp),%ebx
3a1e: 85 db test %ebx,%ebx
3a20: 74 7e je 3aa0 <printint+0x90>
3a22: 89 d0 mov %edx,%eax
3a24: c1 e8 1f shr $0x1f,%eax
3a27: 84 c0 test %al,%al
3a29: 74 75 je 3aa0 <printint+0x90>
neg = 1;
x = -xx;
3a2b: 89 d0 mov %edx,%eax
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
3a2d: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
x = -xx;
3a34: f7 d8 neg %eax
3a36: 89 75 c0 mov %esi,-0x40(%ebp)
} else {
x = xx;
}
i = 0;
3a39: 31 ff xor %edi,%edi
3a3b: 8d 5d d7 lea -0x29(%ebp),%ebx
3a3e: 89 ce mov %ecx,%esi
3a40: eb 08 jmp 3a4a <printint+0x3a>
3a42: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
do{
buf[i++] = digits[x % base];
3a48: 89 cf mov %ecx,%edi
3a4a: 31 d2 xor %edx,%edx
3a4c: 8d 4f 01 lea 0x1(%edi),%ecx
3a4f: f7 f6 div %esi
3a51: 0f b6 92 70 55 00 00 movzbl 0x5570(%edx),%edx
}while((x /= base) != 0);
3a58: 85 c0 test %eax,%eax
x = xx;
}
i = 0;
do{
buf[i++] = digits[x % base];
3a5a: 88 14 0b mov %dl,(%ebx,%ecx,1)
}while((x /= base) != 0);
3a5d: 75 e9 jne 3a48 <printint+0x38>
if(neg)
3a5f: 8b 45 c4 mov -0x3c(%ebp),%eax
3a62: 8b 75 c0 mov -0x40(%ebp),%esi
3a65: 85 c0 test %eax,%eax
3a67: 74 08 je 3a71 <printint+0x61>
buf[i++] = '-';
3a69: c6 44 0d d8 2d movb $0x2d,-0x28(%ebp,%ecx,1)
3a6e: 8d 4f 02 lea 0x2(%edi),%ecx
3a71: 8d 7c 0d d7 lea -0x29(%ebp,%ecx,1),%edi
3a75: 8d 76 00 lea 0x0(%esi),%esi
3a78: 0f b6 07 movzbl (%edi),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3a7b: 83 ec 04 sub $0x4,%esp
3a7e: 83 ef 01 sub $0x1,%edi
3a81: 6a 01 push $0x1
3a83: 53 push %ebx
3a84: 56 push %esi
3a85: 88 45 d7 mov %al,-0x29(%ebp)
3a88: e8 f5 fe ff ff call 3982 <write>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
3a8d: 83 c4 10 add $0x10,%esp
3a90: 39 df cmp %ebx,%edi
3a92: 75 e4 jne 3a78 <printint+0x68>
putc(fd, buf[i]);
}
3a94: 8d 65 f4 lea -0xc(%ebp),%esp
3a97: 5b pop %ebx
3a98: 5e pop %esi
3a99: 5f pop %edi
3a9a: 5d pop %ebp
3a9b: c3 ret
3a9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
neg = 0;
if(sgn && xx < 0){
neg = 1;
x = -xx;
} else {
x = xx;
3aa0: 89 d0 mov %edx,%eax
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
3aa2: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
3aa9: eb 8b jmp 3a36 <printint+0x26>
3aab: 90 nop
3aac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00003ab0 <printf>:
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
3ab0: 55 push %ebp
3ab1: 89 e5 mov %esp,%ebp
3ab3: 57 push %edi
3ab4: 56 push %esi
3ab5: 53 push %ebx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3ab6: 8d 45 10 lea 0x10(%ebp),%eax
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
3ab9: 83 ec 2c sub $0x2c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3abc: 8b 75 0c mov 0xc(%ebp),%esi
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
3abf: 8b 7d 08 mov 0x8(%ebp),%edi
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3ac2: 89 45 d0 mov %eax,-0x30(%ebp)
3ac5: 0f b6 1e movzbl (%esi),%ebx
3ac8: 83 c6 01 add $0x1,%esi
3acb: 84 db test %bl,%bl
3acd: 0f 84 b0 00 00 00 je 3b83 <printf+0xd3>
3ad3: 31 d2 xor %edx,%edx
3ad5: eb 39 jmp 3b10 <printf+0x60>
3ad7: 89 f6 mov %esi,%esi
3ad9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
3ae0: 83 f8 25 cmp $0x25,%eax
3ae3: 89 55 d4 mov %edx,-0x2c(%ebp)
state = '%';
3ae6: ba 25 00 00 00 mov $0x25,%edx
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
3aeb: 74 18 je 3b05 <printf+0x55>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3aed: 8d 45 e2 lea -0x1e(%ebp),%eax
3af0: 83 ec 04 sub $0x4,%esp
3af3: 88 5d e2 mov %bl,-0x1e(%ebp)
3af6: 6a 01 push $0x1
3af8: 50 push %eax
3af9: 57 push %edi
3afa: e8 83 fe ff ff call 3982 <write>
3aff: 8b 55 d4 mov -0x2c(%ebp),%edx
3b02: 83 c4 10 add $0x10,%esp
3b05: 83 c6 01 add $0x1,%esi
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3b08: 0f b6 5e ff movzbl -0x1(%esi),%ebx
3b0c: 84 db test %bl,%bl
3b0e: 74 73 je 3b83 <printf+0xd3>
c = fmt[i] & 0xff;
if(state == 0){
3b10: 85 d2 test %edx,%edx
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
3b12: 0f be cb movsbl %bl,%ecx
3b15: 0f b6 c3 movzbl %bl,%eax
if(state == 0){
3b18: 74 c6 je 3ae0 <printf+0x30>
if(c == '%'){
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
3b1a: 83 fa 25 cmp $0x25,%edx
3b1d: 75 e6 jne 3b05 <printf+0x55>
if(c == 'd'){
3b1f: 83 f8 64 cmp $0x64,%eax
3b22: 0f 84 f8 00 00 00 je 3c20 <printf+0x170>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
3b28: 81 e1 f7 00 00 00 and $0xf7,%ecx
3b2e: 83 f9 70 cmp $0x70,%ecx
3b31: 74 5d je 3b90 <printf+0xe0>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
3b33: 83 f8 73 cmp $0x73,%eax
3b36: 0f 84 84 00 00 00 je 3bc0 <printf+0x110>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
3b3c: 83 f8 63 cmp $0x63,%eax
3b3f: 0f 84 ea 00 00 00 je 3c2f <printf+0x17f>
putc(fd, *ap);
ap++;
} else if(c == '%'){
3b45: 83 f8 25 cmp $0x25,%eax
3b48: 0f 84 c2 00 00 00 je 3c10 <printf+0x160>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3b4e: 8d 45 e7 lea -0x19(%ebp),%eax
3b51: 83 ec 04 sub $0x4,%esp
3b54: c6 45 e7 25 movb $0x25,-0x19(%ebp)
3b58: 6a 01 push $0x1
3b5a: 50 push %eax
3b5b: 57 push %edi
3b5c: e8 21 fe ff ff call 3982 <write>
3b61: 83 c4 0c add $0xc,%esp
3b64: 8d 45 e6 lea -0x1a(%ebp),%eax
3b67: 88 5d e6 mov %bl,-0x1a(%ebp)
3b6a: 6a 01 push $0x1
3b6c: 50 push %eax
3b6d: 57 push %edi
3b6e: 83 c6 01 add $0x1,%esi
3b71: e8 0c fe ff ff call 3982 <write>
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3b76: 0f b6 5e ff movzbl -0x1(%esi),%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3b7a: 83 c4 10 add $0x10,%esp
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
3b7d: 31 d2 xor %edx,%edx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
3b7f: 84 db test %bl,%bl
3b81: 75 8d jne 3b10 <printf+0x60>
putc(fd, c);
}
state = 0;
}
}
}
3b83: 8d 65 f4 lea -0xc(%ebp),%esp
3b86: 5b pop %ebx
3b87: 5e pop %esi
3b88: 5f pop %edi
3b89: 5d pop %ebp
3b8a: c3 ret
3b8b: 90 nop
3b8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
3b90: 83 ec 0c sub $0xc,%esp
3b93: b9 10 00 00 00 mov $0x10,%ecx
3b98: 6a 00 push $0x0
3b9a: 8b 5d d0 mov -0x30(%ebp),%ebx
3b9d: 89 f8 mov %edi,%eax
3b9f: 8b 13 mov (%ebx),%edx
3ba1: e8 6a fe ff ff call 3a10 <printint>
ap++;
3ba6: 89 d8 mov %ebx,%eax
3ba8: 83 c4 10 add $0x10,%esp
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
3bab: 31 d2 xor %edx,%edx
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
ap++;
3bad: 83 c0 04 add $0x4,%eax
3bb0: 89 45 d0 mov %eax,-0x30(%ebp)
3bb3: e9 4d ff ff ff jmp 3b05 <printf+0x55>
3bb8: 90 nop
3bb9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
} else if(c == 's'){
s = (char*)*ap;
3bc0: 8b 45 d0 mov -0x30(%ebp),%eax
3bc3: 8b 18 mov (%eax),%ebx
ap++;
3bc5: 83 c0 04 add $0x4,%eax
3bc8: 89 45 d0 mov %eax,-0x30(%ebp)
if(s == 0)
s = "(null)";
3bcb: b8 68 55 00 00 mov $0x5568,%eax
3bd0: 85 db test %ebx,%ebx
3bd2: 0f 44 d8 cmove %eax,%ebx
while(*s != 0){
3bd5: 0f b6 03 movzbl (%ebx),%eax
3bd8: 84 c0 test %al,%al
3bda: 74 23 je 3bff <printf+0x14f>
3bdc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3be0: 88 45 e3 mov %al,-0x1d(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3be3: 8d 45 e3 lea -0x1d(%ebp),%eax
3be6: 83 ec 04 sub $0x4,%esp
3be9: 6a 01 push $0x1
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
3beb: 83 c3 01 add $0x1,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3bee: 50 push %eax
3bef: 57 push %edi
3bf0: e8 8d fd ff ff call 3982 <write>
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
3bf5: 0f b6 03 movzbl (%ebx),%eax
3bf8: 83 c4 10 add $0x10,%esp
3bfb: 84 c0 test %al,%al
3bfd: 75 e1 jne 3be0 <printf+0x130>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
3bff: 31 d2 xor %edx,%edx
3c01: e9 ff fe ff ff jmp 3b05 <printf+0x55>
3c06: 8d 76 00 lea 0x0(%esi),%esi
3c09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3c10: 83 ec 04 sub $0x4,%esp
3c13: 88 5d e5 mov %bl,-0x1b(%ebp)
3c16: 8d 45 e5 lea -0x1b(%ebp),%eax
3c19: 6a 01 push $0x1
3c1b: e9 4c ff ff ff jmp 3b6c <printf+0xbc>
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
3c20: 83 ec 0c sub $0xc,%esp
3c23: b9 0a 00 00 00 mov $0xa,%ecx
3c28: 6a 01 push $0x1
3c2a: e9 6b ff ff ff jmp 3b9a <printf+0xea>
3c2f: 8b 5d d0 mov -0x30(%ebp),%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
3c32: 83 ec 04 sub $0x4,%esp
3c35: 8b 03 mov (%ebx),%eax
3c37: 6a 01 push $0x1
3c39: 88 45 e4 mov %al,-0x1c(%ebp)
3c3c: 8d 45 e4 lea -0x1c(%ebp),%eax
3c3f: 50 push %eax
3c40: 57 push %edi
3c41: e8 3c fd ff ff call 3982 <write>
3c46: e9 5b ff ff ff jmp 3ba6 <printf+0xf6>
3c4b: 66 90 xchg %ax,%ax
3c4d: 66 90 xchg %ax,%ax
3c4f: 90 nop
00003c50 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
3c50: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
3c51: a1 00 5f 00 00 mov 0x5f00,%eax
static Header base;
static Header *freep;
void
free(void *ap)
{
3c56: 89 e5 mov %esp,%ebp
3c58: 57 push %edi
3c59: 56 push %esi
3c5a: 53 push %ebx
3c5b: 8b 5d 08 mov 0x8(%ebp),%ebx
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
3c5e: 8b 10 mov (%eax),%edx
void
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
3c60: 8d 4b f8 lea -0x8(%ebx),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
3c63: 39 c8 cmp %ecx,%eax
3c65: 73 19 jae 3c80 <free+0x30>
3c67: 89 f6 mov %esi,%esi
3c69: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
3c70: 39 d1 cmp %edx,%ecx
3c72: 72 1c jb 3c90 <free+0x40>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
3c74: 39 d0 cmp %edx,%eax
3c76: 73 18 jae 3c90 <free+0x40>
static Header base;
static Header *freep;
void
free(void *ap)
{
3c78: 89 d0 mov %edx,%eax
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
3c7a: 39 c8 cmp %ecx,%eax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
3c7c: 8b 10 mov (%eax),%edx
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
3c7e: 72 f0 jb 3c70 <free+0x20>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
3c80: 39 d0 cmp %edx,%eax
3c82: 72 f4 jb 3c78 <free+0x28>
3c84: 39 d1 cmp %edx,%ecx
3c86: 73 f0 jae 3c78 <free+0x28>
3c88: 90 nop
3c89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
break;
if(bp + bp->s.size == p->s.ptr){
3c90: 8b 73 fc mov -0x4(%ebx),%esi
3c93: 8d 3c f1 lea (%ecx,%esi,8),%edi
3c96: 39 d7 cmp %edx,%edi
3c98: 74 19 je 3cb3 <free+0x63>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
3c9a: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
3c9d: 8b 50 04 mov 0x4(%eax),%edx
3ca0: 8d 34 d0 lea (%eax,%edx,8),%esi
3ca3: 39 f1 cmp %esi,%ecx
3ca5: 74 23 je 3cca <free+0x7a>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
3ca7: 89 08 mov %ecx,(%eax)
freep = p;
3ca9: a3 00 5f 00 00 mov %eax,0x5f00
}
3cae: 5b pop %ebx
3caf: 5e pop %esi
3cb0: 5f pop %edi
3cb1: 5d pop %ebp
3cb2: c3 ret
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
bp->s.size += p->s.ptr->s.size;
3cb3: 03 72 04 add 0x4(%edx),%esi
3cb6: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
3cb9: 8b 10 mov (%eax),%edx
3cbb: 8b 12 mov (%edx),%edx
3cbd: 89 53 f8 mov %edx,-0x8(%ebx)
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
3cc0: 8b 50 04 mov 0x4(%eax),%edx
3cc3: 8d 34 d0 lea (%eax,%edx,8),%esi
3cc6: 39 f1 cmp %esi,%ecx
3cc8: 75 dd jne 3ca7 <free+0x57>
p->s.size += bp->s.size;
3cca: 03 53 fc add -0x4(%ebx),%edx
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
freep = p;
3ccd: a3 00 5f 00 00 mov %eax,0x5f00
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
p->s.size += bp->s.size;
3cd2: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
3cd5: 8b 53 f8 mov -0x8(%ebx),%edx
3cd8: 89 10 mov %edx,(%eax)
} else
p->s.ptr = bp;
freep = p;
}
3cda: 5b pop %ebx
3cdb: 5e pop %esi
3cdc: 5f pop %edi
3cdd: 5d pop %ebp
3cde: c3 ret
3cdf: 90 nop
00003ce0 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
3ce0: 55 push %ebp
3ce1: 89 e5 mov %esp,%ebp
3ce3: 57 push %edi
3ce4: 56 push %esi
3ce5: 53 push %ebx
3ce6: 83 ec 0c sub $0xc,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
3ce9: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
3cec: 8b 15 00 5f 00 00 mov 0x5f00,%edx
malloc(uint nbytes)
{
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
3cf2: 8d 78 07 lea 0x7(%eax),%edi
3cf5: c1 ef 03 shr $0x3,%edi
3cf8: 83 c7 01 add $0x1,%edi
if((prevp = freep) == 0){
3cfb: 85 d2 test %edx,%edx
3cfd: 0f 84 a3 00 00 00 je 3da6 <malloc+0xc6>
3d03: 8b 02 mov (%edx),%eax
3d05: 8b 48 04 mov 0x4(%eax),%ecx
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
3d08: 39 cf cmp %ecx,%edi
3d0a: 76 74 jbe 3d80 <malloc+0xa0>
3d0c: 81 ff 00 10 00 00 cmp $0x1000,%edi
3d12: be 00 10 00 00 mov $0x1000,%esi
3d17: 8d 1c fd 00 00 00 00 lea 0x0(,%edi,8),%ebx
3d1e: 0f 43 f7 cmovae %edi,%esi
3d21: ba 00 80 00 00 mov $0x8000,%edx
3d26: 81 ff ff 0f 00 00 cmp $0xfff,%edi
3d2c: 0f 46 da cmovbe %edx,%ebx
3d2f: eb 10 jmp 3d41 <malloc+0x61>
3d31: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
3d38: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
3d3a: 8b 48 04 mov 0x4(%eax),%ecx
3d3d: 39 cf cmp %ecx,%edi
3d3f: 76 3f jbe 3d80 <malloc+0xa0>
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
3d41: 39 05 00 5f 00 00 cmp %eax,0x5f00
3d47: 89 c2 mov %eax,%edx
3d49: 75 ed jne 3d38 <malloc+0x58>
char *p;
Header *hp;
if(nu < 4096)
nu = 4096;
p = sbrk(nu * sizeof(Header));
3d4b: 83 ec 0c sub $0xc,%esp
3d4e: 53 push %ebx
3d4f: e8 96 fc ff ff call 39ea <sbrk>
if(p == (char*)-1)
3d54: 83 c4 10 add $0x10,%esp
3d57: 83 f8 ff cmp $0xffffffff,%eax
3d5a: 74 1c je 3d78 <malloc+0x98>
return 0;
hp = (Header*)p;
hp->s.size = nu;
3d5c: 89 70 04 mov %esi,0x4(%eax)
free((void*)(hp + 1));
3d5f: 83 ec 0c sub $0xc,%esp
3d62: 83 c0 08 add $0x8,%eax
3d65: 50 push %eax
3d66: e8 e5 fe ff ff call 3c50 <free>
return freep;
3d6b: 8b 15 00 5f 00 00 mov 0x5f00,%edx
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
3d71: 83 c4 10 add $0x10,%esp
3d74: 85 d2 test %edx,%edx
3d76: 75 c0 jne 3d38 <malloc+0x58>
return 0;
3d78: 31 c0 xor %eax,%eax
3d7a: eb 1c jmp 3d98 <malloc+0xb8>
3d7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
if(p->s.size == nunits)
3d80: 39 cf cmp %ecx,%edi
3d82: 74 1c je 3da0 <malloc+0xc0>
prevp->s.ptr = p->s.ptr;
else {
p->s.size -= nunits;
3d84: 29 f9 sub %edi,%ecx
3d86: 89 48 04 mov %ecx,0x4(%eax)
p += p->s.size;
3d89: 8d 04 c8 lea (%eax,%ecx,8),%eax
p->s.size = nunits;
3d8c: 89 78 04 mov %edi,0x4(%eax)
}
freep = prevp;
3d8f: 89 15 00 5f 00 00 mov %edx,0x5f00
return (void*)(p + 1);
3d95: 83 c0 08 add $0x8,%eax
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
}
3d98: 8d 65 f4 lea -0xc(%ebp),%esp
3d9b: 5b pop %ebx
3d9c: 5e pop %esi
3d9d: 5f pop %edi
3d9e: 5d pop %ebp
3d9f: c3 ret
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
if(p->s.size == nunits)
prevp->s.ptr = p->s.ptr;
3da0: 8b 08 mov (%eax),%ecx
3da2: 89 0a mov %ecx,(%edx)
3da4: eb e9 jmp 3d8f <malloc+0xaf>
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
3da6: c7 05 00 5f 00 00 04 movl $0x5f04,0x5f00
3dad: 5f 00 00
3db0: c7 05 04 5f 00 00 04 movl $0x5f04,0x5f04
3db7: 5f 00 00
base.s.size = 0;
3dba: b8 04 5f 00 00 mov $0x5f04,%eax
3dbf: c7 05 08 5f 00 00 00 movl $0x0,0x5f08
3dc6: 00 00 00
3dc9: e9 3e ff ff ff jmp 3d0c <malloc+0x2c>
|
; A071239: a(n) = n*(n+1)*(n^2+2)/6.
; 0,1,6,22,60,135,266,476,792,1245,1870,2706,3796,5187,6930,9080,11696,14841,18582,22990,28140,34111,40986,48852,57800,67925,79326,92106,106372,122235,139810,159216,180576,204017,229670,257670,288156,321271,357162,395980,437880,483021,531566,583682,639540,699315,763186,831336,903952,981225,1063350,1150526,1242956,1340847,1444410,1553860,1669416,1791301,1919742,2054970,2197220,2346731,2503746,2668512,2841280,3022305,3211846,3410166,3617532,3834215,4060490,4296636,4542936,4799677,5067150,5345650,5635476,5936931,6250322,6575960,6914160,7265241,7629526,8007342,8399020,8804895,9225306,9660596,10111112,10577205,11059230,11557546,12072516,12604507,13153890,13721040,14306336,14910161,15532902,16174950
mov $1,$0
pow $0,2
add $1,$0
add $0,2
mul $0,$1
div $0,6
|
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file gameengine/GameLogic/SCA_EventManager.cpp
* \ingroup gamelogic
*/
#include <assert.h>
#include "SCA_EventManager.h"
#include "SCA_ISensor.h"
SCA_EventManager::SCA_EventManager(SCA_LogicManager* logicmgr, EVENT_MANAGER_TYPE mgrtype)
:m_logicmgr(logicmgr),
m_mgrtype(mgrtype)
{
}
SCA_EventManager::~SCA_EventManager()
{
// all sensors should be removed
assert(m_sensors.Empty());
}
void SCA_EventManager::RegisterSensor(class SCA_ISensor* sensor)
{
m_sensors.AddBack(sensor);
}
void SCA_EventManager::RemoveSensor(class SCA_ISensor* sensor)
{
sensor->Delink();
}
void SCA_EventManager::NextFrame(double curtime, double fixedtime)
{
NextFrame();
}
void SCA_EventManager::NextFrame()
{
assert(false); // && "Event managers should override a NextFrame method");
}
void SCA_EventManager::EndFrame()
{
}
void SCA_EventManager::UpdateFrame()
{
}
int SCA_EventManager::GetType()
{
return (int) m_mgrtype;
}
|
db DEX_VULPIX ; pokedex id
db 38 ; base hp
db 41 ; base attack
db 40 ; base defense
db 65 ; base speed
db 65 ; base special
db FIRE ; species type 1
db FIRE ; species type 2
db 190 ; catch rate
db 63 ; base exp yield
INCBIN "pic/ymon/vulpix.pic",0,1 ; 66, sprite dimensions
dw VulpixPicFront
dw VulpixPicBack
; attacks known at lvl 0
db EMBER
db TAIL_WHIP
db 0
db 0
db 0 ; growth rate
; learnset
tmlearn 6,8
tmlearn 9,10
tmlearn 20
tmlearn 28,31,32
tmlearn 33,34,38,39,40
tmlearn 44
tmlearn 50
db BANK(VulpixPicFront)
|
; A154246: a(n) = ( (5 + sqrt(7))^n - (5 - sqrt(7))^n )/(2*sqrt(7)).
; Submitted by Jon Maiga
; 1,10,82,640,4924,37720,288568,2206720,16872976,129008800,986374432,7541585920,57661119424,440862647680,3370726327168,25771735613440,197044282245376,1506551581411840,11518718733701632,88069258871603200,673355651509402624,5148309855405168640,39362696826882439168,300957390871531356160,2301045365831429656576,17593220622626732154880,134513389641301587730432,1028455925205734698516480,7863318238513918406017024,60120975731435959486873600,459670029021109063560429568,3514522727045243364840570880
mov $2,1
lpb $0
sub $0,1
add $1,$2
mul $2,2
sub $2,$1
mul $2,9
add $2,1
lpe
mov $0,$2
|
; A025744: Index of 10^n within sequence of numbers of form 6^i*10^j.
; 1,3,6,10,16,23,31,40,51,63,76,91,107,124,142,162,183,205,229,254,280,307,336,366,397,430,464,499,535,573,612,652,694,737,781,826,873,921,970,1021,1073,1126,1180,1236,1293,1351,1411,1472,1534,1597,1662,1728,1795
mov $3,$0
add $3,3
add $0,$3
add $3,$0
mov $0,$3
mov $1,2
lpb $0
trn $0,6
mov $2,0
add $2,$1
add $2,$0
trn $0,1
sub $1,$1
add $1,$2
sub $1,1
lpe
|
Name: sccdrv.asm
Type: file
Size: 22054
Last-Modified: '2016-05-13T04:52:55Z'
SHA-1: D911D2CA8090B2ADA1B46459AE28111BB5C073EC
Description: null
|
; A133728: A128174 * A127775.
; Submitted by Jon Maiga
; 1,0,3,1,0,5,0,3,0,7,1,0,5,0,9,0,3,0,7,0,11,1,0,5,0,9,0,13,0,3,0,7,0,11,0,15,1,0,5,0,9,0,13,0,17,0,3,0,7,0,11,0,15,0,19,1,0,5,0,9,0,13,0,17,0,21,0,3,0,7,0,11,0,15,0,19,0,23
seq $0,128179 ; A097807 * A002260.
mul $0,2
max $0,1
sub $0,1
|
; A112032: Denominator of 3/4 + 1/4 - 3/8 - 1/8 + 3/16 + 1/16 - 3/32 - 1/32 + 3/64 ...
; 4,1,8,2,16,4,32,8,64,16,128,32,256,64,512,128,1024,256,2048,512,4096,1024,8192,2048,16384,4096,32768,8192,65536,16384,131072,32768,262144,65536,524288,131072,1048576,262144,2097152,524288,4194304,1048576,8388608,2097152,16777216,4194304,33554432,8388608,67108864,16777216,134217728,33554432,268435456,67108864,536870912,134217728,1073741824,268435456,2147483648,536870912,4294967296,1073741824,8589934592,2147483648,17179869184,4294967296,34359738368,8589934592,68719476736,17179869184,137438953472
mov $1,4
mov $3,1
lpb $0
sub $0,1
mov $2,$3
mov $3,$1
mov $1,$2
mul $3,2
lpe
mov $0,$1
|
; A125117: First differences of A034887.
; 0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0
mov $6,$0
mov $7,2
lpb $7,1
mov $0,$6
sub $7,1
add $0,$7
mov $5,7
mul $5,$0
mul $5,4
sub $5,1
mov $2,$5
lpb $0,1
mov $0,1
mov $4,$2
lpe
mov $3,$7
div $4,93
mov $8,$4
lpb $3,1
mov $1,$8
sub $3,1
lpe
lpe
lpb $6,1
sub $1,$8
mov $6,0
lpe
|
#include "vex.h"
#include "drivetrain.h"
void sensor_display() {
//int line_y = 0;
//Print(0, line_y += 20, "gyro deg: %.2f ", gyro_z.value(rotationUnits::deg));
// Print(0, line_y += 20, "gyro mv: %.2f ", gyro_z.value(analogUnits::mV) );
// Print(0, line_y += 20, "gyro_fa : %.2f ", GyroGetAbsAngle());
// Print(0, line_y += 20, "gyro_f : %.2f ", GyroGetAngle());
/*Print(0, line_y += 20, "push : %d ", get_push_enc());
Print(0, line_y += 20, "swing: %d ", get_swing_enc());
Print(0, line_y += 20, "intake L: %d ", get_intake_enc(-1));
Print(0, line_y += 20, "intake R: %d ", get_intake_enc(1));
Print(0, line_y += 20, "move L : %d ", get_move_enc(-1));
Print(0, line_y += 20, "move R : %d ", get_move_enc(1));*/
//Print(0, line_y += 20, "limit push: %d ", limit_push_max.pressing());
} |
###############################################################################
# Copyright 2018 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material ("Material") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.section .note.GNU-stack,"",%progbits
.text
.globl s8_cpMulAdc_BNU_school
.type s8_cpMulAdc_BNU_school, @function
s8_cpMulAdc_BNU_school:
push %ebp
mov %esp, %ebp
push %ebx
push %esi
push %edi
movl (12)(%ebp), %eax
movl (16)(%ebp), %edi
movl (20)(%ebp), %ebx
movl (24)(%ebp), %esi
movl (8)(%ebp), %edx
cmp %ebx, %eax
jne .Lmultiplicationgas_1
cmp $(1), %edi
jg .Lsqr2gas_1
.Lsqr1gas_1:
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movq %xmm0, (%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr2gas_1:
cmp $(2), %edi
jg .Lsqr3gas_1
movd (%eax), %xmm0
movd (4)(%eax), %xmm1
movq %xmm0, %xmm2
pmuludq %xmm0, %xmm0
pmuludq %xmm1, %xmm2
pmuludq %xmm1, %xmm1
pcmpeqd %xmm7, %xmm7
psrlq $(32), %xmm7
pand %xmm2, %xmm7
paddq %xmm7, %xmm7
psrlq $(32), %xmm2
paddq %xmm2, %xmm2
movd %xmm0, (%edx)
psrlq $(32), %xmm0
paddq %xmm7, %xmm0
movd %xmm0, (4)(%edx)
psrlq $(32), %xmm0
paddq %xmm1, %xmm2
paddq %xmm0, %xmm2
movq %xmm2, (8)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr3gas_1:
cmp $(3), %edi
jg .Lsqr4gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (12)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (16)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (20)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr4gas_1:
cmp $(4), %edi
jg .Lsqr5gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (16)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (20)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (24)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (28)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr5gas_1:
cmp $(5), %edi
jg .Lsqr6gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (20)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (24)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (28)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (36)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr6gas_1:
cmp $(6), %edi
jg .Lsqr7gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (24)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (28)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (44)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr7gas_1:
cmp $(7), %edi
jg .Lsqr8gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (28)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (52)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr8gas_1:
cmp $(8), %edi
jg .Lsqr9gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (60)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr9gas_1:
cmp $(9), %edi
jg .Lsqr10gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (68)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr10gas_1:
cmp $(10), %edi
jg .Lsqr11gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (76)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr11gas_1:
cmp $(11), %edi
jg .Lsqr12gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (72)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (36)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (84)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (40)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr12gas_1:
cmp $(12), %edi
jg .Lsqr13gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (72)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (36)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm3
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (80)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (40)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (92)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (40)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (44)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr13gas_1:
cmp $(13), %edi
jg .Lsqr14gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (72)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (36)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm3
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (80)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (40)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm3
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (88)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (44)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (100)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (40)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (44)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (48)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr14gas_1:
cmp $(14), %edi
jg .Lsqr15gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (72)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (36)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm3
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (80)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (40)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm3
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (88)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (44)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm3
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (96)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (48)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (108)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (40)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (44)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (48)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (52)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (108)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr15gas_1:
cmp $(15), %edi
jg .Lsqr16gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (72)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (36)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm3
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (80)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (40)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm3
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (88)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (96)(%edx), %xmm4
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (44)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm3
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (96)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
movd (48)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm3
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (104)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (108)(%edx)
movd (52)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (112)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (116)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (40)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (44)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (48)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (52)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (108)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (56)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (116)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr16gas_1:
cmp $(16), %edi
jg .Lsqr17gas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (72)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (36)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm3
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (80)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (96)(%edx), %xmm4
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (40)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm3
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (88)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (96)(%edx), %xmm4
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
movd (44)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm3
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (96)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (104)(%edx), %xmm4
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (108)(%edx)
movd (48)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm3
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (104)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (108)(%edx), %xmm3
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (112)(%edx)
movd (52)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm3
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (112)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (116)(%edx)
movd (56)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (116)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (120)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (124)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (40)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (44)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (48)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (52)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (108)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (56)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (116)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (60)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (120)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (124)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (120)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (124)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lsqr17gas_1:
cmp $(17), %edi
jg .Lcommon_case_sqrgas_1
movd (%eax), %xmm0
pxor %xmm7, %xmm7
movd %xmm7, (%edx)
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (4)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm3
movd (12)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (16)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (24)(%edx), %xmm4
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (8)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm3
movd (16)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (24)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (32)(%edx), %xmm4
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (12)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm3
movd (20)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (32)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (40)(%edx), %xmm4
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (16)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm3
movd (24)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (40)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (48)(%edx), %xmm4
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (20)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm3
movd (28)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (48)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (56)(%edx), %xmm4
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (24)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm3
movd (32)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (56)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (64)(%edx), %xmm4
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (28)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm3
movd (36)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (64)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (72)(%edx), %xmm4
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (32)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm3
movd (40)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (72)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (80)(%edx), %xmm4
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (96)(%edx), %xmm4
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (36)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm3
movd (44)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (80)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (88)(%edx), %xmm4
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (96)(%edx), %xmm4
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
movd (40)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm3
movd (48)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (88)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (96)(%edx), %xmm4
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (104)(%edx), %xmm4
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (108)(%edx)
movd (44)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm3
movd (52)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (96)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (104)(%edx), %xmm4
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (108)(%edx), %xmm3
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (112)(%edx)
movd (48)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm3
movd (56)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (104)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (108)(%edx), %xmm3
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm4, %xmm7
movd (112)(%edx), %xmm4
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (116)(%edx)
movd (52)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm3
movd (60)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (112)(%edx), %xmm4
paddq %xmm1, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm3, %xmm7
movd (116)(%edx), %xmm3
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (120)(%edx)
movd (56)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (116)(%edx), %xmm3
movd (64)(%eax), %xmm2
pmuludq %xmm0, %xmm2
movd (120)(%edx), %xmm4
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
paddq %xmm2, %xmm7
paddq %xmm4, %xmm7
movd %xmm7, (120)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (124)(%edx)
movd (60)(%eax), %xmm0
pxor %xmm7, %xmm7
movd (64)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (124)(%edx), %xmm3
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (124)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (128)(%edx)
pandn %xmm7, %xmm7
movd %xmm7, (132)(%edx)
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
movd (%edx), %xmm2
paddq %xmm2, %xmm2
movd (4)(%edx), %xmm3
paddq %xmm3, %xmm3
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
pandn %xmm7, %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (4)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (12)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (8)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (20)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (12)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (28)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (16)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (36)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (20)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (44)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (24)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (52)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (28)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (60)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (32)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (68)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (36)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (76)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (40)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (84)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (44)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (92)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (48)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (100)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (52)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (108)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (56)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (116)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (60)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (120)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (124)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
movd (64)(%eax), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm2, %xmm7
movd (128)(%edx), %xmm2
paddq %xmm2, %xmm2
movd %xmm7, (120)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd (132)(%edx), %xmm3
paddq %xmm3, %xmm3
movd %xmm7, (124)(%edx)
psrlq $(32), %xmm7
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm0, %xmm7
paddq %xmm2, %xmm7
movd %xmm7, (128)(%edx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (132)(%edx)
psrlq $(32), %xmm7
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lcommon_case_sqrgas_1:
mov %edx, %ebx
mov %edi, %ecx
mov $(1), %edx
movd (%eax), %xmm0
movd (%eax,%edx,4), %xmm1
pmuludq %xmm0, %xmm1
pandn %xmm7, %xmm7
movd %xmm7, (%ebx)
.Lsqr_init_loopgas_1:
movd (4)(%eax,%edx,4), %xmm2
pmuludq %xmm0, %xmm2
paddq %xmm1, %xmm7
movd %xmm7, (%ebx,%edx,4)
psrlq $(32), %xmm7
add $(2), %edx
cmp %ecx, %edx
jg .Lsqr_break_init_loopgas_1
movd (%eax,%edx,4), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm7
movd %xmm7, (-4)(%ebx,%edx,4)
psrlq $(32), %xmm7
jl .Lsqr_init_loopgas_1
.Lsqr_break_init_loopgas_1:
movd %xmm7, (%ebx,%ecx,4)
mov $(1), %edx
.Lsqr_update_mul_loopgas_1:
mov %edx, %esi
add $(1), %esi
mov %edx, %edi
add %esi, %edi
movd (%eax,%edx,4), %xmm0
movd (%eax,%esi,4), %xmm1
pmuludq %xmm0, %xmm1
movd (%ebx,%edi,4), %xmm3
pandn %xmm7, %xmm7
.Lsqr_update_mul_inner_loopgas_1:
paddq %xmm1, %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (%ebx,%edi,4)
psrlq $(32), %xmm7
movd (4)(%eax,%esi,4), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%ebx,%edi,4), %xmm3
add $(1), %edi
add $(1), %esi
cmp %ecx, %esi
jl .Lsqr_update_mul_inner_loopgas_1
movd %xmm7, (%ebx,%edi,4)
add $(1), %edx
sub $(1), %esi
cmp %esi, %edx
jl .Lsqr_update_mul_loopgas_1
pandn %xmm7, %xmm7
movd %xmm7, (4)(%ebx,%edi,4)
pcmpeqd %xmm6, %xmm6
psrlq $(32), %xmm6
movd (%eax), %xmm0
pmuludq %xmm0, %xmm0
mov $(0), %edx
movd (%ebx), %xmm2
movd (4)(%ebx), %xmm3
pandn %xmm7, %xmm7
.Lsqr_loopgas_1:
paddq %xmm2, %xmm2
paddq %xmm3, %xmm3
movq %xmm0, %xmm1
pand %xmm6, %xmm0
psrlq $(32), %xmm1
paddq %xmm2, %xmm7
paddq %xmm0, %xmm7
movd %xmm7, (%ebx,%edx,8)
psrlq $(32), %xmm7
movd (4)(%eax,%edx,4), %xmm0
pmuludq %xmm0, %xmm0
paddq %xmm3, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%ebx,%edx,8)
psrlq $(32), %xmm7
add $(1), %edx
movd (%ebx,%edx,8), %xmm2
movd (4)(%ebx,%edx,8), %xmm3
cmp %ecx, %edx
jl .Lsqr_loopgas_1
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmultiplicationgas_1:
cmp %esi, %edi
jne .Lcommon_case_mulgas_1
.Lmul4gas_1:
cmp $(4), %edi
jne .Lmul5gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm1, (%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (16)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (20)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (24)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (28)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul5gas_1:
cmp $(5), %edi
jne .Lmul6gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd %xmm7, (%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (20)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (24)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (28)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul6gas_1:
cmp $(6), %edi
jne .Lmul7gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm1, (%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (24)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (28)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul7gas_1:
cmp $(7), %edi
jne .Lmul8gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd %xmm7, (%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (28)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul8gas_1:
cmp $(8), %edi
jne .Lmul9gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm1, (%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (32)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul9gas_1:
cmp $(9), %edi
jne .Lmul10gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd %xmm7, (%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (36)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul10gas_1:
cmp $(10), %edi
jne .Lmul11gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm1, (%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (40)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul11gas_1:
cmp $(11), %edi
jne .Lmul12gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd %xmm7, (%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (44)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (40)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul12gas_1:
cmp $(12), %edi
jne .Lmul13gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm1, (%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (48)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (40)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (44)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul13gas_1:
cmp $(13), %edi
jne .Lmul14gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd %xmm7, (%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (52)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (40)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (44)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (48)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul14gas_1:
cmp $(14), %edi
jne .Lmul15gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm1, (%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (56)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (40)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (44)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (48)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
movd (52)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (108)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul15gas_1:
cmp $(15), %edi
jne .Lmul16gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd %xmm7, (%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (60)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (40)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (44)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
movd (48)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (108)(%edx)
movd (52)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (104)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (112)(%edx)
movd (56)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (108)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (116)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul16gas_1:
cmp $(16), %edi
jne .Lmul17gas_1
movd (%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd %xmm1, (%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (64)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (40)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
movd (44)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (108)(%edx)
movd (48)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (104)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (112)(%edx)
movd (52)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (108)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (116)(%edx)
movd (56)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (104)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (112)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (116)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (120)(%edx)
movd (60)(%ebx), %xmm0
movd (%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (4)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (8)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (12)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (16)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (20)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (24)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (28)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (32)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (36)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (40)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (44)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd (48)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (108)(%edx)
psrlq $(32), %xmm1
movd (52)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd (56)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (116)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (116)(%edx)
psrlq $(32), %xmm1
movd (60)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (120)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (120)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (124)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lmul17gas_1:
cmp $(17), %edi
jne .Lcommon_case_mulgas_1
movd (%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd %xmm7, (%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (4)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (68)(%edx)
movd (4)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (4)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (4)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (8)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (72)(%edx)
movd (8)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (8)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (8)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (12)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (76)(%edx)
movd (12)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (12)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (12)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (16)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (80)(%edx)
movd (16)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (16)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (16)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (20)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (84)(%edx)
movd (20)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (20)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (20)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (24)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (88)(%edx)
movd (24)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (24)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (24)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (28)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (92)(%edx)
movd (28)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (28)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (28)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (32)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (96)(%edx)
movd (32)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (32)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (32)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (36)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (100)(%edx)
movd (36)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (36)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (36)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (40)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (104)(%edx)
movd (40)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (40)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (40)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (44)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (108)(%edx)
movd (44)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (44)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (44)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (48)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (104)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (112)(%edx)
movd (48)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (48)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (48)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (52)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (108)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (116)(%edx)
movd (52)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (52)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (52)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (56)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (104)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (112)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (116)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (120)(%edx)
movd (56)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (56)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (56)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (60)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (108)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (116)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (116)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (120)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (120)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (124)(%edx)
movd (60)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (60)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (60)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (64)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (68)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (72)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (76)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (80)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (84)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (88)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (92)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (96)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (100)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (104)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (108)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (112)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (116)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (116)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (120)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (120)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (124)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (124)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (128)(%edx)
movd (64)(%ebx), %xmm0
movd (%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (64)(%edx), %xmm2
paddq %xmm2, %xmm7
movd %xmm7, (64)(%edx)
psrlq $(32), %xmm7
movd (4)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (68)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (68)(%edx)
psrlq $(32), %xmm1
movd (8)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (72)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (72)(%edx)
psrlq $(32), %xmm7
movd (12)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (76)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (76)(%edx)
psrlq $(32), %xmm1
movd (16)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (80)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (80)(%edx)
psrlq $(32), %xmm7
movd (20)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (84)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (84)(%edx)
psrlq $(32), %xmm1
movd (24)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (88)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (88)(%edx)
psrlq $(32), %xmm7
movd (28)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (92)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (92)(%edx)
psrlq $(32), %xmm1
movd (32)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (96)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (96)(%edx)
psrlq $(32), %xmm7
movd (36)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (100)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (100)(%edx)
psrlq $(32), %xmm1
movd (40)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (104)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (104)(%edx)
psrlq $(32), %xmm7
movd (44)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (108)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (108)(%edx)
psrlq $(32), %xmm1
movd (48)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (112)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (112)(%edx)
psrlq $(32), %xmm7
movd (52)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (116)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (116)(%edx)
psrlq $(32), %xmm1
movd (56)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (120)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (120)(%edx)
psrlq $(32), %xmm7
movd (60)(%eax), %xmm1
pmuludq %xmm0, %xmm1
movd (124)(%edx), %xmm2
paddq %xmm2, %xmm1
paddq %xmm7, %xmm1
movd %xmm1, (124)(%edx)
psrlq $(32), %xmm1
movd (64)(%eax), %xmm7
pmuludq %xmm0, %xmm7
movd (128)(%edx), %xmm2
paddq %xmm2, %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (128)(%edx)
psrlq $(32), %xmm7
movd %xmm7, (132)(%edx)
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lcommon_case_mulgas_1:
cmp %edi, %esi
jae .Lini_resultgas_1
xor %esi, %edi
xor %edi, %esi
xor %esi, %edi
movl (16)(%ebp), %edi
movl (24)(%ebp), %esi
xor %ebx, %eax
xor %eax, %ebx
xor %ebx, %eax
movl (12)(%ebp), %eax
movl (20)(%ebp), %ebx
.Lini_resultgas_1:
add %edi, %esi
xor %ecx, %ecx
.Lmul_init_loopgas_1:
mov %ecx, (%edx)
add $(4), %edx
sub $(1), %esi
jne .Lmul_init_loopgas_1
mov %edi, %esi
movl (8)(%ebp), %edx
shl $(2), %edi
.LmacLoopgas_1:
movd (%ebx), %xmm0
pxor %xmm7, %xmm7
mov %edi, %esi
xor %ecx, %ecx
and $(28), %esi
jz .LtestSize_8gas_1
.Ltiny_loopgas_1:
movd (%ecx,%eax), %xmm1
movd (%edx,%ecx), %xmm2
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm1, %xmm7
movd %xmm7, (%edx,%ecx)
psrlq $(32), %xmm7
add $(4), %ecx
cmp %esi, %ecx
jl .Ltiny_loopgas_1
.LtestSize_8gas_1:
mov %edi, %esi
and $(32), %esi
jz .LtestSize_16gas_1
movd (%ecx,%eax), %xmm1
movd (%edx,%ecx), %xmm2
movd (4)(%ecx,%eax), %xmm3
movd (4)(%edx,%ecx), %xmm4
movd (8)(%ecx,%eax), %xmm5
movd (8)(%edx,%ecx), %xmm6
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
pmuludq %xmm0, %xmm5
paddq %xmm6, %xmm5
paddq %xmm1, %xmm7
movd (12)(%ecx,%eax), %xmm1
movd (12)(%edx,%ecx), %xmm2
movd %xmm7, (%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm3, %xmm7
movd (16)(%ecx,%eax), %xmm3
movd (16)(%edx,%ecx), %xmm4
movd %xmm7, (4)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
paddq %xmm5, %xmm7
movd (20)(%ecx,%eax), %xmm5
movd (20)(%edx,%ecx), %xmm6
movd %xmm7, (8)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm5
paddq %xmm6, %xmm5
paddq %xmm1, %xmm7
movd (24)(%ecx,%eax), %xmm1
movd (24)(%edx,%ecx), %xmm2
movd %xmm7, (12)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm3, %xmm7
movd (28)(%ecx,%eax), %xmm3
movd (28)(%edx,%ecx), %xmm4
movd %xmm7, (16)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
paddq %xmm5, %xmm7
movd %xmm7, (20)(%edx,%ecx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (24)(%edx,%ecx)
psrlq $(32), %xmm7
paddq %xmm3, %xmm7
movd %xmm7, (28)(%edx,%ecx)
psrlq $(32), %xmm7
add $(32), %ecx
.LtestSize_16gas_1:
mov %edi, %esi
and $(4294967232), %esi
jz .Lnext_termgas_1
.Lhuge_loopgas_1:
movd (%ecx,%eax), %xmm1
movd (%edx,%ecx), %xmm2
movd (4)(%ecx,%eax), %xmm3
movd (4)(%edx,%ecx), %xmm4
movd (8)(%ecx,%eax), %xmm5
movd (8)(%edx,%ecx), %xmm6
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
pmuludq %xmm0, %xmm5
paddq %xmm6, %xmm5
paddq %xmm1, %xmm7
movd (12)(%ecx,%eax), %xmm1
movd (12)(%edx,%ecx), %xmm2
movd %xmm7, (%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm3, %xmm7
movd (16)(%ecx,%eax), %xmm3
movd (16)(%edx,%ecx), %xmm4
movd %xmm7, (4)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
paddq %xmm5, %xmm7
movd (20)(%ecx,%eax), %xmm5
movd (20)(%edx,%ecx), %xmm6
movd %xmm7, (8)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm5
paddq %xmm6, %xmm5
paddq %xmm1, %xmm7
movd (24)(%ecx,%eax), %xmm1
movd (24)(%edx,%ecx), %xmm2
movd %xmm7, (12)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm3, %xmm7
movd (28)(%ecx,%eax), %xmm3
movd (28)(%edx,%ecx), %xmm4
movd %xmm7, (16)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
paddq %xmm5, %xmm7
movd (32)(%ecx,%eax), %xmm5
movd (32)(%edx,%ecx), %xmm6
movd %xmm7, (20)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm5
paddq %xmm6, %xmm5
paddq %xmm1, %xmm7
movd (36)(%ecx,%eax), %xmm1
movd (36)(%edx,%ecx), %xmm2
movd %xmm7, (24)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm3, %xmm7
movd (40)(%ecx,%eax), %xmm3
movd (40)(%edx,%ecx), %xmm4
movd %xmm7, (28)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
paddq %xmm5, %xmm7
movd (44)(%ecx,%eax), %xmm5
movd (44)(%edx,%ecx), %xmm6
movd %xmm7, (32)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm5
paddq %xmm6, %xmm5
paddq %xmm1, %xmm7
movd (48)(%ecx,%eax), %xmm1
movd (48)(%edx,%ecx), %xmm2
movd %xmm7, (36)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm3, %xmm7
movd (52)(%ecx,%eax), %xmm3
movd (52)(%edx,%ecx), %xmm4
movd %xmm7, (40)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm3
paddq %xmm4, %xmm3
paddq %xmm5, %xmm7
movd (56)(%ecx,%eax), %xmm5
movd (56)(%edx,%ecx), %xmm6
movd %xmm7, (44)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm5
paddq %xmm6, %xmm5
paddq %xmm1, %xmm7
movd (60)(%ecx,%eax), %xmm1
movd (60)(%edx,%ecx), %xmm2
movd %xmm7, (48)(%edx,%ecx)
psrlq $(32), %xmm7
pmuludq %xmm0, %xmm1
paddq %xmm2, %xmm1
paddq %xmm3, %xmm7
movd %xmm7, (52)(%edx,%ecx)
psrlq $(32), %xmm7
paddq %xmm5, %xmm7
movd %xmm7, (56)(%edx,%ecx)
psrlq $(32), %xmm7
paddq %xmm1, %xmm7
movd %xmm7, (60)(%edx,%ecx)
psrlq $(32), %xmm7
add $(64), %ecx
cmp %esi, %ecx
jl .Lhuge_loopgas_1
.Lnext_termgas_1:
movd %xmm7, (%edx,%ecx)
add $(4), %ebx
add $(4), %edx
subl $(1), (24)(%ebp)
jne .LmacLoopgas_1
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
.Lfe1:
.size s8_cpMulAdc_BNU_school, .Lfe1-(s8_cpMulAdc_BNU_school)
|
; A190716: a(2*n) = 2*n and a(2*n-1) = A054569(n).
; 1,2,7,4,21,6,43,8,73,10,111,12,157,14,211,16,273,18,343,20,421,22,507,24,601,26,703,28,813,30,931,32,1057,34,1191,36,1333,38,1483,40,1641,42,1807,44,1981,46,2163,48,2353,50,2551,52,2757,54,2971,56,3193
mov $1,-2
lpb $1,$0
bin $1,$0
mul $0,$1
bin $1,$2
lpe
mov $1,$0
add $1,1
|
;;
;; Copyright (c) 2012-2018, Intel Corporation
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions are met:
;;
;; * Redistributions of source code must retain the above copyright notice,
;; this list of conditions and the following disclaimer.
;; * Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;; * Neither the name of Intel Corporation nor the names of its contributors
;; may be used to endorse or promote products derived from this software
;; without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
;; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
;; CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
;; OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;
%include "include/os.asm"
%include "job_aes_hmac.asm"
%include "mb_mgr_datastruct.asm"
%include "include/reg_sizes.asm"
%include "include/memcpy.asm"
%include "include/const.inc"
;%define DO_DBGPRINT
%include "include/dbgprint.asm"
extern sha1_mult_sse
section .data
default rel
align 16
byteswap: ;ddq 0x0c0d0e0f08090a0b0405060700010203
dq 0x0405060700010203, 0x0c0d0e0f08090a0b
section .text
%if 1
%ifdef LINUX
%define arg1 rdi
%define arg2 rsi
%define reg3 rcx
%define reg4 rdx
%else
%define arg1 rcx
%define arg2 rdx
%define reg3 rdi
%define reg4 rsi
%endif
%define state arg1
%define job arg2
%define len2 arg2
; idx needs to be in rbx, rbp, r12-r15
%define last_len rbp
%define idx rbp
%define p r11
%define start_offset r11
%define unused_lanes rbx
%define tmp4 rbx
%define job_rax rax
%define len rax
%define size_offset reg3
%define tmp2 reg3
%define lane reg4
%define tmp3 reg4
%define extra_blocks r8
%define tmp r9
%define p2 r9
%define lane_data r10
%endif
; This routine clobbers rdi, rsi, rbx, rbp
struc STACK
_gpr_save: resq 4
_rsp_save: resq 1
endstruc
; JOB* submit_job_hmac_sse(MB_MGR_HMAC_SHA_1_OOO *state, JOB_AES_HMAC *job)
; arg 1 : rcx : state
; arg 2 : rdx : job
MKGLOBAL(submit_job_hmac_sse,function, internal)
submit_job_hmac_sse:
mov rax, rsp
sub rsp, STACK_size
and rsp, -16
mov [rsp + _gpr_save + 8*0], rbx
mov [rsp + _gpr_save + 8*1], rbp
%ifndef LINUX
mov [rsp + _gpr_save + 8*2], rsi
mov [rsp + _gpr_save + 8*3], rdi
%endif
mov [rsp + _rsp_save], rax ; original SP
DBGPRINTL "enter sha1-sse submit"
mov unused_lanes, [state + _unused_lanes]
movzx lane, BYTE(unused_lanes)
shr unused_lanes, 8
imul lane_data, lane, _HMAC_SHA1_LANE_DATA_size
lea lane_data, [state + _ldata + lane_data]
mov [state + _unused_lanes], unused_lanes
mov len, [job + _msg_len_to_hash_in_bytes]
mov tmp, len
shr tmp, 6 ; divide by 64, len in terms of blocks
mov [lane_data + _job_in_lane], job
mov dword [lane_data + _outer_done], 0
movdqa xmm0, [state + _lens]
XPINSRW xmm0, xmm1, p, lane, tmp, scale_x16
movdqa [state + _lens], xmm0
mov last_len, len
and last_len, 63
lea extra_blocks, [last_len + 9 + 63]
shr extra_blocks, 6
mov [lane_data + _extra_blocks], DWORD(extra_blocks)
mov p, [job + _src]
add p, [job + _hash_start_src_offset_in_bytes]
mov [state + _args_data_ptr + PTR_SZ*lane], p
cmp len, 64
jb copy_lt64
fast_copy:
add p, len
movdqu xmm0, [p - 64 + 0*16]
movdqu xmm1, [p - 64 + 1*16]
movdqu xmm2, [p - 64 + 2*16]
movdqu xmm3, [p - 64 + 3*16]
movdqa [lane_data + _extra_block + 0*16], xmm0
movdqa [lane_data + _extra_block + 1*16], xmm1
movdqa [lane_data + _extra_block + 2*16], xmm2
movdqa [lane_data + _extra_block + 3*16], xmm3
end_fast_copy:
mov size_offset, extra_blocks
shl size_offset, 6
sub size_offset, last_len
add size_offset, 64-8
mov [lane_data + _size_offset], DWORD(size_offset)
mov start_offset, 64
sub start_offset, last_len
mov [lane_data + _start_offset], DWORD(start_offset)
lea tmp, [8*64 + 8*len]
bswap tmp
mov [lane_data + _extra_block + size_offset], tmp
mov tmp, [job + _auth_key_xor_ipad]
movdqu xmm0, [tmp]
mov DWORD(tmp), [tmp + 4*4]
movd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*lane + 0*SHA1_DIGEST_ROW_SIZE], xmm0
pextrd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*lane + 1*SHA1_DIGEST_ROW_SIZE], xmm0, 1
pextrd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*lane + 2*SHA1_DIGEST_ROW_SIZE], xmm0, 2
pextrd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*lane + 3*SHA1_DIGEST_ROW_SIZE], xmm0, 3
mov [state + _args_digest + SHA1_DIGEST_WORD_SIZE*lane + 4*SHA1_DIGEST_ROW_SIZE], DWORD(tmp)
test len, ~63
jnz ge64_bytes
lt64_bytes:
movdqa xmm0, [state + _lens]
XPINSRW xmm0, xmm1, tmp, lane, extra_blocks, scale_x16
movdqa [state + _lens], xmm0
lea tmp, [lane_data + _extra_block + start_offset]
mov [state + _args_data_ptr + PTR_SZ*lane], tmp
mov dword [lane_data + _extra_blocks], 0
ge64_bytes:
cmp unused_lanes, 0xff
jne return_null
movdqa xmm0, [state + _lens]
jmp start_loop
align 16
start_loop:
; Find min length
phminposuw xmm1, xmm0
pextrw len2, xmm1, 0 ; min value
pextrw idx, xmm1, 1 ; min index (0...3)
cmp len2, 0
je len_is_0
pshuflw xmm1, xmm1, 0
psubw xmm0, xmm1
movdqa [state + _lens], xmm0
; "state" and "args" are the same address, arg1
; len is arg2
call sha1_mult_sse
; state is intact
len_is_0:
; process completed job "idx"
imul lane_data, idx, _HMAC_SHA1_LANE_DATA_size
lea lane_data, [state + _ldata + lane_data]
mov DWORD(extra_blocks), [lane_data + _extra_blocks]
cmp extra_blocks, 0
jne proc_extra_blocks
cmp dword [lane_data + _outer_done], 0
jne end_loop
proc_outer:
mov dword [lane_data + _outer_done], 1
mov DWORD(size_offset), [lane_data + _size_offset]
mov qword [lane_data + _extra_block + size_offset], 0
movdqa xmm1, [state + _lens]
XPINSRW xmm1, xmm2, tmp, idx, 1, scale_x16
movdqa [state + _lens], xmm1
lea tmp, [lane_data + _outer_block]
mov job, [lane_data + _job_in_lane]
mov [state + _args_data_ptr + PTR_SZ*idx], tmp
movd xmm0, [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 0*SHA1_DIGEST_ROW_SIZE]
pinsrd xmm0, [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 1*SHA1_DIGEST_ROW_SIZE], 1
pinsrd xmm0, [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 2*SHA1_DIGEST_ROW_SIZE], 2
pinsrd xmm0, [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 3*SHA1_DIGEST_ROW_SIZE], 3
pshufb xmm0, [rel byteswap]
mov DWORD(tmp), [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 4*SHA1_DIGEST_ROW_SIZE]
bswap DWORD(tmp)
movdqa [lane_data + _outer_block], xmm0
mov [lane_data + _outer_block + 4*SHA1_DIGEST_WORD_SIZE], DWORD(tmp)
mov tmp, [job + _auth_key_xor_opad]
movdqu xmm0, [tmp]
mov DWORD(tmp), [tmp + 4*4]
movd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 0*SHA1_DIGEST_ROW_SIZE], xmm0
pextrd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 1*SHA1_DIGEST_ROW_SIZE], xmm0, 1
pextrd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 2*SHA1_DIGEST_ROW_SIZE], xmm0, 2
pextrd [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 3*SHA1_DIGEST_ROW_SIZE], xmm0, 3
mov [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 4*SHA1_DIGEST_ROW_SIZE], DWORD(tmp)
movdqa xmm0, xmm1
jmp start_loop
align 16
proc_extra_blocks:
mov DWORD(start_offset), [lane_data + _start_offset]
movdqa xmm0, [state + _lens]
XPINSRW xmm0, xmm1, tmp, idx, extra_blocks, scale_x16
movdqa [state + _lens], xmm0
lea tmp, [lane_data + _extra_block + start_offset]
mov [state + _args_data_ptr + PTR_SZ*idx], tmp
mov dword [lane_data + _extra_blocks], 0
jmp start_loop
align 16
copy_lt64:
;; less than one message block of data
;; beginning of source block
;; destination extrablock but backwards by len from where 0x80 pre-populated
lea p2, [lane_data + _extra_block + 64]
sub p2, len
memcpy_sse_64_1 p2, p, len, tmp4, tmp2, xmm0, xmm1, xmm2, xmm3
mov unused_lanes, [state + _unused_lanes]
jmp end_fast_copy
return_null:
xor job_rax, job_rax
jmp return
align 16
end_loop:
mov job_rax, [lane_data + _job_in_lane]
mov unused_lanes, [state + _unused_lanes]
mov qword [lane_data + _job_in_lane], 0
or dword [job_rax + _status], STS_COMPLETED_HMAC
shl unused_lanes, 8
or unused_lanes, idx
mov [state + _unused_lanes], unused_lanes
mov p, [job_rax + _auth_tag_output]
; copy 12 bytes
mov DWORD(tmp), [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 0*SHA1_DIGEST_ROW_SIZE]
mov DWORD(tmp2), [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 1*SHA1_DIGEST_ROW_SIZE]
mov DWORD(tmp3), [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 2*SHA1_DIGEST_ROW_SIZE]
bswap DWORD(tmp)
bswap DWORD(tmp2)
bswap DWORD(tmp3)
mov [p + 0*SHA1_DIGEST_WORD_SIZE], DWORD(tmp)
mov [p + 1*SHA1_DIGEST_WORD_SIZE], DWORD(tmp2)
mov [p + 2*SHA1_DIGEST_WORD_SIZE], DWORD(tmp3)
cmp qword [job_rax + _auth_tag_output_len_in_bytes], 12
je return
;; copy remaining 8 bytes to return 20 byte digest
mov DWORD(tmp), [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 3*SHA1_DIGEST_ROW_SIZE]
mov DWORD(tmp2), [state + _args_digest + SHA1_DIGEST_WORD_SIZE*idx + 4*SHA1_DIGEST_ROW_SIZE]
bswap DWORD(tmp)
bswap DWORD(tmp2)
mov [p + 3*SHA1_DIGEST_WORD_SIZE], DWORD(tmp)
mov [p + 4*SHA1_DIGEST_WORD_SIZE], DWORD(tmp2)
return:
mov rbx, [rsp + _gpr_save + 8*0]
mov rbp, [rsp + _gpr_save + 8*1]
%ifndef LINUX
mov rsi, [rsp + _gpr_save + 8*2]
mov rdi, [rsp + _gpr_save + 8*3]
%endif
mov rsp, [rsp + _rsp_save] ; original SP
ret
%ifdef LINUX
section .note.GNU-stack noalloc noexec nowrite progbits
%endif
|
/*
* Copyright (c) 2018 Isetta
*/
#include "SinglePlayerLevel.h"
#include <IsettaEngine.h>
// GAME
#include <Input/Input.h>
#include "Consts.h"
#include "Gameplay/Damageable.h"
#include "Player/PlayerHealth.h"
using namespace Isetta;
using CameraProperty = CameraComponent::Property;
void SinglePlayerLevel::Load() {
// TODO: remove
Font::AddFontFromFile("fonts\\DeatheMaach.otf", Consts::MID_SIZE, "Deathe");
Entity* cameraEntity = Entity::Instantiate("Camera");
cameraEntity->AddComponent<CameraComponent>();
cameraEntity->SetTransform(Math::Vector3{0, 5, 10}, Math::Vector3{-15, 0, 0},
Math::Vector3::one);
Entity* player = Entity::Instantiate("Player");
auto damage = player->AddComponent<Damageable>(100);
player->AddComponent<PlayerHealth>();
Input::RegisterMousePressCallback(MouseButton::LEFT,
[damage]() { damage->DealDamage(-1, 10); });
Input::RegisterKeyPressCallback(KeyCode::ESCAPE,
[]() { Application::Exit(); });
}
|
.file "-"
.file 1 "/home/mgodbold/dev/gcc-explorer/-"
.file 2 "/home/mgodbold/dev/gcc-explorer/<stdin>"
.section .debug_info,"",@progbits
.Lsection_info:
.section .debug_abbrev,"",@progbits
.Lsection_abbrev:
.section .debug_aranges,"",@progbits
.section .debug_macinfo,"",@progbits
.section .debug_line,"",@progbits
.Lsection_line:
.section .debug_loc,"",@progbits
.section .debug_pubnames,"",@progbits
.section .debug_pubtypes,"",@progbits
.section .debug_str,"",@progbits
.Lsection_str:
.section .debug_ranges,"",@progbits
.Ldebug_range:
.section .debug_loc,"",@progbits
.Lsection_debug_loc:
.text
.Ltext_begin:
.data
.text
.globl main
.align 16, 0x90
.type main,@function
main: # @main
.Ltmp2:
.cfi_startproc
.Lfunc_begin0:
.loc 2 2 0 # <stdin>:2:0
# BB#0:
pushq %rbp
.Ltmp3:
.cfi_def_cfa_offset 16
.Ltmp4:
.cfi_offset %rbp, -16
movq %rsp, %rbp
.Ltmp5:
.cfi_def_cfa_register %rbp
.loc 2 3 1 prologue_end # <stdin>:3:1
.Ltmp6:
movl $.L.str, %edi
xorb %al, %al
callq printf
.loc 2 4 3 # <stdin>:4:3
movl $str, %edi
callq puts
xorl %eax, %eax
.loc 2 5 1 # <stdin>:5:1
popq %rbp
ret
.Ltmp7:
.Ltmp8:
.size main, .Ltmp8-main
.Lfunc_end0:
.Ltmp9:
.cfi_endproc
.Leh_func_end0:
.type .L.str,@object # @.str
.section .rodata.str1.1,"aMS",@progbits,1
.L.str:
.asciz "Hello world"
.size .L.str, 12
.type str,@object # @str
.section .rodata,"a",@progbits
str:
.asciz "moo"
.size str, 4
.text
.Ltext_end:
.data
.Ldata_end:
.text
.Lsection_end1:
.section .debug_info,"",@progbits
.Linfo_begin1:
.long 175 # Length of Compilation Unit Info
.short 2 # DWARF version number
.long .Labbrev_begin # Offset Into Abbrev. Section
.byte 8 # Address Size (in bytes)
.byte 1 # Abbrev [1] 0xb:0xa8 DW_TAG_compile_unit
.ascii "Ubuntu clang version 3.0-6ubuntu3 (tags/RELEASE_30/final) (based on LLVM 3.0)" # DW_AT_producer
.byte 0
.short 4 # DW_AT_language
.byte 45 # DW_AT_name
.byte 0
.quad 0 # DW_AT_entry_pc
.long .Lsection_line # DW_AT_stmt_list
.ascii "/home/mgodbold/dev/gcc-explorer" # DW_AT_comp_dir
.byte 0
.byte 1 # DW_AT_APPLE_optimized
.byte 2 # Abbrev [2] 0x8b:0x20 DW_TAG_subprogram
.ascii "main" # DW_AT_name
.byte 0
.byte 2 # DW_AT_decl_file
.byte 2 # DW_AT_decl_line
.byte 1 # DW_AT_prototyped
.long 171 # DW_AT_type
.byte 1 # DW_AT_external
.quad .Lfunc_begin0 # DW_AT_low_pc
.quad .Lfunc_end0 # DW_AT_high_pc
.byte 1 # DW_AT_frame_base
.byte 86
.byte 3 # Abbrev [3] 0xab:0x7 DW_TAG_base_type
.ascii "int" # DW_AT_name
.byte 0
.byte 5 # DW_AT_encoding
.byte 4 # DW_AT_byte_size
.byte 0 # End Of Children Mark
.Linfo_end1:
.section .debug_abbrev,"",@progbits
.Labbrev_begin:
.byte 1 # Abbreviation Code
.byte 17 # DW_TAG_compile_unit
.byte 1 # DW_CHILDREN_yes
.byte 37 # DW_AT_producer
.byte 8 # DW_FORM_string
.byte 19 # DW_AT_language
.byte 5 # DW_FORM_data2
.byte 3 # DW_AT_name
.byte 8 # DW_FORM_string
.byte 82 # DW_AT_entry_pc
.byte 1 # DW_FORM_addr
.byte 16 # DW_AT_stmt_list
.byte 6 # DW_FORM_data4
.byte 27 # DW_AT_comp_dir
.byte 8 # DW_FORM_string
.ascii "\341\177" # DW_AT_APPLE_optimized
.byte 12 # DW_FORM_flag
.byte 0 # EOM(1)
.byte 0 # EOM(2)
.byte 2 # Abbreviation Code
.byte 46 # DW_TAG_subprogram
.byte 0 # DW_CHILDREN_no
.byte 3 # DW_AT_name
.byte 8 # DW_FORM_string
.byte 58 # DW_AT_decl_file
.byte 11 # DW_FORM_data1
.byte 59 # DW_AT_decl_line
.byte 11 # DW_FORM_data1
.byte 39 # DW_AT_prototyped
.byte 12 # DW_FORM_flag
.byte 73 # DW_AT_type
.byte 19 # DW_FORM_ref4
.byte 63 # DW_AT_external
.byte 12 # DW_FORM_flag
.byte 17 # DW_AT_low_pc
.byte 1 # DW_FORM_addr
.byte 18 # DW_AT_high_pc
.byte 1 # DW_FORM_addr
.byte 64 # DW_AT_frame_base
.byte 10 # DW_FORM_block1
.byte 0 # EOM(1)
.byte 0 # EOM(2)
.byte 3 # Abbreviation Code
.byte 36 # DW_TAG_base_type
.byte 0 # DW_CHILDREN_no
.byte 3 # DW_AT_name
.byte 8 # DW_FORM_string
.byte 62 # DW_AT_encoding
.byte 11 # DW_FORM_data1
.byte 11 # DW_AT_byte_size
.byte 11 # DW_FORM_data1
.byte 0 # EOM(1)
.byte 0 # EOM(2)
.byte 0 # EOM(3)
.Labbrev_end:
.section .debug_pubnames,"",@progbits
.Lset0 = .Lpubnames_end1-.Lpubnames_begin1 # Length of Public Names Info
.long .Lset0
.Lpubnames_begin1:
.short 2 # DWARF Version
.long .Linfo_begin1 # Offset of Compilation Unit Info
.Lset1 = .Linfo_end1-.Linfo_begin1 # Compilation Unit Length
.long .Lset1
.long 139 # DIE offset
.asciz "main" # External Name
.long 0 # End Mark
.Lpubnames_end1:
.section .debug_pubtypes,"",@progbits
.Lset2 = .Lpubtypes_end1-.Lpubtypes_begin1 # Length of Public Types Info
.long .Lset2
.Lpubtypes_begin1:
.short 2 # DWARF Version
.long .Linfo_begin1 # Offset of Compilation Unit Info
.Lset3 = .Linfo_end1-.Linfo_begin1 # Compilation Unit Length
.long .Lset3
.long 0 # End Mark
.Lpubtypes_end1:
.section .debug_aranges,"",@progbits
.section .debug_ranges,"",@progbits
.section .debug_macinfo,"",@progbits
.section ".note.GNU-stack","",@progbits
|
; Copyright 2005-2013 Intel Corporation. All Rights Reserved.
;
; This file is part of Threading Building Blocks.
;
; Threading Building Blocks is free software; you can redistribute it
; and/or modify it under the terms of the GNU General Public License
; version 2 as published by the Free Software Foundation.
;
; Threading Building Blocks is distributed in the hope that it will be
; useful, but WITHOUT ANY WARRANTY; without even the implied warranty
; of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with Threading Building Blocks; if not, write to the Free Software
; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
;
; As a special exception, you may use this file as part of a free software
; library without restriction. Specifically, if other files instantiate
; templates or use macros or inline functions from this file, or you compile
; this file and link it with other files to produce an executable, this
; file does not by itself cause the resulting executable to be covered by
; the GNU General Public License. This exception does not however
; invalidate any other reasons why the executable file might be covered by
; the GNU General Public License.
.686
.model flat,c
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchadd1
__TBB_machine_fetchadd1:
mov edx,4[esp]
mov eax,8[esp]
lock xadd [edx],al
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchstore1
__TBB_machine_fetchstore1:
mov edx,4[esp]
mov eax,8[esp]
lock xchg [edx],al
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_cmpswp1
__TBB_machine_cmpswp1:
mov edx,4[esp]
mov ecx,8[esp]
mov eax,12[esp]
lock cmpxchg [edx],cl
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchadd2
__TBB_machine_fetchadd2:
mov edx,4[esp]
mov eax,8[esp]
lock xadd [edx],ax
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchstore2
__TBB_machine_fetchstore2:
mov edx,4[esp]
mov eax,8[esp]
lock xchg [edx],ax
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_cmpswp2
__TBB_machine_cmpswp2:
mov edx,4[esp]
mov ecx,8[esp]
mov eax,12[esp]
lock cmpxchg [edx],cx
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchadd4
__TBB_machine_fetchadd4:
mov edx,4[esp]
mov eax,8[esp]
lock xadd [edx],eax
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchstore4
__TBB_machine_fetchstore4:
mov edx,4[esp]
mov eax,8[esp]
lock xchg [edx],eax
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_cmpswp4
__TBB_machine_cmpswp4:
mov edx,4[esp]
mov ecx,8[esp]
mov eax,12[esp]
lock cmpxchg [edx],ecx
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchadd8
__TBB_machine_fetchadd8:
push ebx
push edi
mov edi,12[esp]
mov eax,[edi]
mov edx,4[edi]
__TBB_machine_fetchadd8_loop:
mov ebx,16[esp]
mov ecx,20[esp]
add ebx,eax
adc ecx,edx
lock cmpxchg8b qword ptr [edi]
jnz __TBB_machine_fetchadd8_loop
pop edi
pop ebx
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_fetchstore8
__TBB_machine_fetchstore8:
push ebx
push edi
mov edi,12[esp]
mov ebx,16[esp]
mov ecx,20[esp]
mov eax,[edi]
mov edx,4[edi]
__TBB_machine_fetchstore8_loop:
lock cmpxchg8b qword ptr [edi]
jnz __TBB_machine_fetchstore8_loop
pop edi
pop ebx
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_cmpswp8
__TBB_machine_cmpswp8:
push ebx
push edi
mov edi,12[esp]
mov ebx,16[esp]
mov ecx,20[esp]
mov eax,24[esp]
mov edx,28[esp]
lock cmpxchg8b qword ptr [edi]
pop edi
pop ebx
ret
.code
ALIGN 4
PUBLIC c __TBB_machine_load8
__TBB_machine_Load8:
; If location is on stack, compiler may have failed to align it correctly, so we do dynamic check.
mov ecx,4[esp]
test ecx,7
jne load_slow
; Load within a cache line
sub esp,12
fild qword ptr [ecx]
fistp qword ptr [esp]
mov eax,[esp]
mov edx,4[esp]
add esp,12
ret
load_slow:
; Load is misaligned. Use cmpxchg8b.
push ebx
push edi
mov edi,ecx
xor eax,eax
xor ebx,ebx
xor ecx,ecx
xor edx,edx
lock cmpxchg8b qword ptr [edi]
pop edi
pop ebx
ret
EXTRN __TBB_machine_store8_slow:PROC
.code
ALIGN 4
PUBLIC c __TBB_machine_store8
__TBB_machine_Store8:
; If location is on stack, compiler may have failed to align it correctly, so we do dynamic check.
mov ecx,4[esp]
test ecx,7
jne __TBB_machine_store8_slow ;; tail call to tbb_misc.cpp
fild qword ptr 8[esp]
fistp qword ptr [ecx]
ret
end
|
/**
* Upbit Open API
* ## REST API for Upbit Exchange - Base URL: [https://api.upbit.com] - Official Upbit API Documents: [https://docs.upbit.com] - Official Support email: [open-api@upbit.com]
*
* OpenAPI spec version: 1.1.6
* Contact: ujhin942@gmail.com
*
* NOTE: This class is auto generated by the swagger code generator 2.4.17.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
#include "Object.h"
namespace io {
namespace swagger {
namespace client {
namespace model {
Object::Object()
{
m_object = web::json::value::object();
}
Object::~Object()
{
}
void Object::validate()
{
// TODO: implement validation
}
web::json::value Object::toJson() const
{
return m_object;
}
void Object::fromJson(web::json::value& val)
{
if (val.is_object())
{
m_object = val;
}
}
void Object::toMultipart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix) const
{
utility::string_t namePrefix = prefix;
if(namePrefix.size() > 0 && namePrefix.substr(namePrefix.size() - 1) != utility::conversions::to_string_t("."))
{
namePrefix += utility::conversions::to_string_t(".");
}
multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("object"), m_object));
}
void Object::fromMultiPart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix)
{
utility::string_t namePrefix = prefix;
if(namePrefix.size() > 0 && namePrefix.substr(namePrefix.size() - 1) != utility::conversions::to_string_t("."))
{
namePrefix += utility::conversions::to_string_t(".");
}
m_object = ModelBase::valueFromHttpContent(multipart->getContent(namePrefix + utility::conversions::to_string_t("object")));
}
web::json::value Object::getValue(const utility::string_t& key) const
{
return m_object.at(key);
}
void Object::setValue(const utility::string_t& key, const web::json::value& value)
{
m_object[key] = value;
}
}
}
}
}
|
#include <MyHeaders\Dialog.h>
#include <MyHeaders\Button.h>
#include <MyHeaders\CheckBox.h>
#include <MyHeaders\ListView.h>
#include <string>
using std::wstring;
using std::to_wstring;
#include "resource.h"
struct Controls
{
Button btn;
CheckBox cbox;
ListView lv;
};
DIALOGPROC(proc, handle, msg, wp, lp)
{
//initialize objects
if (msg == WM_INITDIALOG)
{
Controls *c = (Controls*)lp;
c->btn.Init(handle, IDC_BUTTON1);
c->cbox.Init(handle, IDC_CHECK1);
c->lv.Init(handle, IDC_LIST1);
c->cbox.SetState(checkbox::state::Check);
c->lv.AddColumn(L"This is a test", 0, 200);
return 1;
}
if (msg == WM_COMMAND)
{
if (LOWORD(wp) == IDCANCEL)
{
DestroyWindow(handle);
return 1;
}
Controls *c = (Controls*)GetWindowLongPtr(handle, GWLP_USERDATA);
if (LOWORD(wp) == IDC_BUTTON1)
{
//create a random number, convert it to wstring
wstring str = to_wstring(rand()).c_str();
//add it to the list view
c->lv.InsertText((TCHAR*)str.c_str(), 0);
return 1;
}
if (LOWORD(wp) == IDC_CHECK1)
{
c->btn.Enable(c->cbox.GetState());
return 1;
}
}
return 0;
}
WINMAIN(hin, cmd, show)
{
Controls ctrl;
//the address of ctrl will be passed as the LPARAM for WM_INITDIALOG
Dialog d(IDD_DIALOG1, proc, &ctrl);
//the address of ctrl will be available via GetWindowLongPtr
d.SetWLongPtr(GWLP_USERDATA, (LONG_PTR)&ctrl);
//run until user quits
d.MessageLoop();
} |
; A049398: a(n) = (n+9)!/9!.
; 1,10,110,1320,17160,240240,3603600,57657600,980179200,17643225600,335221286400,6704425728000,140792940288000,3097444686336000,71241227785728000,1709789466857472000,42744736671436800000,1111363153457356800000,30006805143348633600000,840190544013761740800000,24365525776399090483200000,730965773291972714496000000,22659938972051154149376000000,725118047105636932780032000000,23928895554486018781741056000000,813582448852524638579195904000000,28475385709838362350271856640000000
add $0,9
seq $0,142 ; Factorial numbers: n! = 1*2*3*4*...*n (order of symmetric group S_n, number of permutations of n letters).
div $0,362880
|
test_device():
sub rsp, 24
call rand
mov rax, QWORD PTR [rsp]
mov edx, DWORD PTR [rsp]
shr rax, 12
and edx, -258049
add eax, 1
and eax, 63
mov ecx, eax
sal ecx, 12
or edx, ecx
mov DWORD PTR [rsp], edx
mov DWORD PTR [rsp+12], eax
add rsp, 24
ret
|
// Problem Code: abc158_c
#include <iostream>
#include <cmath>
using namespace std;
int tax_increase(int A, int B) {
for (int i = ceil(A / 0.08); int(i * 0.08) == A; i++)
if (int(i * 0.1) == B)
return i;
return -1;
}
int main() {
int A, B;
cin >> A >> B;
cout << tax_increase(A, B);
return 0;
} |
; A198309: Moore lower bound on the order of a (9,g)-cage.
; Submitted by Jon Maiga
; 10,18,82,146,658,1170,5266,9362,42130,74898,337042,599186,2696338,4793490,21570706,38347922,172565650,306783378,1380525202,2454267026,11044201618,19634136210,88353612946,157073089682,706828903570,1256584717458,5654631228562,10052677739666,45237049828498,80421421917330,361896398627986,643371375338642,2895171189023890,5146971002709138,23161369512191122,41175768021673106,185290956097528978,329406144173384850,1482327648780231826,2635249153387078802,11858621190241854610,21081993227096630418
mov $1,$0
mod $0,2
add $0,1
lpb $1
mul $0,8
add $0,2
sub $1,2
lpe
mul $0,7
sub $0,7
div $0,7
mul $0,8
add $0,10
|
; Assert that a particular label immediately follows; this documents where code
; falls through into following code and helps to detect problems if other code
; is accidentally interposed.
macro fall_through_to target
assert P% == target
endmacro
macro inc_word x
inc x
bne no_carry
inc x+1
.no_carry
endmacro
macro inc_word_high x
bcc no_carry
inc x
.no_carry
endmacro
; Helper macro for equ_hex_char
macro equ_hex_digit n
assert n <= &f
if n <= &9
equb '0'+n
else
equb 'A'+(n-10)
endif
endmacro
; Helper macro for equ_hex16
macro equ_hex_char word, digit
equ_hex_digit (word >> (digit*4)) and &f
endmacro
; Generate a string representation of a 16-bit value as hex.
macro equ_hex16 word
equ_hex_char word, 3
equ_hex_char word, 2
equ_hex_char word, 1
equ_hex_char word, 0
endmacro
|
;
; jdcolss2.asm - colorspace conversion (SSE2)
;
; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
; Copyright 2009 D. R. Commander
;
; Based on
; x86 SIMD extension for IJG JPEG library
; Copyright (C) 1999-2006, MIYASAKA Masaru.
; For conditions of distribution and use, see copyright notice in jsimdext.inc
;
; This file should be assembled with NASM (Netwide Assembler),
; can *not* be assembled with Microsoft's MASM or any compatible
; assembler (including Borland's Turbo Assembler).
; NASM is available from http://nasm.sourceforge.net/ or
; http://sourceforge.net/project/showfiles.php?group_id=6208
;
; [TAB8]
%include "jsimdext.inc"
; --------------------------------------------------------------------------
%define SCALEBITS 16
F_0_344 equ 22554 ; FIX(0.34414)
F_0_714 equ 46802 ; FIX(0.71414)
F_1_402 equ 91881 ; FIX(1.40200)
F_1_772 equ 116130 ; FIX(1.77200)
F_0_402 equ (F_1_402 - 65536) ; FIX(1.40200) - FIX(1)
F_0_285 equ ( 65536 - F_0_714) ; FIX(1) - FIX(0.71414)
F_0_228 equ (131072 - F_1_772) ; FIX(2) - FIX(1.77200)
; --------------------------------------------------------------------------
SECTION SEG_CONST
alignz 16
global EXTN(jconst_ycc_rgb_convert_sse2)
EXTN(jconst_ycc_rgb_convert_sse2):
PW_F0402 times 8 dw F_0_402
PW_MF0228 times 8 dw -F_0_228
PW_MF0344_F0285 times 4 dw -F_0_344, F_0_285
PW_ONE times 8 dw 1
PD_ONEHALF times 4 dd 1 << (SCALEBITS-1)
alignz 16
; --------------------------------------------------------------------------
SECTION SEG_TEXT
BITS 32
%include "jdclrss2.asm"
%undef RGB_RED
%undef RGB_GREEN
%undef RGB_BLUE
%undef RGB_PIXELSIZE
%define RGB_RED EXT_RGB_RED
%define RGB_GREEN EXT_RGB_GREEN
%define RGB_BLUE EXT_RGB_BLUE
%define RGB_PIXELSIZE EXT_RGB_PIXELSIZE
%define jsimd_ycc_rgb_convert_sse2 jsimd_ycc_extrgb_convert_sse2
%include "jdclrss2.asm"
%undef RGB_RED
%undef RGB_GREEN
%undef RGB_BLUE
%undef RGB_PIXELSIZE
%define RGB_RED EXT_RGBX_RED
%define RGB_GREEN EXT_RGBX_GREEN
%define RGB_BLUE EXT_RGBX_BLUE
%define RGB_PIXELSIZE EXT_RGBX_PIXELSIZE
%define jsimd_ycc_rgb_convert_sse2 jsimd_ycc_extrgbx_convert_sse2
%include "jdclrss2.asm"
%undef RGB_RED
%undef RGB_GREEN
%undef RGB_BLUE
%undef RGB_PIXELSIZE
%define RGB_RED EXT_BGR_RED
%define RGB_GREEN EXT_BGR_GREEN
%define RGB_BLUE EXT_BGR_BLUE
%define RGB_PIXELSIZE EXT_BGR_PIXELSIZE
%define jsimd_ycc_rgb_convert_sse2 jsimd_ycc_extbgr_convert_sse2
%include "jdclrss2.asm"
%undef RGB_RED
%undef RGB_GREEN
%undef RGB_BLUE
%undef RGB_PIXELSIZE
%define RGB_RED EXT_BGRX_RED
%define RGB_GREEN EXT_BGRX_GREEN
%define RGB_BLUE EXT_BGRX_BLUE
%define RGB_PIXELSIZE EXT_BGRX_PIXELSIZE
%define jsimd_ycc_rgb_convert_sse2 jsimd_ycc_extbgrx_convert_sse2
%include "jdclrss2.asm"
%undef RGB_RED
%undef RGB_GREEN
%undef RGB_BLUE
%undef RGB_PIXELSIZE
%define RGB_RED EXT_XBGR_RED
%define RGB_GREEN EXT_XBGR_GREEN
%define RGB_BLUE EXT_XBGR_BLUE
%define RGB_PIXELSIZE EXT_XBGR_PIXELSIZE
%define jsimd_ycc_rgb_convert_sse2 jsimd_ycc_extxbgr_convert_sse2
%include "jdclrss2.asm"
%undef RGB_RED
%undef RGB_GREEN
%undef RGB_BLUE
%undef RGB_PIXELSIZE
%define RGB_RED EXT_XRGB_RED
%define RGB_GREEN EXT_XRGB_GREEN
%define RGB_BLUE EXT_XRGB_BLUE
%define RGB_PIXELSIZE EXT_XRGB_PIXELSIZE
%define jsimd_ycc_rgb_convert_sse2 jsimd_ycc_extxrgb_convert_sse2
%include "jdclrss2.asm"
|
#include "EPoller.h"
#include <cassert>
#include <vector>
#include <fcntl.h>
class Pipe
{
int fd_[2];
public:
Pipe()
{
int ret = pipe2(fd_, O_NONBLOCK | O_CLOEXEC);
assert(ret == 0);
}
int getReadFD() {
return fd_[0];
}
int getWriteFD() {
return fd_[1];
}
~Pipe()
{
close(fd_[1]);
close(fd_[0]);
}
};
EPoller epoller1;
EPoller epoller2;
std::atomic<uint64_t> curCount;
thread_local int readByMe = 0;
int readfunc(int fd, uint64_t ctx)
{
Pipe* p = reinterpret_cast<Pipe*>(ctx);
int readfd = p->getReadFD();
assert(readfd == fd);
do {
uint64_t s;
ssize_t ret = read(readfd, &s, sizeof(s));
if (ret < 0) {
break;
}
curCount ++;
readByMe ++;
} while (1);
std::this_thread::yield();
return 0;
}
void epollrun() {
epoller2.run();
std::cout << "readByMe=" << readByMe << std::endl;
}
int main(int argc, char* argv[])
{
google::InitGoogleLogging(argv[0]);
epoller1.init();
epoller2.init();
auto p = std::unique_ptr<Pipe>(new Pipe());
epoller1.addEvent(reinterpret_cast<uint64_t>(p.get()),
p->getReadFD(),
EPOLLIN,
readfunc);
epoller1.addToAnotherEPoller(epoller2);
std::vector<std::future<void>> futVec;
for (int i = 0; i < 20; i++) {
auto fut = std::async(std::launch::async,
epollrun);
futVec.push_back(std::move(fut));
}
uint64_t totalCount = 1000000;
for (uint64_t idx = 0; idx < totalCount; idx++) {
ssize_t ret = write(p->getWriteFD(), &idx, sizeof(idx));
if (ret < 0) {
totalCount --;
}
std::this_thread::yield();
}
LOG(INFO) << "writes done";
while (curCount < totalCount) {
usleep(100);
}
epoller2.shutdown();
epoller1.shutdown();
for (auto& elem : futVec) {
elem.wait();
}
}
|
//
// Copyright (C) 2011-15 DyND Developers
// BSD 2-Clause License, see LICENSE.txt
//
#pragma once
#include <dynd/type.hpp>
#include <dynd/types/base_string_type.hpp>
namespace dynd {
namespace ndt {
class DYNDT_API fixed_string_kind_type : public base_string_type {
public:
fixed_string_kind_type();
size_t get_default_data_size() const;
void print_data(std::ostream &o, const char *arrmeta, const char *data) const;
void print_type(std::ostream &o) const;
bool is_expression() const;
bool is_unique_data_owner(const char *arrmeta) const;
type get_canonical_type() const;
bool is_lossless_assignment(const type &dst_tp, const type &src_tp) const;
string_encoding_t get_encoding() const;
void get_string_range(const char **out_begin, const char **out_end, const char *arrmeta, const char *data) const;
bool operator==(const base_type &rhs) const;
void arrmeta_default_construct(char *arrmeta, bool blockref_alloc) const;
void arrmeta_copy_construct(char *dst_arrmeta, const char *src_arrmeta,
const intrusive_ptr<memory_block_data> &embedded_reference) const;
void arrmeta_reset_buffers(char *arrmeta) const;
void arrmeta_finalize_buffers(char *arrmeta) const;
void arrmeta_destruct(char *arrmeta) const;
void arrmeta_debug_print(const char *arrmeta, std::ostream &o, const std::string &indent) const;
void data_destruct(const char *arrmeta, char *data) const;
void data_destruct_strided(const char *arrmeta, char *data, intptr_t stride, size_t count) const;
bool match(const type &candidate_tp, std::map<std::string, type> &tp_vars) const;
static type make() { return type(new fixed_string_kind_type(), false); }
};
} // namespace dynd::ndt
} // namespace dynd
|
/*
*********************************************************************************************************
* uC/Probe Communication
*
* (c) Copyright 2007; Micrium, Inc.; Weston, FL
*
* All rights reserved. Protected by international copyright laws.
* Knowledge of the source code may NOT be used to develop a similar product.
* Please help us continue to provide the Embedded community with the finest
* software available. Your honesty is greatly appreciated.
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*
* uC/Probe
*
* Communication: RS-232
* Port for the Freescale CF5275
*
* Filename : probe_rs232a.asm
* Version : V1.00
* Programmer(s) : Fabiano Kovalski
*********************************************************************************************************
*/
#include <os_cpu_i.asm>
/*
;*************************************************************************************************
; PUBLIC DECLARATIONS
;*************************************************************************************************
*/
PUBLIC ProbeRS232_RxTxISR
/*
;**************************************************************************************************
; EXTERNAL DECLARATIONS
;**************************************************************************************************
*/
EXTERN OSIntNesting
EXTERN OSIntExit
EXTERN OSTCBCur
EXTERN ProbeRS232_RxTxISRHandler
RSEG CODE:CODE:NOROOT(2) /* Align to power 2, 4 bytes. */
/*
;*******************************************************************************************
; uC/Probe's Rx/Tx ISR
;
; Description : This function services uC/Probe's receive and transmit interrupts
;
; Arguments : none
;*******************************************************************************************
*/
ProbeRS232_RxTxISR:
MOVE.W #0x2700,SR /* Disable interrupts */
LEA (-60, A7), A7 /* Save processor registers onto stack */
MOVEM.L D0-D7/A0-A6,(A7)
OS_EMAC_SAVE /* Save the EMAC registers */
MOVEQ.L #0,D0 /* OSIntNesting++ */
MOVE.B (OSIntNesting),D0
ADDQ.L #1,D0
MOVE.B D0,(OSIntNesting)
CMPI.L #1, D0 /* if (OSIntNesting == 1) */
BNE.W (ProbeRS232_RxTxISR_1)
MOVEA.L (OSTCBCur), A1 /* OSTCBCur-<OSTCBStkPtr = SP */
MOVE.L A7,(A1)
ProbeRS232_RxTxISR_1:
/* ProbeRS232_RxTxISRHandler() */
JSR (ProbeRS232_RxTxISRHandler)
JSR (OSIntExit) /* Exit the ISR */
OS_EMAC_RESTORE /* Restore the EMAC registers */
MOVEM.L (A7),D0-D7/A0-A6 /* Restore processor registers from stack */
LEA (60, A7), A7
RTE /* Return to task or nested ISR */
END
|
; A060939: a(n) = (Sum of the first n primes) + n.
; 3,7,13,21,33,47,65,85,109,139,171,209,251,295,343,397,457,519,587,659,733,813,897,987,1085,1187,1291,1399,1509,1623,1751,1883,2021,2161,2311,2463,2621,2785,2953,3127,3307,3489,3681,3875,4073,4273,4485,4709,4937,5167,5401,5641,5883,6135,6393,6657,6927,7199,7477,7759,8043,8337,8645,8957,9271,9589,9921,10259,10607,10957,11311,11671,12039,12413,12793,13177,13567,13965,14367,14777,15197,15619,16051,16485,16925,17369,17819,18277,18739,19203,19671,20151,20639,21131,21631,22135,22645,23167,23691,24233
mov $1,$0
seq $1,237589 ; Sum of first n odd noncomposite numbers.
add $0,$1
add $0,2
|
Name: Poo.asm
Type: file
Size: 4791
Last-Modified: '1992-11-18T01:48:25Z'
SHA-1: 5D009387589543EB857BDF69DD2B8B9315B0CD50
Description: null
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.