# stack32 out_stack

# int32 out

# stack32 u_stack

# int32 u

# stack32 v_stack

# int32 v

# int32 eax

# int32 ebx

# int32 esi

# int32 edi

# int32 ebp

# float80 out0

# float80 out1

# float80 out2

# float80 out3

# float80 out4

# float80 carry0

# float80 carry1

# float80 carry2

# float80 carry3

# float80 carry4

# float80 u0v0

# float80 u0v1

# float80 u0v2

# float80 u0v3

# float80 u0v4

# float80 u1v0

# float80 u1v1

# float80 u1v2

# float80 u1v3

# float80 u1v4

# float80 u2v0

# float80 u2v1

# float80 u2v2

# float80 u2v3

# float80 u2v4

# float80 u3v0

# float80 u3v1

# float80 u3v2

# float80 u3v3

# float80 u3v4

# float80 u4v0

# float80 u4v1

# float80 u4v2

# float80 u4v3

# float80 u4v4

# enter gaudry_pm_mult
.text
.p2align 5
.globl _gaudry_pm_mult
.globl gaudry_pm_mult
_gaudry_pm_mult:
gaudry_pm_mult:
mov %esp,%eax
and $31,%eax
add $0,%eax
sub %eax,%esp

# input out_stack

# input u_stack

# input v_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

#   v = v_stack
# movl <v_stack=stack32#-3,>v=int32#3
# movl <v_stack=12(%esp,%eax),>v=%edx
movl 12(%esp,%eax),%edx

#   out3 = *(float64 *) (u + 32)
# fldl 32(<u=int32#2)
# fldl 32(<u=%ecx)
fldl 32(%ecx)

#   out3 *= *(float64 *) (v + 32)
# fmull 32(<v=int32#3)
# fmull 32(<v=%edx)
fmull 32(%edx)

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

#   u0v3 = *(float64 *) (u + 0)
# fldl 0(<u=int32#2)
# fldl 0(<u=%ecx)
fldl 0(%ecx)

#   u0v3 *= *(float64 *) (v + 24)
# fmull 24(<v=int32#3)
# fmull 24(<v=%edx)
fmull 24(%edx)

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

#   u1v2 = *(float64 *) (u + 8)
# fldl 8(<u=int32#2)
# fldl 8(<u=%ecx)
fldl 8(%ecx)

#   u1v2 *= *(float64 *) (v + 16)
# fmull 16(<v=int32#3)
# fmull 16(<v=%edx)
fmull 16(%edx)

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

#   u2v1 = *(float64 *) (u + 16)
# fldl 16(<u=int32#2)
# fldl 16(<u=%ecx)
fldl 16(%ecx)

#   u2v1 *= *(float64 *) (v + 8)
# fmull 8(<v=int32#3)
# fmull 8(<v=%edx)
fmull 8(%edx)

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

#   u3v0 = *(float64 *) (u + 24)
# fldl 24(<u=int32#2)
# fldl 24(<u=%ecx)
fldl 24(%ecx)

#   u3v0 *= *(float64 *) (v + 0)
# fmull 0(<v=int32#3)
# fmull 0(<v=%edx)
fmull 0(%edx)

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

#     out4 = *(float64 *) (u + 0)
# fldl 0(<u=int32#2)
# fldl 0(<u=%ecx)
fldl 0(%ecx)

#     out4 *= *(float64 *) (v + 32)
# fmull 32(<v=int32#3)
# fmull 32(<v=%edx)
fmull 32(%edx)

#     u1v3 = *(float64 *) (u + 8)
# fldl 8(<u=int32#2)
# fldl 8(<u=%ecx)
fldl 8(%ecx)

#     u1v3 *= *(float64 *) (v + 24)
# fmull 24(<v=int32#3)
# fmull 24(<v=%edx)
fmull 24(%edx)

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

#     u2v2 = *(float64 *) (u + 16)
# fldl 16(<u=int32#2)
# fldl 16(<u=%ecx)
fldl 16(%ecx)

#     u2v2 *= *(float64 *) (v + 16)
# fmull 16(<v=int32#3)
# fmull 16(<v=%edx)
fmull 16(%edx)

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

#     u3v1 = *(float64 *) (u + 24)
# fldl 24(<u=int32#2)
# fldl 24(<u=%ecx)
fldl 24(%ecx)

#     u3v1 *= *(float64 *) (v + 8)
# fmull 8(<v=int32#3)
# fmull 8(<v=%edx)
fmull 8(%edx)

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

#     u4v0 = *(float64 *) (u + 32)
# fldl 32(<u=int32#2)
# fldl 32(<u=%ecx)
fldl 32(%ecx)

#     u4v0 *= *(float64 *) (v + 0)
# fmull 0(<v=int32#3)
# fmull 0(<v=%edx)
fmull 0(%edx)

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

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

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

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

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

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

#       out0 = *(float64 *) (u + 8)
# fldl 8(<u=int32#2)
# fldl 8(<u=%ecx)
fldl 8(%ecx)

#       out0 *= *(float64 *) (v + 32)
# fmull 32(<v=int32#3)
# fmull 32(<v=%edx)
fmull 32(%edx)

#       u2v3 = *(float64 *) (u + 16)
# fldl 16(<u=int32#2)
# fldl 16(<u=%ecx)
fldl 16(%ecx)

#       u2v3 *= *(float64 *) (v + 24)
# fmull 24(<v=int32#3)
# fmull 24(<v=%edx)
fmull 24(%edx)

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

#       u3v2 = *(float64 *) (u + 24)
# fldl 24(<u=int32#2)
# fldl 24(<u=%ecx)
fldl 24(%ecx)

#       u3v2 *= *(float64 *) (v + 16)
# fmull 16(<v=int32#3)
# fmull 16(<v=%edx)
fmull 16(%edx)

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

#       u4v1 = *(float64 *) (u + 32)
# fldl 32(<u=int32#2)
# fldl 32(<u=%ecx)
fldl 32(%ecx)

#       u4v1 *= *(float64 *) (v + 8)
# fmull 8(<v=int32#3)
# fmull 8(<v=%edx)
fmull 8(%edx)

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

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

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

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

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

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

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

#               u0v0 = *(float64 *) (u + 0)
# fldl 0(<u=int32#2)
# fldl 0(<u=%ecx)
fldl 0(%ecx)

#               u0v0 *= *(float64 *) (v + 0)
# fmull 0(<v=int32#3)
# fmull 0(<v=%edx)
fmull 0(%edx)

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

#         out1 = *(float64 *) (u + 16)
# fldl 16(<u=int32#2)
# fldl 16(<u=%ecx)
fldl 16(%ecx)

#         out1 *= *(float64 *) (v + 32)
# fmull 32(<v=int32#3)
# fmull 32(<v=%edx)
fmull 32(%edx)

#         u3v3 = *(float64 *) (u + 24)
# fldl 24(<u=int32#2)
# fldl 24(<u=%ecx)
fldl 24(%ecx)

#         u3v3 *= *(float64 *) (v + 24)
# fmull 24(<v=int32#3)
# fmull 24(<v=%edx)
fmull 24(%edx)

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

#         u4v2 = *(float64 *) (u + 32)
# fldl 32(<u=int32#2)
# fldl 32(<u=%ecx)
fldl 32(%ecx)

#         u4v2 *= *(float64 *) (v + 16)
# fmull 16(<v=int32#3)
# fmull 16(<v=%edx)
fmull 16(%edx)

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

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

#         u0v1 = *(float64 *) (u + 0)
# fldl 0(<u=int32#2)
# fldl 0(<u=%ecx)
fldl 0(%ecx)

#         u0v1 *= *(float64 *) (v + 8)
# fmull 8(<v=int32#3)
# fmull 8(<v=%edx)
fmull 8(%edx)

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

#         u1v0 = *(float64 *) (u + 8)
# fldl 8(<u=int32#2)
# fldl 8(<u=%ecx)
fldl 8(%ecx)

#         u1v0 *= *(float64 *) (v + 0)
# fmull 0(<v=int32#3)
# fmull 0(<v=%edx)
fmull 0(%edx)

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

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

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

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

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

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

#           out2 = *(float64 *) (u + 24)
# fldl 24(<u=int32#2)
# fldl 24(<u=%ecx)
fldl 24(%ecx)

#           out2 *= *(float64 *) (v + 32)
# fmull 32(<v=int32#3)
# fmull 32(<v=%edx)
fmull 32(%edx)

#           u4v3 = *(float64 *) (u + 32)
# fldl 32(<u=int32#2)
# fldl 32(<u=%ecx)
fldl 32(%ecx)

#           u4v3 *= *(float64 *) (v + 24)
# fmull 24(<v=int32#3)
# fmull 24(<v=%edx)
fmull 24(%edx)

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

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

#           u0v2 = *(float64 *) (u + 0)
# fldl 0(<u=int32#2)
# fldl 0(<u=%ecx)
fldl 0(%ecx)

#           u0v2 *= *(float64 *) (v + 16)
# fmull 16(<v=int32#3)
# fmull 16(<v=%edx)
fmull 16(%edx)

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

#           u1v1 = *(float64 *) (u + 8)
# fldl 8(<u=int32#2)
# fldl 8(<u=%ecx)
fldl 8(%ecx)

#           u1v1 *= *(float64 *) (v + 8)
# fmull 8(<v=int32#3)
# fmull 8(<v=%edx)
fmull 8(%edx)

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

#           u2v0 = *(float64 *) (u + 16)
# fldl 16(<u=int32#2)
# fldl 16(<u=%ecx)
fldl 16(%ecx)

#           u2v0 *= *(float64 *) (v + 0)
# fmull 0(<v=int32#3)
# fmull 0(<v=%edx)
fmull 0(%edx)

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

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

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

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

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

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

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

#                     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

#                     out3 += carry2
# fadd <carry2=float80#1,<out3=float80#6
# fadd <carry2=%st(0),<out3=%st(5)
fadd %st(0),%st(5)

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

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

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

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

#                       out4 += carry3
# fadd <carry3=float80#1,<out4=float80#5
# fadd <carry3=%st(0),<out4=%st(4)
fadd %st(0),%st(4)

#                       out3 -= carry3
# fsubrp <carry3=float80#1,<out3=float80#6
# fsubrp <carry3=%st(0),<out3=%st(5)
fsubrp %st(0),%st(5)

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

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

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

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

# 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)

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

# leave
add %eax,%esp
ret