# stack32 out_stack

# stack32 u_stack

# int32 eax

# int32 ebx

# int32 esi

# int32 edi

# int32 ebp

# int32 out

# int32 u

# int32 word0

# int32 word1

# int32 word2

# int32 word3

# int32 word4

# float80 out0

# float80 out1

# float80 out2

# float80 out3

# float80 out4

# float80 carry0

# float80 carry1

# float80 carry2

# float80 carry3

# float80 carry4

# stack64 d0

# stack64 d1

# stack64 d2

# stack64 d3

# stack64 d4

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

# input out_stack

# input u_stack

# caller eax

# caller ebx

# caller esi

# caller edi

# caller ebp

#   u = u_stack
# movl <u_stack=stack32#-2,>u=int32#2
# movl <u_stack=8(%esp,%eax),>u=%ecx
movl 8(%esp,%eax),%ecx

#   word0 = *(uint32 *) (u + 0)
# movl 0(<u=int32#2),>word0=int32#3
# movl 0(<u=%ecx),>word0=%edx
movl 0(%ecx),%edx

#   d0 top = 0x43300000
# movl  $0x43300000,>d0=stack64#1
# movl  $0x43300000,>d0=4(%esp)
movl  $0x43300000,4(%esp)

#   inplace d0 bottom = word0
# movl <word0=int32#3,<d0=stack64#1
# movl <word0=%edx,<d0=0(%esp)
movl %edx,0(%esp)

#   word1 = *(uint32 *) (u + 4)
# movl 4(<u=int32#2),>word1=int32#3
# movl 4(<u=%ecx),>word1=%edx
movl 4(%ecx),%edx

#   word1 &= 0xffffff
# and  $0xffffff,<word1=int32#3
# and  $0xffffff,<word1=%edx
and  $0xffffff,%edx

#   d1 top = 0x45300000
# movl  $0x45300000,>d1=stack64#2
# movl  $0x45300000,>d1=12(%esp)
movl  $0x45300000,12(%esp)

#   inplace d1 bottom = word1
# movl <word1=int32#3,<d1=stack64#2
# movl <word1=%edx,<d1=8(%esp)
movl %edx,8(%esp)

#   word2 = *(uint32 *) (u + 7)
# movl 7(<u=int32#2),>word2=int32#3
# movl 7(<u=%ecx),>word2=%edx
movl 7(%ecx),%edx

#   word2 &= 0xffffff
# and  $0xffffff,<word2=int32#3
# and  $0xffffff,<word2=%edx
and  $0xffffff,%edx

#   d2 top = 0x46b00000
# movl  $0x46b00000,>d2=stack64#3
# movl  $0x46b00000,>d2=20(%esp)
movl  $0x46b00000,20(%esp)

#   inplace d2 bottom = word2
# movl <word2=int32#3,<d2=stack64#3
# movl <word2=%edx,<d2=16(%esp)
movl %edx,16(%esp)

#   word3 = *(uint32 *) (u + 10)
# movl 10(<u=int32#2),>word3=int32#3
# movl 10(<u=%ecx),>word3=%edx
movl 10(%ecx),%edx

#   word3 &= 0xffffff
# and  $0xffffff,<word3=int32#3
# and  $0xffffff,<word3=%edx
and  $0xffffff,%edx

#   d3 top = 0x48300000
# movl  $0x48300000,>d3=stack64#4
# movl  $0x48300000,>d3=28(%esp)
movl  $0x48300000,28(%esp)

#   inplace d3 bottom = word3
# movl <word3=int32#3,<d3=stack64#4
# movl <word3=%edx,<d3=24(%esp)
movl %edx,24(%esp)

#   word4 = *(uint32 *) (u + 12)
# movl 12(<u=int32#2),>word4=int32#2
# movl 12(<u=%ecx),>word4=%ecx
movl 12(%ecx),%ecx

#   (uint32) word4 >>= 8
# shr  $8,<word4=int32#2
# shr  $8,<word4=%ecx
shr  $8,%ecx

#   d4 top = 0x49b00000
# movl  $0x49b00000,>d4=stack64#5
# movl  $0x49b00000,>d4=36(%esp)
movl  $0x49b00000,36(%esp)

#   inplace d4 bottom = word4
# movl <word4=int32#2,<d4=stack64#5
# movl <word4=%ecx,<d4=32(%esp)
movl %ecx,32(%esp)

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

#   out4 = *(float64 *) &d4
# fldl <d4=stack64#5
# fldl <d4=32(%esp)
fldl 32(%esp)

#   out4 -= *(float64 *) &gaudry_pm_in4offset
fsubl gaudry_pm_in4offset

#   carry4 = *(float64 *) &gaudry_pm_alpha127
fldl gaudry_pm_alpha127

#   carry4 += out4
# fadd <out4=float80#2,<carry4=float80#1
# fadd <out4=%st(1),<carry4=%st(0)
fadd %st(1),%st(0)

#   carry4 -= *(float64 *) &gaudry_pm_alpha127
fsubl gaudry_pm_alpha127

#   out4 -= carry4
# fsubr <carry4=float80#1,<out4=float80#2
# fsubr <carry4=%st(0),<out4=%st(1)
fsubr %st(0),%st(1)

#   out0 = *(float64 *) &d0
# fldl <d0=stack64#1
# fldl <d0=0(%esp)
fldl 0(%esp)

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

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

#   carry4 *= *(float64 *) &gaudry_pm_scale
fmull gaudry_pm_scale

#   out0 += carry4
# faddp <carry4=float80#1,<out0=float80#2
# faddp <carry4=%st(0),<out0=%st(1)
faddp %st(0),%st(1)

#   carry0 = *(float64 *) &gaudry_pm_alpha26
fldl gaudry_pm_alpha26

#   carry0 += out0
# fadd <out0=float80#2,<carry0=float80#1
# fadd <out0=%st(1),<carry0=%st(0)
fadd %st(1),%st(0)

#   carry0 -= *(float64 *) &gaudry_pm_alpha26
fsubl gaudry_pm_alpha26

#   out0 -= carry0
# fsubr <carry0=float80#1,<out0=float80#2
# fsubr <carry0=%st(0),<out0=%st(1)
fsubr %st(0),%st(1)

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

#   *(float64 *) (out + 0) = out0
# fstpl 0(<out=int32#2)
# fstpl 0(<out=%ecx)
fstpl 0(%ecx)

#   out1 = *(float64 *) &d1
# fldl <d1=stack64#2
# fldl <d1=8(%esp)
fldl 8(%esp)

#   out1 -= *(float64 *) &gaudry_pm_in1offset
fsubl gaudry_pm_in1offset

#   out1 += carry0
# faddp <carry0=float80#1,<out1=float80#2
# faddp <carry0=%st(0),<out1=%st(1)
faddp %st(0),%st(1)

#   carry1 = *(float64 *) &gaudry_pm_alpha51
fldl gaudry_pm_alpha51

#   carry1 += out1
# fadd <out1=float80#2,<carry1=float80#1
# fadd <out1=%st(1),<carry1=%st(0)
fadd %st(1),%st(0)

#   carry1 -= *(float64 *) &gaudry_pm_alpha51
fsubl gaudry_pm_alpha51

#   out1 -= carry1
# fsubr <carry1=float80#1,<out1=float80#2
# fsubr <carry1=%st(0),<out1=%st(1)
fsubr %st(0),%st(1)

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

#   *(float64 *) (out + 8) = out1
# fstpl 8(<out=int32#2)
# fstpl 8(<out=%ecx)
fstpl 8(%ecx)

#   out2 = *(float64 *) &d2
# fldl <d2=stack64#3
# fldl <d2=16(%esp)
fldl 16(%esp)

#   out2 -= *(float64 *) &gaudry_pm_in2offset
fsubl gaudry_pm_in2offset

#   out2 += carry1
# faddp <carry1=float80#1,<out2=float80#2
# faddp <carry1=%st(0),<out2=%st(1)
faddp %st(0),%st(1)

#   carry2 = *(float64 *) &gaudry_pm_alpha77
fldl gaudry_pm_alpha77

#   carry2 += out2
# fadd <out2=float80#2,<carry2=float80#1
# fadd <out2=%st(1),<carry2=%st(0)
fadd %st(1),%st(0)

#   carry2 -= *(float64 *) &gaudry_pm_alpha77
fsubl gaudry_pm_alpha77

#   out2 -= carry2
# fsubr <carry2=float80#1,<out2=float80#2
# fsubr <carry2=%st(0),<out2=%st(1)
fsubr %st(0),%st(1)

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

#   *(float64 *) (out + 16) = out2
# fstpl 16(<out=int32#2)
# fstpl 16(<out=%ecx)
fstpl 16(%ecx)

#   out3 = *(float64 *) &d3
# fldl <d3=stack64#4
# fldl <d3=24(%esp)
fldl 24(%esp)

#   out3 -= *(float64 *) &gaudry_pm_in3offset
fsubl gaudry_pm_in3offset

#   out3 += carry2
# faddp <carry2=float80#1,<out3=float80#2
# faddp <carry2=%st(0),<out3=%st(1)
faddp %st(0),%st(1)

#   carry3 = *(float64 *) &gaudry_pm_alpha102
fldl gaudry_pm_alpha102

#   carry3 += out3
# fadd <out3=float80#2,<carry3=float80#1
# fadd <out3=%st(1),<carry3=%st(0)
fadd %st(1),%st(0)

#   carry3 -= *(float64 *) &gaudry_pm_alpha102
fsubl gaudry_pm_alpha102

#   out3 -= carry3
# fsubr <carry3=float80#1,<out3=float80#2
# fsubr <carry3=%st(0),<out3=%st(1)
fsubr %st(0),%st(1)

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

#   *(float64 *) (out + 24) = out3
# fstpl 24(<out=int32#2)
# fstpl 24(<out=%ecx)
fstpl 24(%ecx)

#   out4 += carry3
# faddp <carry3=float80#1,<out4=float80#2
# faddp <carry3=%st(0),<out4=%st(1)
faddp %st(0),%st(1)

#   *(float64 *) (out + 32) = out4
# fstpl 32(<out=int32#2)
# fstpl 32(<out=%ecx)
fstpl 32(%ecx)

# leave
add %eax,%esp
ret