# int32 eax

# int32 ebx

# int32 esi

# stack32 esi_stack

# int32 edi

# stack32 edi_stack

# int32 ebp

# stack32 ebp_stack

# stack32 x_stack

# int32 x

# stack32 y_stack

# int32 y

# stack32 u_stack

# int32 u

# stack32 v_stack

# int32 v

# stack32 bit_stack

# int32 bit

# stack64 exponentbitshifted

# float80 use1

# float80 x0

# float80 x1

# float80 x2

# float80 x3

# float80 x4

# float80 x5

# float80 x6

# float80 x7

# float80 x8

# float80 x9

# float80 y0

# float80 y1

# float80 y2

# float80 y3

# float80 y4

# float80 y5

# float80 y6

# float80 y7

# float80 y8

# float80 y9

# enter gaudry_pm_select
.text
.p2align 5
.globl _gaudry_pm_select
.globl gaudry_pm_select
_gaudry_pm_select:
gaudry_pm_select:
mov %esp,%eax
and $31,%eax
add $64,%eax
sub %eax,%esp

# input out_stack

# input x_stack

# input y_stack

# input u_stack

# input v_stack

# input bit_stack

# caller eax

# caller ebx

# caller esi

# caller edi

# caller ebp

#   bit = bit_stack
# movl <bit_stack=stack32#-5,>bit=int32#2
# movl <bit_stack=20(%esp,%eax),>bit=%ecx
movl 20(%esp,%eax),%ecx

#   exponentbitshifted top = 0x43300000
# movl  $0x43300000,>exponentbitshifted=stack64#1
# movl  $0x43300000,>exponentbitshifted=36(%esp)
movl  $0x43300000,36(%esp)

#   inplace exponentbitshifted bottom = bit
# movl <bit=int32#2,<exponentbitshifted=stack64#1
# movl <bit=%ecx,<exponentbitshifted=32(%esp)
movl %ecx,32(%esp)

#   use1 = *(float64 *) &exponentbitshifted
# fldl <exponentbitshifted=stack64#1
# fldl <exponentbitshifted=32(%esp)
fldl 32(%esp)

#   use1 -= *(float64 *) &gaudry_pm_in0offset
fsubl gaudry_pm_in0offset

#   ebp_stack = ebp
# movl <ebp=int32#7,>ebp_stack=stack32#3
# movl <ebp=%ebp,>ebp_stack=8(%esp)
movl %ebp,8(%esp)

#   edi_stack = edi
# movl <edi=int32#6,>edi_stack=stack32#2
# movl <edi=%edi,>edi_stack=4(%esp)
movl %edi,4(%esp)

#   esi_stack = esi
# movl <esi=int32#5,>esi_stack=stack32#1
# movl <esi=%esi,>esi_stack=0(%esp)
movl %esi,0(%esp)

#   x = x_stack
# movl <x_stack=stack32#-1,>x=int32#2
# movl <x_stack=4(%esp,%eax),>x=%ecx
movl 4(%esp,%eax),%ecx

#   y = y_stack
# movl <y_stack=stack32#-2,>y=int32#3
# movl <y_stack=8(%esp,%eax),>y=%edx
movl 8(%esp,%eax),%edx

#   u = u_stack
# movl <u_stack=stack32#-3,>u=int32#5
# movl <u_stack=12(%esp,%eax),>u=%esi
movl 12(%esp,%eax),%esi

#   v = v_stack
# movl <v_stack=stack32#-4,>v=int32#6
# movl <v_stack=16(%esp,%eax),>v=%edi
movl 16(%esp,%eax),%edi

#   x0 = *(float64 *) (u + 0)
# fldl 0(<u=int32#5)
# fldl 0(<u=%esi)
fldl 0(%esi)

#   y0 = *(float64 *) (v + 0)
# fldl 0(<v=int32#6)
# fldl 0(<v=%edi)
fldl 0(%edi)

#   y0 -= x0; negate
# fsubr <x0=float80#2,<y0=float80#1
# fsubr <x0=%st(1),<y0=%st(0)
fsubr %st(1),%st(0)

#   y0 *= use1
# fmul <use1=float80#3,<y0=float80#1
# fmul <use1=%st(2),<y0=%st(0)
fmul %st(2),%st(0)

#   x0 -= y0
# fsubr <y0=float80#1,<x0=float80#2
# fsubr <y0=%st(0),<x0=%st(1)
fsubr %st(0),%st(1)

#   y0 += *(float64 *) (v + 0)
# faddl 0(<v=int32#6)
# faddl 0(<v=%edi)
faddl 0(%edi)

# stacktop x0
# fxch <x0=float80#2
# fxch <x0=%st(1)
fxch %st(1)

#   *(float64 *) (x + 0) = x0
# fstpl 0(<x=int32#2)
# fstpl 0(<x=%ecx)
fstpl 0(%ecx)

#   *(float64 *) (y + 0) = y0
# fstpl 0(<y=int32#3)
# fstpl 0(<y=%edx)
fstpl 0(%edx)

#   x1 = *(float64 *) (u + 8)
# fldl 8(<u=int32#5)
# fldl 8(<u=%esi)
fldl 8(%esi)

#   y1 = *(float64 *) (v + 8)
# fldl 8(<v=int32#6)
# fldl 8(<v=%edi)
fldl 8(%edi)

#   y1 -= x1; negate
# fsubr <x1=float80#2,<y1=float80#1
# fsubr <x1=%st(1),<y1=%st(0)
fsubr %st(1),%st(0)

#   y1 *= use1
# fmul <use1=float80#3,<y1=float80#1
# fmul <use1=%st(2),<y1=%st(0)
fmul %st(2),%st(0)

#   x1 -= y1
# fsubr <y1=float80#1,<x1=float80#2
# fsubr <y1=%st(0),<x1=%st(1)
fsubr %st(0),%st(1)

#   y1 += *(float64 *) (v + 8)
# faddl 8(<v=int32#6)
# faddl 8(<v=%edi)
faddl 8(%edi)

# stacktop x1
# fxch <x1=float80#2
# fxch <x1=%st(1)
fxch %st(1)

#   *(float64 *) (x + 8) = x1
# fstpl 8(<x=int32#2)
# fstpl 8(<x=%ecx)
fstpl 8(%ecx)

#   *(float64 *) (y + 8) = y1
# fstpl 8(<y=int32#3)
# fstpl 8(<y=%edx)
fstpl 8(%edx)

#   x2 = *(float64 *) (u + 16)
# fldl 16(<u=int32#5)
# fldl 16(<u=%esi)
fldl 16(%esi)

#   y2 = *(float64 *) (v + 16)
# fldl 16(<v=int32#6)
# fldl 16(<v=%edi)
fldl 16(%edi)

#   y2 -= x2; negate
# fsubr <x2=float80#2,<y2=float80#1
# fsubr <x2=%st(1),<y2=%st(0)
fsubr %st(1),%st(0)

#   y2 *= use1
# fmul <use1=float80#3,<y2=float80#1
# fmul <use1=%st(2),<y2=%st(0)
fmul %st(2),%st(0)

#   x2 -= y2
# fsubr <y2=float80#1,<x2=float80#2
# fsubr <y2=%st(0),<x2=%st(1)
fsubr %st(0),%st(1)

#   y2 += *(float64 *) (v + 16)
# faddl 16(<v=int32#6)
# faddl 16(<v=%edi)
faddl 16(%edi)

# stacktop x2
# fxch <x2=float80#2
# fxch <x2=%st(1)
fxch %st(1)

#   *(float64 *) (x + 16) = x2
# fstpl 16(<x=int32#2)
# fstpl 16(<x=%ecx)
fstpl 16(%ecx)

#   *(float64 *) (y + 16) = y2
# fstpl 16(<y=int32#3)
# fstpl 16(<y=%edx)
fstpl 16(%edx)

#   x3 = *(float64 *) (u + 24)
# fldl 24(<u=int32#5)
# fldl 24(<u=%esi)
fldl 24(%esi)

#   y3 = *(float64 *) (v + 24)
# fldl 24(<v=int32#6)
# fldl 24(<v=%edi)
fldl 24(%edi)

#   y3 -= x3; negate
# fsubr <x3=float80#2,<y3=float80#1
# fsubr <x3=%st(1),<y3=%st(0)
fsubr %st(1),%st(0)

#   y3 *= use1
# fmul <use1=float80#3,<y3=float80#1
# fmul <use1=%st(2),<y3=%st(0)
fmul %st(2),%st(0)

#   x3 -= y3
# fsubr <y3=float80#1,<x3=float80#2
# fsubr <y3=%st(0),<x3=%st(1)
fsubr %st(0),%st(1)

#   y3 += *(float64 *) (v + 24)
# faddl 24(<v=int32#6)
# faddl 24(<v=%edi)
faddl 24(%edi)

# stacktop x3
# fxch <x3=float80#2
# fxch <x3=%st(1)
fxch %st(1)

#   *(float64 *) (x + 24) = x3
# fstpl 24(<x=int32#2)
# fstpl 24(<x=%ecx)
fstpl 24(%ecx)

#   *(float64 *) (y + 24) = y3
# fstpl 24(<y=int32#3)
# fstpl 24(<y=%edx)
fstpl 24(%edx)

#   x4 = *(float64 *) (u + 32)
# fldl 32(<u=int32#5)
# fldl 32(<u=%esi)
fldl 32(%esi)

#   y4 = *(float64 *) (v + 32)
# fldl 32(<v=int32#6)
# fldl 32(<v=%edi)
fldl 32(%edi)

#   y4 -= x4; negate
# fsubr <x4=float80#2,<y4=float80#1
# fsubr <x4=%st(1),<y4=%st(0)
fsubr %st(1),%st(0)

#   y4 *= use1
# fmul <use1=float80#3,<y4=float80#1
# fmul <use1=%st(2),<y4=%st(0)
fmul %st(2),%st(0)

#   x4 -= y4
# fsubr <y4=float80#1,<x4=float80#2
# fsubr <y4=%st(0),<x4=%st(1)
fsubr %st(0),%st(1)

#   y4 += *(float64 *) (v + 32)
# faddl 32(<v=int32#6)
# faddl 32(<v=%edi)
faddl 32(%edi)

# stacktop x4
# fxch <x4=float80#2
# fxch <x4=%st(1)
fxch %st(1)

#   *(float64 *) (x + 32) = x4
# fstpl 32(<x=int32#2)
# fstpl 32(<x=%ecx)
fstpl 32(%ecx)

#   *(float64 *) (y + 32) = y4
# fstpl 32(<y=int32#3)
# fstpl 32(<y=%edx)
fstpl 32(%edx)

#   x5 = *(float64 *) (u + 40)
# fldl 40(<u=int32#5)
# fldl 40(<u=%esi)
fldl 40(%esi)

#   y5 = *(float64 *) (v + 40)
# fldl 40(<v=int32#6)
# fldl 40(<v=%edi)
fldl 40(%edi)

#   y5 -= x5; negate
# fsubr <x5=float80#2,<y5=float80#1
# fsubr <x5=%st(1),<y5=%st(0)
fsubr %st(1),%st(0)

#   y5 *= use1
# fmul <use1=float80#3,<y5=float80#1
# fmul <use1=%st(2),<y5=%st(0)
fmul %st(2),%st(0)

#   x5 -= y5
# fsubr <y5=float80#1,<x5=float80#2
# fsubr <y5=%st(0),<x5=%st(1)
fsubr %st(0),%st(1)

#   y5 += *(float64 *) (v + 40)
# faddl 40(<v=int32#6)
# faddl 40(<v=%edi)
faddl 40(%edi)

# stacktop x5
# fxch <x5=float80#2
# fxch <x5=%st(1)
fxch %st(1)

#   *(float64 *) (x + 40) = x5
# fstpl 40(<x=int32#2)
# fstpl 40(<x=%ecx)
fstpl 40(%ecx)

#   *(float64 *) (y + 40) = y5
# fstpl 40(<y=int32#3)
# fstpl 40(<y=%edx)
fstpl 40(%edx)

#   x6 = *(float64 *) (u + 48)
# fldl 48(<u=int32#5)
# fldl 48(<u=%esi)
fldl 48(%esi)

#   y6 = *(float64 *) (v + 48)
# fldl 48(<v=int32#6)
# fldl 48(<v=%edi)
fldl 48(%edi)

#   y6 -= x6; negate
# fsubr <x6=float80#2,<y6=float80#1
# fsubr <x6=%st(1),<y6=%st(0)
fsubr %st(1),%st(0)

#   y6 *= use1
# fmul <use1=float80#3,<y6=float80#1
# fmul <use1=%st(2),<y6=%st(0)
fmul %st(2),%st(0)

#   x6 -= y6
# fsubr <y6=float80#1,<x6=float80#2
# fsubr <y6=%st(0),<x6=%st(1)
fsubr %st(0),%st(1)

#   y6 += *(float64 *) (v + 48)
# faddl 48(<v=int32#6)
# faddl 48(<v=%edi)
faddl 48(%edi)

# stacktop x6
# fxch <x6=float80#2
# fxch <x6=%st(1)
fxch %st(1)

#   *(float64 *) (x + 48) = x6
# fstpl 48(<x=int32#2)
# fstpl 48(<x=%ecx)
fstpl 48(%ecx)

#   *(float64 *) (y + 48) = y6
# fstpl 48(<y=int32#3)
# fstpl 48(<y=%edx)
fstpl 48(%edx)

#   x7 = *(float64 *) (u + 56)
# fldl 56(<u=int32#5)
# fldl 56(<u=%esi)
fldl 56(%esi)

#   y7 = *(float64 *) (v + 56)
# fldl 56(<v=int32#6)
# fldl 56(<v=%edi)
fldl 56(%edi)

#   y7 -= x7; negate
# fsubr <x7=float80#2,<y7=float80#1
# fsubr <x7=%st(1),<y7=%st(0)
fsubr %st(1),%st(0)

#   y7 *= use1
# fmul <use1=float80#3,<y7=float80#1
# fmul <use1=%st(2),<y7=%st(0)
fmul %st(2),%st(0)

#   x7 -= y7
# fsubr <y7=float80#1,<x7=float80#2
# fsubr <y7=%st(0),<x7=%st(1)
fsubr %st(0),%st(1)

#   y7 += *(float64 *) (v + 56)
# faddl 56(<v=int32#6)
# faddl 56(<v=%edi)
faddl 56(%edi)

# stacktop x7
# fxch <x7=float80#2
# fxch <x7=%st(1)
fxch %st(1)

#   *(float64 *) (x + 56) = x7
# fstpl 56(<x=int32#2)
# fstpl 56(<x=%ecx)
fstpl 56(%ecx)

#   *(float64 *) (y + 56) = y7
# fstpl 56(<y=int32#3)
# fstpl 56(<y=%edx)
fstpl 56(%edx)

#   x8 = *(float64 *) (u + 64)
# fldl 64(<u=int32#5)
# fldl 64(<u=%esi)
fldl 64(%esi)

#   y8 = *(float64 *) (v + 64)
# fldl 64(<v=int32#6)
# fldl 64(<v=%edi)
fldl 64(%edi)

#   y8 -= x8; negate
# fsubr <x8=float80#2,<y8=float80#1
# fsubr <x8=%st(1),<y8=%st(0)
fsubr %st(1),%st(0)

#   y8 *= use1
# fmul <use1=float80#3,<y8=float80#1
# fmul <use1=%st(2),<y8=%st(0)
fmul %st(2),%st(0)

#   x8 -= y8
# fsubr <y8=float80#1,<x8=float80#2
# fsubr <y8=%st(0),<x8=%st(1)
fsubr %st(0),%st(1)

#   y8 += *(float64 *) (v + 64)
# faddl 64(<v=int32#6)
# faddl 64(<v=%edi)
faddl 64(%edi)

# stacktop x8
# fxch <x8=float80#2
# fxch <x8=%st(1)
fxch %st(1)

#   *(float64 *) (x + 64) = x8
# fstpl 64(<x=int32#2)
# fstpl 64(<x=%ecx)
fstpl 64(%ecx)

#   *(float64 *) (y + 64) = y8
# fstpl 64(<y=int32#3)
# fstpl 64(<y=%edx)
fstpl 64(%edx)

#   x9 = *(float64 *) (u + 72)
# fldl 72(<u=int32#5)
# fldl 72(<u=%esi)
fldl 72(%esi)

#   y9 = *(float64 *) (v + 72)
# fldl 72(<v=int32#6)
# fldl 72(<v=%edi)
fldl 72(%edi)

#   y9 -= x9; negate
# fsubr <x9=float80#2,<y9=float80#1
# fsubr <x9=%st(1),<y9=%st(0)
fsubr %st(1),%st(0)

#   y9 *= use1
# fmul <use1=float80#3,<y9=float80#1
# fmul <use1=%st(2),<y9=%st(0)
fmul %st(2),%st(0)

#   x9 -= y9
# fsubr <y9=float80#1,<x9=float80#2
# fsubr <y9=%st(0),<x9=%st(1)
fsubr %st(0),%st(1)

#   y9 += *(float64 *) (v + 72)
# faddl 72(<v=int32#6)
# faddl 72(<v=%edi)
faddl 72(%edi)

# stacktop x9
# fxch <x9=float80#2
# fxch <x9=%st(1)
fxch %st(1)

#   *(float64 *) (x + 72) = x9
# fstpl 72(<x=int32#2)
# fstpl 72(<x=%ecx)
fstpl 72(%ecx)

#   *(float64 *) (y + 72) = y9
# fstpl 72(<y=int32#3)
# fstpl 72(<y=%edx)
fstpl 72(%edx)

#   x0 = *(float64 *) (u + 80)
# fldl 80(<u=int32#5)
# fldl 80(<u=%esi)
fldl 80(%esi)

#   y0 = *(float64 *) (v + 80)
# fldl 80(<v=int32#6)
# fldl 80(<v=%edi)
fldl 80(%edi)

#   y0 -= x0; negate
# fsubr <x0=float80#2,<y0=float80#1
# fsubr <x0=%st(1),<y0=%st(0)
fsubr %st(1),%st(0)

#   y0 *= use1
# fmul <use1=float80#3,<y0=float80#1
# fmul <use1=%st(2),<y0=%st(0)
fmul %st(2),%st(0)

#   x0 -= y0
# fsubr <y0=float80#1,<x0=float80#2
# fsubr <y0=%st(0),<x0=%st(1)
fsubr %st(0),%st(1)

#   y0 += *(float64 *) (v + 80)
# faddl 80(<v=int32#6)
# faddl 80(<v=%edi)
faddl 80(%edi)

# stacktop x0
# fxch <x0=float80#2
# fxch <x0=%st(1)
fxch %st(1)

#   *(float64 *) (x + 80) = x0
# fstpl 80(<x=int32#2)
# fstpl 80(<x=%ecx)
fstpl 80(%ecx)

#   *(float64 *) (y + 80) = y0
# fstpl 80(<y=int32#3)
# fstpl 80(<y=%edx)
fstpl 80(%edx)

#   x1 = *(float64 *) (u + 88)
# fldl 88(<u=int32#5)
# fldl 88(<u=%esi)
fldl 88(%esi)

#   y1 = *(float64 *) (v + 88)
# fldl 88(<v=int32#6)
# fldl 88(<v=%edi)
fldl 88(%edi)

#   y1 -= x1; negate
# fsubr <x1=float80#2,<y1=float80#1
# fsubr <x1=%st(1),<y1=%st(0)
fsubr %st(1),%st(0)

#   y1 *= use1
# fmul <use1=float80#3,<y1=float80#1
# fmul <use1=%st(2),<y1=%st(0)
fmul %st(2),%st(0)

#   x1 -= y1
# fsubr <y1=float80#1,<x1=float80#2
# fsubr <y1=%st(0),<x1=%st(1)
fsubr %st(0),%st(1)

#   y1 += *(float64 *) (v + 88)
# faddl 88(<v=int32#6)
# faddl 88(<v=%edi)
faddl 88(%edi)

# stacktop x1
# fxch <x1=float80#2
# fxch <x1=%st(1)
fxch %st(1)

#   *(float64 *) (x + 88) = x1
# fstpl 88(<x=int32#2)
# fstpl 88(<x=%ecx)
fstpl 88(%ecx)

#   *(float64 *) (y + 88) = y1
# fstpl 88(<y=int32#3)
# fstpl 88(<y=%edx)
fstpl 88(%edx)

#   x2 = *(float64 *) (u + 96)
# fldl 96(<u=int32#5)
# fldl 96(<u=%esi)
fldl 96(%esi)

#   y2 = *(float64 *) (v + 96)
# fldl 96(<v=int32#6)
# fldl 96(<v=%edi)
fldl 96(%edi)

#   y2 -= x2; negate
# fsubr <x2=float80#2,<y2=float80#1
# fsubr <x2=%st(1),<y2=%st(0)
fsubr %st(1),%st(0)

#   y2 *= use1
# fmul <use1=float80#3,<y2=float80#1
# fmul <use1=%st(2),<y2=%st(0)
fmul %st(2),%st(0)

#   x2 -= y2
# fsubr <y2=float80#1,<x2=float80#2
# fsubr <y2=%st(0),<x2=%st(1)
fsubr %st(0),%st(1)

#   y2 += *(float64 *) (v + 96)
# faddl 96(<v=int32#6)
# faddl 96(<v=%edi)
faddl 96(%edi)

# stacktop x2
# fxch <x2=float80#2
# fxch <x2=%st(1)
fxch %st(1)

#   *(float64 *) (x + 96) = x2
# fstpl 96(<x=int32#2)
# fstpl 96(<x=%ecx)
fstpl 96(%ecx)

#   *(float64 *) (y + 96) = y2
# fstpl 96(<y=int32#3)
# fstpl 96(<y=%edx)
fstpl 96(%edx)

#   x3 = *(float64 *) (u + 104)
# fldl 104(<u=int32#5)
# fldl 104(<u=%esi)
fldl 104(%esi)

#   y3 = *(float64 *) (v + 104)
# fldl 104(<v=int32#6)
# fldl 104(<v=%edi)
fldl 104(%edi)

#   y3 -= x3; negate
# fsubr <x3=float80#2,<y3=float80#1
# fsubr <x3=%st(1),<y3=%st(0)
fsubr %st(1),%st(0)

#   y3 *= use1
# fmul <use1=float80#3,<y3=float80#1
# fmul <use1=%st(2),<y3=%st(0)
fmul %st(2),%st(0)

#   x3 -= y3
# fsubr <y3=float80#1,<x3=float80#2
# fsubr <y3=%st(0),<x3=%st(1)
fsubr %st(0),%st(1)

#   y3 += *(float64 *) (v + 104)
# faddl 104(<v=int32#6)
# faddl 104(<v=%edi)
faddl 104(%edi)

# stacktop x3
# fxch <x3=float80#2
# fxch <x3=%st(1)
fxch %st(1)

#   *(float64 *) (x + 104) = x3
# fstpl 104(<x=int32#2)
# fstpl 104(<x=%ecx)
fstpl 104(%ecx)

#   *(float64 *) (y + 104) = y3
# fstpl 104(<y=int32#3)
# fstpl 104(<y=%edx)
fstpl 104(%edx)

#   x4 = *(float64 *) (u + 112)
# fldl 112(<u=int32#5)
# fldl 112(<u=%esi)
fldl 112(%esi)

#   y4 = *(float64 *) (v + 112)
# fldl 112(<v=int32#6)
# fldl 112(<v=%edi)
fldl 112(%edi)

#   y4 -= x4; negate
# fsubr <x4=float80#2,<y4=float80#1
# fsubr <x4=%st(1),<y4=%st(0)
fsubr %st(1),%st(0)

#   y4 *= use1
# fmul <use1=float80#3,<y4=float80#1
# fmul <use1=%st(2),<y4=%st(0)
fmul %st(2),%st(0)

#   x4 -= y4
# fsubr <y4=float80#1,<x4=float80#2
# fsubr <y4=%st(0),<x4=%st(1)
fsubr %st(0),%st(1)

#   y4 += *(float64 *) (v + 112)
# faddl 112(<v=int32#6)
# faddl 112(<v=%edi)
faddl 112(%edi)

# stacktop x4
# fxch <x4=float80#2
# fxch <x4=%st(1)
fxch %st(1)

#   *(float64 *) (x + 112) = x4
# fstpl 112(<x=int32#2)
# fstpl 112(<x=%ecx)
fstpl 112(%ecx)

#   *(float64 *) (y + 112) = y4
# fstpl 112(<y=int32#3)
# fstpl 112(<y=%edx)
fstpl 112(%edx)

#   x5 = *(float64 *) (u + 120)
# fldl 120(<u=int32#5)
# fldl 120(<u=%esi)
fldl 120(%esi)

#   y5 = *(float64 *) (v + 120)
# fldl 120(<v=int32#6)
# fldl 120(<v=%edi)
fldl 120(%edi)

#   y5 -= x5; negate
# fsubr <x5=float80#2,<y5=float80#1
# fsubr <x5=%st(1),<y5=%st(0)
fsubr %st(1),%st(0)

#   y5 *= use1
# fmul <use1=float80#3,<y5=float80#1
# fmul <use1=%st(2),<y5=%st(0)
fmul %st(2),%st(0)

#   x5 -= y5
# fsubr <y5=float80#1,<x5=float80#2
# fsubr <y5=%st(0),<x5=%st(1)
fsubr %st(0),%st(1)

#   y5 += *(float64 *) (v + 120)
# faddl 120(<v=int32#6)
# faddl 120(<v=%edi)
faddl 120(%edi)

# stacktop x5
# fxch <x5=float80#2
# fxch <x5=%st(1)
fxch %st(1)

#   *(float64 *) (x + 120) = x5
# fstpl 120(<x=int32#2)
# fstpl 120(<x=%ecx)
fstpl 120(%ecx)

#   *(float64 *) (y + 120) = y5
# fstpl 120(<y=int32#3)
# fstpl 120(<y=%edx)
fstpl 120(%edx)

#   x6 = *(float64 *) (u + 128)
# fldl 128(<u=int32#5)
# fldl 128(<u=%esi)
fldl 128(%esi)

#   y6 = *(float64 *) (v + 128)
# fldl 128(<v=int32#6)
# fldl 128(<v=%edi)
fldl 128(%edi)

#   y6 -= x6; negate
# fsubr <x6=float80#2,<y6=float80#1
# fsubr <x6=%st(1),<y6=%st(0)
fsubr %st(1),%st(0)

#   y6 *= use1
# fmul <use1=float80#3,<y6=float80#1
# fmul <use1=%st(2),<y6=%st(0)
fmul %st(2),%st(0)

#   x6 -= y6
# fsubr <y6=float80#1,<x6=float80#2
# fsubr <y6=%st(0),<x6=%st(1)
fsubr %st(0),%st(1)

#   y6 += *(float64 *) (v + 128)
# faddl 128(<v=int32#6)
# faddl 128(<v=%edi)
faddl 128(%edi)

# stacktop x6
# fxch <x6=float80#2
# fxch <x6=%st(1)
fxch %st(1)

#   *(float64 *) (x + 128) = x6
# fstpl 128(<x=int32#2)
# fstpl 128(<x=%ecx)
fstpl 128(%ecx)

#   *(float64 *) (y + 128) = y6
# fstpl 128(<y=int32#3)
# fstpl 128(<y=%edx)
fstpl 128(%edx)

#   x7 = *(float64 *) (u + 136)
# fldl 136(<u=int32#5)
# fldl 136(<u=%esi)
fldl 136(%esi)

#   y7 = *(float64 *) (v + 136)
# fldl 136(<v=int32#6)
# fldl 136(<v=%edi)
fldl 136(%edi)

#   y7 -= x7; negate
# fsubr <x7=float80#2,<y7=float80#1
# fsubr <x7=%st(1),<y7=%st(0)
fsubr %st(1),%st(0)

#   y7 *= use1
# fmul <use1=float80#3,<y7=float80#1
# fmul <use1=%st(2),<y7=%st(0)
fmul %st(2),%st(0)

#   x7 -= y7
# fsubr <y7=float80#1,<x7=float80#2
# fsubr <y7=%st(0),<x7=%st(1)
fsubr %st(0),%st(1)

#   y7 += *(float64 *) (v + 136)
# faddl 136(<v=int32#6)
# faddl 136(<v=%edi)
faddl 136(%edi)

# stacktop x7
# fxch <x7=float80#2
# fxch <x7=%st(1)
fxch %st(1)

#   *(float64 *) (x + 136) = x7
# fstpl 136(<x=int32#2)
# fstpl 136(<x=%ecx)
fstpl 136(%ecx)

#   *(float64 *) (y + 136) = y7
# fstpl 136(<y=int32#3)
# fstpl 136(<y=%edx)
fstpl 136(%edx)

#   x8 = *(float64 *) (u + 144)
# fldl 144(<u=int32#5)
# fldl 144(<u=%esi)
fldl 144(%esi)

#   y8 = *(float64 *) (v + 144)
# fldl 144(<v=int32#6)
# fldl 144(<v=%edi)
fldl 144(%edi)

#   y8 -= x8; negate
# fsubr <x8=float80#2,<y8=float80#1
# fsubr <x8=%st(1),<y8=%st(0)
fsubr %st(1),%st(0)

#   y8 *= use1
# fmul <use1=float80#3,<y8=float80#1
# fmul <use1=%st(2),<y8=%st(0)
fmul %st(2),%st(0)

#   x8 -= y8
# fsubr <y8=float80#1,<x8=float80#2
# fsubr <y8=%st(0),<x8=%st(1)
fsubr %st(0),%st(1)

#   y8 += *(float64 *) (v + 144)
# faddl 144(<v=int32#6)
# faddl 144(<v=%edi)
faddl 144(%edi)

# stacktop x8
# fxch <x8=float80#2
# fxch <x8=%st(1)
fxch %st(1)

#   *(float64 *) (x + 144) = x8
# fstpl 144(<x=int32#2)
# fstpl 144(<x=%ecx)
fstpl 144(%ecx)

#   *(float64 *) (y + 144) = y8
# fstpl 144(<y=int32#3)
# fstpl 144(<y=%edx)
fstpl 144(%edx)

#   x9 = *(float64 *) (u + 152)
# fldl 152(<u=int32#5)
# fldl 152(<u=%esi)
fldl 152(%esi)

#   y9 = *(float64 *) (v + 152)
# fldl 152(<v=int32#6)
# fldl 152(<v=%edi)
fldl 152(%edi)

#   y9 -= x9; negate
# fsubr <x9=float80#2,<y9=float80#1
# fsubr <x9=%st(1),<y9=%st(0)
fsubr %st(1),%st(0)

#   y9 *= use1
# fmulp <use1=float80#1,<y9=float80#3
# fmulp <use1=%st(0),<y9=%st(2)
fmulp %st(0),%st(2)

#   x9 -= y9
# fsub <y9=float80#2,<x9=float80#1
# fsub <y9=%st(1),<x9=%st(0)
fsub %st(1),%st(0)

# stacktop y9
# fxch <y9=float80#2
# fxch <y9=%st(1)
fxch %st(1)

#   y9 += *(float64 *) (v + 152)
# faddl 152(<v=int32#6)
# faddl 152(<v=%edi)
faddl 152(%edi)

# stacktop x9
# fxch <x9=float80#2
# fxch <x9=%st(1)
fxch %st(1)

#   *(float64 *) (x + 152) = x9
# fstpl 152(<x=int32#2)
# fstpl 152(<x=%ecx)
fstpl 152(%ecx)

#   *(float64 *) (y + 152) = y9
# fstpl 152(<y=int32#3)
# fstpl 152(<y=%edx)
fstpl 152(%edx)

#   ebp = ebp_stack
# movl <ebp_stack=stack32#3,>ebp=int32#7
# movl <ebp_stack=8(%esp),>ebp=%ebp
movl 8(%esp),%ebp

#   edi = edi_stack
# movl <edi_stack=stack32#2,>edi=int32#6
# movl <edi_stack=4(%esp),>edi=%edi
movl 4(%esp),%edi

#   esi = esi_stack
# movl <esi_stack=stack32#1,>esi=int32#5
# movl <esi_stack=0(%esp),>esi=%esi
movl 0(%esp),%esi

# leave
add %eax,%esp
ret