x86codegen bug (1/2)

Thu, 31 May 2001 16:18:13 -0700

MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Message-ID: <15126.53557.559865.246842@eponym.epr.com>
Date: Thu, 31 May 2001 16:18:13 -0700
To: MLton@sourcelight.com
Reply-to: MLton@sourcelight.com
Subject: x86codegen bug
X-Mailer: VM 6.89 under 21.1 (patch 14) "Cuyahoga Valley" XEmacs Lucid

Matthew, I assume the following indicates a codegen bug.

% mlton moments.sml
	fmovl MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)],MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
entries:
%edi MEM<>(l){Runtime}[(gcState+40)+(0*4)] 2013 false NO
%esi MEM<>(l){Runtime}[(gcState+12)+(0*4)] 2013 false NO
%eax MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)] 999 true NO
%ecx MEM<F>(l){Runtime}[globalpointer+(7*4)] 1009 true NO
%ebx MEM<F>(l){Runtime}[globalpointer+(10*4)] 1019 true NO
reserved:
fltstack:
%st(1) MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)] 1034 true NO
%st MEM<T>(l){Runtime}[localdouble+(3*8)] 1029 false NO

.p2align 2
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

skipGC_0:
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Assume: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Assume: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	cmpl $-1,MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Cache: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi (reserved)
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Cache: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi (reserved)
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi

# directive: Flush
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Commit: 
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	jg L_36
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Unreserve: %edi
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Unreserve: %esi
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	cmpl MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)],MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
remove: MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(164*1)]+(-2*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Cache: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi (reserved)
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Cache: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi (reserved)
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi

# directive: Flush
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Commit: 
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globaldouble+(0*8)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(11*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	jae L_96
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globaldouble+(0*8)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(11*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Unreserve: %edi
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globaldouble+(0*8)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(11*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

# directive: Unreserve: %esi
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globaldouble+(0*8)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(11*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmovl MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(11*4)]+(0*1)],MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
commit: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(11*4)]+(0*1)]
remove: MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globaldouble+(0*8)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(11*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(11*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fsubrl MEM<F>(l){Runtime}[globaldouble+(0*8)], MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
commit: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
remove: MEM<F>(l){Runtime}[globaldouble+(0*8)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USEDEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Runtime}[globaldouble+(0*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmovl MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)],MEM<T>(l){Runtime}[localdouble+(3*8)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmovl MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)],MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
commit: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fabsl MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
future: USEDEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	faddl MEM<T>(l){Runtime}[localdouble+(3*8)], MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
dead: MEM<T>(l){Runtime}[localdouble+(3*8)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
remove: MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USEDEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(10*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(10*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(3*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmovl MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)],MEM<T>(l){Runtime}[localdouble+(9*8)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(9*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmull MEM<T>(l){Runtime}[localdouble+(9*8)], MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(9*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(9*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	faddl MEM<T>(l){Runtime}[localdouble+(9*8)], MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(9*4)]+(0*1)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(9*4)]+(0*1)]
remove: MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(9*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(9*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmovl MEM<T>(l){Runtime}[localdouble+(9*8)],MEM<T>(l){Runtime}[localdouble+(13*8)]
dead: MEM<T>(l){Runtime}[localdouble+(9*8)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(8*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(9*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmull MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)], MEM<T>(l){Runtime}[localdouble+(13*8)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(8*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	faddl MEM<T>(l){Runtime}[localdouble+(13*8)], MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(8*4)]+(0*1)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(8*4)]+(0*1)]
remove: MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USEDEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(8*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(8*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmovl MEM<T>(l){Runtime}[localdouble+(13*8)],MEM<T>(l){Runtime}[localdouble+(19*8)]
dead: MEM<T>(l){Runtime}[localdouble+(13*8)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
future: DEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<T>(l){Runtime}[localdouble+(13*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmull MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)], MEM<T>(l){Runtime}[localdouble+(19*8)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
remove: MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(7*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(7*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	faddl MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)], MEM<T>(l){Runtime}[localdouble+(19*8)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USEDEF MEM<T>(l){Runtime}[localdouble+(19*8)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USE MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi
hint: MEM<>(l){Runtime}[(gcState+40)+(0*4)] -> %edi

	fmovl MEM<T>(l){Runtime}[localdouble+(19*8)],MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
dead: MEM<T>(l){Runtime}[localdouble+(19*8)]
remove: MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
remove: MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USE MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+12)+(0*4)]
future: USEDEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: DEF MEM<T>(l){Runtime}[overflowCheckTemp+(0*4)]
future: USE MEM<>(l){Runtime}[(gcState+40)+(0*4)]
future: USE MEM<F>(l){Stack}[MEM<>(l){Runtime}[(gcState+40)+(0*4)]+(184*1)]
future: DEF MEM<F>(l){Heap}[MEM<F>(l){Runtime}[globalpointer+(6*4)]+(0*1)]
future: USE MEM<F>(l){Runtime}[globalpointer+(6*4)]
future: USE MEM<T>(l){Runtime}[localdouble+(19*8)]
hint: MEM<>(l){Runtime}[(gcState+12)+(0*4)] -> %esi