From 139a7a223e7439a7aeb5bcc292e3904b274a766d Mon Sep 17 00:00:00 2001
From: david <david>
Date: Mon, 11 Jul 2011 22:57:35 +0000
Subject: [PATCH] annotated

---
 .../Tests/ssJava/mp3decoder/BitReserve.java   |   49 +-
 Robust/src/Tests/ssJava/mp3decoder/Crc16.java |   13 +-
 .../src/Tests/ssJava/mp3decoder/Decoder.java  |   18 +-
 .../Tests/ssJava/mp3decoder/Equalizer.java    |   21 +-
 .../src/Tests/ssJava/mp3decoder/Header.java   |   75 +-
 .../ssJava/mp3decoder/JavaLayerUtils.java     |    5 +-
 .../ssJava/mp3decoder/LayerIDecoder.java      |  156 ++-
 .../ssJava/mp3decoder/LayerIIDecoder.java     |  233 +--
 .../ssJava/mp3decoder/LayerIIIDecoder.java    |  553 ++++----
 .../src/Tests/ssJava/mp3decoder/Obuffer.java  |    8 +-
 .../ssJava/mp3decoder/OutputChannels.java     |   24 +-
 .../src/Tests/ssJava/mp3decoder/Player.java   |    2 +-
 .../Tests/ssJava/mp3decoder/SampleBuffer.java |   12 +-
 .../ssJava/mp3decoder/SynthesisFilter.java    | 1247 +++++++++--------
 .../Tests/ssJava/mp3decoder/huffcodetab.java  |  109 +-
 15 files changed, 1383 insertions(+), 1142 deletions(-)

diff --git a/Robust/src/Tests/ssJava/mp3decoder/BitReserve.java b/Robust/src/Tests/ssJava/mp3decoder/BitReserve.java
index 24794c1a..bd57b6ea 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/BitReserve.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/BitReserve.java
@@ -38,6 +38,8 @@
 
 // REVIEW: there is no range checking, so buffer underflow or overflow
 // can silently occur.
+@LATTICE("SH<V,V<T,TOT<OFF,OFF<T,SH*,TOT*,OFF*")
+@METHODDEFAULT("OUT<V,V<C,C<IN,C*,THISLOC=V,GLOBALLOC=V")
 final class BitReserve
 {
    /**
@@ -45,30 +47,34 @@ final class BitReserve
     * Must be a power of 2. And x8, as each bit is stored as a single
     * entry.
     */
-	private static final int		BUFSIZE = 4096*8;
+    @LOC("T") private static final int BUFSIZE = 4096*8;
 	
 	/**
 	 * Mask that can be used to quickly implement the
 	 * modulus operation on BUFSIZE.
 	 */
-	private static final int		BUFSIZE_MASK = BUFSIZE-1;
+    @LOC("V") private static final int BUFSIZE_MASK = BUFSIZE-1;
 	
-	private int 					offset, totbit, buf_byte_idx;
-	private final int[] 			buf = new int[BUFSIZE];
-	private int 					buf_bit_idx;
+    @LOC("OFF") private int offset;
+    @LOC("TOT") private int totbit;
+    @LOC("SH") private int buf_byte_idx;
+    @LOC("V") private final int[] buf;
+    @LOC("T") private int buf_bit_idx;
 	
    BitReserve()
-   {
-	  
-	  offset = 0;
+   {	  
+      offset = 0;
       totbit = 0;
-      buf_byte_idx = 0;	  
+      buf_byte_idx = 0;
+      buf = new int[BUFSIZE];
    }
       
    
    /**
     * Return totbit Field.
 	*/
+
+   @RETURNLOC("OUT")
    public int hsstell() 
    { 
 	   return(totbit); 
@@ -78,13 +84,15 @@ final class BitReserve
     * Read a number bits from the bit stream.
     * @param N the number of
 	*/
-   public int hgetbits(int N)
+   @LATTICE("OUT<SH,SH<THIS,THIS<C,C<GLOBAL,C*,SH*,THISLOC=THIS,GLOBALLOC=GLOBAL")
+   @RETURNLOC("OUT") 
+   public int hgetbits(@LOC("C") int N)
    {
    	 totbit += N;
 	 
-	 int val = 0;
+	 @LOC("SH") int val = 0;
 	 
-	 int pos = buf_byte_idx;
+	 @LOC("THIS,BitReserve.SH") int pos = buf_byte_idx;
 	 if (pos+N < BUFSIZE)
 	 {
 		while (N-- > 0)
@@ -133,11 +141,12 @@ final class BitReserve
     * Returns next bit from reserve.
     * @returns 0 if next bit is reset, or 1 if next bit is set.
     */
+   @RETURNLOC("OUT")
    public int hget1bit()
    {   	  
-	  totbit++;	  
-	  int val = buf[buf_byte_idx];
-	  buf_byte_idx = (buf_byte_idx+1) & BUFSIZE_MASK;
+      totbit++;	  
+      @LOC("OUT") int val = buf[buf_byte_idx];
+      buf_byte_idx = (buf_byte_idx+1) & BUFSIZE_MASK;
       return val;
    }
    
@@ -177,9 +186,10 @@ final class BitReserve
    /**
     * Write 8 bits into the bit stream.
 	*/
-   public void hputbuf(int val)
+   @LATTICE("OUT<THIS,THIS<IN,THISLOC=THIS,GLOBALLOC=IN")
+   public void hputbuf(@LOC("IN") int val)
    {   	  
-	   int ofs = offset;
+           @LOC("THIS,BitReserve.OFF") int ofs = offset;
 	   buf[ofs++] = val & 0x80;
 	   buf[ofs++] = val & 0x40;
 	   buf[ofs++] = val & 0x20;
@@ -210,9 +220,10 @@ final class BitReserve
    /**
     * Rewind N bytes in Stream.
 	*/
-   public void rewindNbytes(int N)
+   @LATTICE("THIS<BIT,BIT<N,THISLOC=THIS,GLOBALLOC=N")
+   public void rewindNbytes(@LOC("N") int N)
    {
-      int bits = (N << 3);
+          @LOC("BIT") int bits = (N << 3);
 	  totbit -= bits;
 	  buf_byte_idx -= bits;	  
 	  if (buf_byte_idx<0)
diff --git a/Robust/src/Tests/ssJava/mp3decoder/Crc16.java b/Robust/src/Tests/ssJava/mp3decoder/Crc16.java
index 058896af..ae35b481 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/Crc16.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/Crc16.java
@@ -26,10 +26,12 @@
 /**
  * 16-Bit CRC checksum
  */
+@LATTICE("B<T,B*")
+@METHODDEFAULT("OUT<V,V<SH,SH<IN,SH*,THISLOC=V,GLOBALLOC=V")
 public final class Crc16
 {
-  private static	short polynomial=(short)0x8005;
-  private			short crc;
+  @LOC("T") private static	short polynomial=(short)0x8005;
+  @LOC("B") private			short crc;
 
   /**
    * Dummy Constructor
@@ -42,9 +44,9 @@ public final class Crc16
   /**
    * Feed a bitstring to the crc calculation (0 < length <= 32).
    */
-  public void add_bits (int bitstring, int length)
+  public void add_bits (@LOC("IN") int bitstring, @LOC("IN") int length)
   {
-  	int bitmask = 1 << (length - 1);
+        @LOC("SH") int bitmask = 1 << (length - 1);
   	do
 	 if (((crc & 0x8000) == 0) ^ ((bitstring & bitmask) == 0 ))
 	 {
@@ -60,9 +62,10 @@ public final class Crc16
    * Return the calculated checksum.
    * Erase it for next calls to add_bits().
    */
+  @RETURNLOC("OUT")
   public short	checksum()
   {
-    short sum = crc;
+    @LOC("OUT") short sum = crc;
     crc = (short) 0xFFFF;
     return sum;
   }
diff --git a/Robust/src/Tests/ssJava/mp3decoder/Decoder.java b/Robust/src/Tests/ssJava/mp3decoder/Decoder.java
index ffafed30..4d064359 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/Decoder.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/Decoder.java
@@ -34,7 +34,7 @@ public class Decoder implements DecoderErrors
 	/**
 	 * The Bistream from which the MPEG audio frames are read.
 	 */
-	//private Bitstream				stream;
+	private Bitstream				stream;
 	
 	/**
 	 * The Obuffer instance that will receive the decoded
@@ -134,7 +134,7 @@ public class Decoder implements DecoderErrors
 	{
 		if (!initialized)
 		{
-			initialize(header);
+		    initialize(header,stream);
 		}
 		
 		int layer = header.layer();
@@ -262,7 +262,7 @@ public class Decoder implements DecoderErrors
 		return decoder;
 	}
 	
-	private void initialize(Header header)
+        public void initialize(Header header, Bitstream stream)
 		throws DecoderException
 	{
 		
@@ -287,7 +287,17 @@ public class Decoder implements DecoderErrors
 
 		outputChannels = channels;
 		outputFrequency = header.frequency();
-		
+
+		l3decoder = new LayerIIIDecoder(stream, header, filter1, filter2, 
+					        output, OutputChannels.BOTH_CHANNELS);
+		l2decoder = new LayerIIDecoder();
+		l2decoder.create(stream, header, filter1, filter2, 
+				 output, OutputChannels.BOTH_CHANNELS);
+
+		l1decoder = new LayerIDecoder();
+		l1decoder.create(stream,header, filter1, filter2, 
+				 output, OutputChannels.BOTH_CHANNELS);	
+
 		initialized = true;
 	}
 	
diff --git a/Robust/src/Tests/ssJava/mp3decoder/Equalizer.java b/Robust/src/Tests/ssJava/mp3decoder/Equalizer.java
index 1dc88f42..f0eb6185 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/Equalizer.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/Equalizer.java
@@ -34,19 +34,21 @@
  * 
  * @author MDM
  */
+@LATTICE("B<T")
+@METHODDEFAULT("OUT<V,V<SH,SH<C,C<IN,SH*,THISLOC=IN,GLOBALLOC=IN")
 public final class Equalizer
 {		
 	/**
 	 * Equalizer setting to denote that a given band will not be
 	 * present in the output signal.
 	 */
-	static public final float BAND_NOT_PRESENT = Float.NEGATIVE_INFINITY;
+        @LOC("T") static public final float BAND_NOT_PRESENT = Float.NEGATIVE_INFINITY;
 		
-	static public final Equalizer	PASS_THRU_EQ = new Equalizer();
+        @LOC("T") static public final Equalizer	PASS_THRU_EQ = new Equalizer();
 	
-	private static final int BANDS = 32;
+        @LOC("T") private static final int BANDS = 32;
 	
-	private final float[]	settings = new float[BANDS];
+        @LOC("B") private final float[]	settings = new float[BANDS];
 	
 	/**
 	 * Creates a new <code>Equalizer</code> instance. 
@@ -178,10 +180,12 @@ public final class Equalizer
 	 * @return	an array of factors that can be applied to the
 	 *			subbands.
 	 */
+        @RETURNLOC("OUT") 
 	float[] getBandFactors()
 	{
-		float[] factors = new float[BANDS];
-		for (int i=0, maxCount=BANDS; i<maxCount; i++)
+	        @LOC("OUT") float[] factors = new float[BANDS];
+		@LOC("C") int maxCount = BANDS;
+		for (@LOC("SH") int i=0; i<maxCount; i++)
 		{
 			factors[i] = getBandFactor(settings[i]);
 		}
@@ -195,12 +199,13 @@ public final class Equalizer
 	 * n is the equalizer band setting in the range [-1.0,1.0].
 	 * 	 
 	 */
-	float getBandFactor(float eq)
+        @RETURNLOC("C")
+        float getBandFactor(@LOC("IN") float eq)
 	{
 		if (eq==BAND_NOT_PRESENT)
 			return 0.0f;
 		
-		float f = (float)Math.pow(2.0, eq);
+		@LOC("C") float f = (float)Math.pow(2.0, eq);
 		return f;
 	}
 	
diff --git a/Robust/src/Tests/ssJava/mp3decoder/Header.java b/Robust/src/Tests/ssJava/mp3decoder/Header.java
index b0dd1001..09f1b231 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/Header.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/Header.java
@@ -33,9 +33,11 @@
 /**
  * Class for extracting information from a frame header.
  */
+@LATTICE("HI<HNS,HNS<H,C<H,NS<FS,FS<H,FS<HV,H<SYNC,HV<SYNC,HV<T,SYNC*,HV*,FS*,HI*")
+@METHODDEFAULT("OUT<V,V<THIS,THIS<SH,SH<IN,SH*,THISLOC=THIS,GLOBALLOC=IN")
 public final class Header
 {
-	public  static final int[][]	frequencies =
+        @LOC("T") public  static final int[][]	frequencies =
 						{{22050, 24000, 16000, 1},
 						{44100, 48000, 32000, 1},
 						{11025, 12000, 8000, 1}};	// SZD: MPEG25
@@ -43,45 +45,50 @@ public final class Header
 	/**
 	 * Constant for MPEG-2 LSF version
 	 */
-	public static final int		MPEG2_LSF = 0;
-	public static final int		MPEG25_LSF = 2;	// SZD
+        @LOC("T") public static final int		MPEG2_LSF = 0;
+        @LOC("T") public static final int		MPEG25_LSF = 2;	// SZD
 
 	/**
 	 * Constant for MPEG-1 version
 	 */
-	public static final int		MPEG1 = 1;
-
-	public static final int		STEREO = 0;
-	public static final int		JOINT_STEREO = 1;
-	public static final int		DUAL_CHANNEL = 2;
-	public static final int		SINGLE_CHANNEL = 3;
-	public static final int		FOURTYFOUR_POINT_ONE = 0;
-	public static final int		FOURTYEIGHT=1;
-	public static final int		THIRTYTWO=2;
-
-	private int				h_layer, h_protection_bit, h_bitrate_index,
-	  						h_padding_bit, h_mode_extension;
-	private int				h_version;
-	private int				h_mode;
-	private int				h_sample_frequency;
-	private int				h_number_of_subbands, h_intensity_stereo_bound;
-	private boolean			h_copyright, h_original;
+        @LOC("T") public static final int		MPEG1 = 1;
+
+        @LOC("T") public static final int		STEREO = 0;
+        @LOC("T") public static final int		JOINT_STEREO = 1;
+        @LOC("T") public static final int		DUAL_CHANNEL = 2;
+        @LOC("T") public static final int		SINGLE_CHANNEL = 3;
+        @LOC("T") public static final int		FOURTYFOUR_POINT_ONE = 0;
+        @LOC("T") public static final int		FOURTYEIGHT=1;
+        @LOC("T") public static final int		THIRTYTWO=2;
+
+    @LOC("H") private int				h_layer;
+    @LOC("H") private int  h_protection_bit;
+    @LOC("H") private int h_bitrate_index;
+    @LOC("H") private int h_padding_bit;
+    @LOC("H") private int h_mode_extension;
+    @LOC("HV") private int				h_version;
+    @LOC("H") private int				h_mode;
+    @LOC("H") private int				h_sample_frequency;
+    @LOC("HNS") private int				h_number_of_subbands;
+    @LOC("HI") private int h_intensity_stereo_bound;
+    @LOC("H") private boolean			h_copyright;
+    @LOC("H") private int h_original;
 	// VBR support added by E.B
-	private double[] 		h_vbr_time_per_frame = {-1, 384, 1152, 1152};
-	private boolean			h_vbr;
-	private int				h_vbr_frames;
-	private int				h_vbr_scale;
-	private int				h_vbr_bytes;
-	private byte[]			h_vbr_toc;
+    @LOC("T") private double[] 		h_vbr_time_per_frame = {-1, 384, 1152, 1152};
+    @LOC("T") private boolean			h_vbr;
+    @LOC("T") private int				h_vbr_frames;
+    @LOC("T") private int				h_vbr_scale;
+    @LOC("T") private int				h_vbr_bytes;
+    @LOC("T") private byte[]			h_vbr_toc;
 	
-	private byte			syncmode = Bitstream.INITIAL_SYNC;
-	private Crc16			crc;
+    @LOC("SYNC") private byte			syncmode = Bitstream.INITIAL_SYNC;
+    @LOC("C") private Crc16			crc;
 
-	public short			checksum;
-	public int				framesize;
-	public int				nSlots;
+    @LOC("C") public short			checksum;
+    @LOC("FS") public int				framesize;
+    @LOC("NS") public int				nSlots;
 
-	private int				_headerstring = -1; // E.B
+    @LOC("T") private int				_headerstring = -1; // E.B
 
 	Header()
 	{
@@ -437,7 +444,7 @@ public final class Header
 	public int mode_extension() { return h_mode_extension; }
 
 	// E.B -> private to public
-	public static final int bitrates[][][] = {
+    @LOC("T") public static final int bitrates[][][] = {
 		{{0 /*free format*/, 32000, 48000, 56000, 64000, 80000, 96000,
 	  112000, 128000, 144000, 160000, 176000, 192000 ,224000, 256000, 0},
 	 	{0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
@@ -597,7 +604,7 @@ public final class Header
 	}
 
 	// E.B -> private to public
-	public static final String bitrate_str[][][] = {
+    @LOC("T") public static final String bitrate_str[][][] = {
 		{{"free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
 	  "80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s",
 	  "160 kbit/s", "176 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s",
diff --git a/Robust/src/Tests/ssJava/mp3decoder/JavaLayerUtils.java b/Robust/src/Tests/ssJava/mp3decoder/JavaLayerUtils.java
index 2156e3db..9a32c5b8 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/JavaLayerUtils.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/JavaLayerUtils.java
@@ -117,9 +117,10 @@ public class JavaLayerUtils
 		
 		Object obj = deserialize(in);
 		
+		//SSJava will never throw exceptions as it is so this code is meaningless
+		/*
 		Class cls = obj.getClass();
 		
-		
 		if (!cls.isArray())
 			throw new InvalidObjectException("object is not an array");
 		
@@ -133,7 +134,7 @@ public class JavaLayerUtils
 			if (arrayLength!=length)
 				throw new InvalidObjectException("array length mismatch");
 		}
-		
+		*/
 		return obj;
 	}
 
diff --git a/Robust/src/Tests/ssJava/mp3decoder/LayerIDecoder.java b/Robust/src/Tests/ssJava/mp3decoder/LayerIDecoder.java
index 97363a97..89eb5dec 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/LayerIDecoder.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/LayerIDecoder.java
@@ -28,27 +28,30 @@
 /**
  * Implements decoding of MPEG Audio Layer I frames. 
  */
-class LayerIDecoder implements FrameDecoder
+@LATTICE("L<SH,SH<H,SH*")
+@METHODDEFAULT("OUT<V,V<SH,SH<IN,SH*,THISLOC=V,GLOBALLOC=IN")
+    class LayerIDecoder //implements FrameDecoder //compiler cannot do interfaces
 {
-	protected Bitstream 			stream;
-    protected Header 				header;
-    protected SynthesisFilter 		filter1, filter2;
-    protected Obuffer 				buffer;
-    protected int 					which_channels;
-	protected int					mode;
+    @LOC("H") protected Bitstream 			        stream;
+    @LOC("H") protected Header 				        header;
+    @LOC("H") protected SynthesisFilter 		        filter1;
+    @LOC("H") protected SynthesisFilter                         filter2;
+    @LOC("H") protected Obuffer 				buffer;
+    @LOC("H") protected int 					which_channels;
+    @LOC("H") protected int					mode;
 	
-	protected int					num_subbands;
-	protected Subband[]				subbands;
-	protected Crc16					crc	= null;	// new Crc16[1] to enable CRC checking.
+    @LOC("H") protected int					num_subbands;
+    @LOC("L") protected Subband[]				subbands;
+    @LOC("H") protected Crc16					crc	= null;	// new Crc16[1] to enable CRC checking.
 	
 	public LayerIDecoder()
 	{
 		crc = new Crc16();
 	}
 	
-	public void create(Bitstream stream0, Header header0,
-		SynthesisFilter filtera, SynthesisFilter filterb,
-		Obuffer buffer0, int which_ch0)
+    public void create(@LOC("IN") Bitstream stream0, @LOC("IN") Header header0,
+		@LOC("IN") SynthesisFilter filtera, @LOC("IN") SynthesisFilter filterb,
+		@LOC("IN") Obuffer buffer0, @LOC("IN") int which_ch0)
 	{		
 	  	stream         = stream0;
 	  	header         = header0;
@@ -82,7 +85,7 @@ class LayerIDecoder implements FrameDecoder
 
 	protected void createSubbands()
 	{  		
-		int i;
+	        @LOC("V,LayerIDecoder.SH") int i;
 		if (mode == Header.SINGLE_CHANNEL)
   		  for (i = 0; i < num_subbands; ++i)
   		    subbands[i] = new SubbandLayer1(i);
@@ -103,7 +106,7 @@ class LayerIDecoder implements FrameDecoder
 	protected void readAllocation() throws DecoderException
 	{
 		// start to read audio data:
-  	    for (int i = 0; i < num_subbands; ++i)
+  	    for (@LOC("V,LayerIDecoder.SH") int i = 0; i < num_subbands; ++i)
   	      subbands[i].read_allocation(stream, header, crc);
 		
 	}
@@ -115,16 +118,16 @@ class LayerIDecoder implements FrameDecoder
 	
 	protected void readScaleFactors()
 	{
-		for (int i = 0; i < num_subbands; ++i)
+	      for (@LOC("SH") int i = 0; i < num_subbands; ++i)
   		  subbands[i].read_scalefactor(stream, header);  		
 	}
 	
 	protected void readSampleData()
 	{
-		boolean read_ready = false;
-		boolean write_ready = false;
-		int mode = header.mode();
-		int i;
+	        @LOC("SH") boolean read_ready = false;
+		@LOC("SH") boolean write_ready = false;
+		@LOC("OUT") int mode = header.mode();
+		@LOC("SH") int i;
 		do
   		{
   		  for (i = 0; i < num_subbands; ++i)
@@ -145,6 +148,7 @@ class LayerIDecoder implements FrameDecoder
 	/**
 	 * Abstract base class for subband classes of layer I and II
 	 */
+        @LATTICE("L<H")
 	static abstract class Subband
 	{
 	 /*
@@ -153,7 +157,7 @@ class LayerIDecoder implements FrameDecoder
 	  *      is illegal (to prevent segmentation faults)
 	  */
 	  // Scalefactors for layer I and II, Annex 3-B.1 in ISO/IEC DIS 11172:
-	  public static final float scalefactors[] =
+	  @LOC("H") public static final float scalefactors[] =
 	  {
 	  2.00000000000000f, 1.58740105196820f, 1.25992104989487f, 1.00000000000000f,
 	  0.79370052598410f, 0.62996052494744f, 0.50000000000000f, 0.39685026299205f,
@@ -184,11 +188,13 @@ class LayerIDecoder implements FrameDecoder
 	 * Used for single channel mode
 	 * and in derived class for intensity stereo mode
 	 */
+        @LATTICE("S<L,L<H,H<SH,SH*,S*")
+	@METHODDEFAULT("OUT<V,V<SH,SH<IN,SH*,THISLOC=V,GLOBALLOC=IN")
 	static class SubbandLayer1 extends Subband
 	{
 
 	  // Factors and offsets for sample requantization
-	  public static final float table_factor[] = {
+	  @LOC("H") public static final float table_factor[] = {
 	   0.0f, (1.0f/2.0f) * (4.0f/3.0f), (1.0f/4.0f) * (8.0f/7.0f), (1.0f/8.0f) * (16.0f/15.0f),
 	  (1.0f/16.0f) * (32.0f/31.0f), (1.0f/32.0f) * (64.0f/63.0f), (1.0f/64.0f) * (128.0f/127.0f),
 	  (1.0f/128.0f) * (256.0f/255.0f), (1.0f/256.0f) * (512.0f/511.0f),
@@ -197,7 +203,7 @@ class LayerIDecoder implements FrameDecoder
 	  (1.0f/8192.0f) * (16384.0f/16383.0f), (1.0f/16384.0f) * (32768.0f/32767.0f)
 	  };
 
-	  public static final float table_offset[] = {
+	  @LOC("H") public static final float table_offset[] = {
 	   0.0f, ((1.0f/2.0f)-1.0f) * (4.0f/3.0f), ((1.0f/4.0f)-1.0f) * (8.0f/7.0f), ((1.0f/8.0f)-1.0f) * (16.0f/15.0f),
 	  ((1.0f/16.0f)-1.0f) * (32.0f/31.0f), ((1.0f/32.0f)-1.0f) * (64.0f/63.0f), ((1.0f/64.0f)-1.0f) * (128.0f/127.0f),
 	  ((1.0f/128.0f)-1.0f) * (256.0f/255.0f), ((1.0f/256.0f)-1.0f) * (512.0f/511.0f),
@@ -206,18 +212,19 @@ class LayerIDecoder implements FrameDecoder
 	  ((1.0f/8192.0f)-1.0f) * (16384.0f/16383.0f), ((1.0f/16384.0f)-1.0f) * (32768.0f/32767.0f)
 	  };
 
-	  protected int			 subbandnumber;
-	  protected int			 samplenumber;
-	  protected int			 allocation;
-	  protected float		 scalefactor;
-	  protected int 		 samplelength;
-	  protected float 		 sample;
-	  protected float 		 factor, offset;
+	  @LOC("H") protected int		 subbandnumber;
+	  @LOC("SH") protected int		 samplenumber;
+	  @LOC("H") protected int		 allocation;
+	  @LOC("L") protected float		 scalefactor;
+	  @LOC("L") protected int 		 samplelength;
+	  @LOC("S")protected float 		 sample;
+	  @LOC("L") protected float 		 factor;
+	  @LOC("L") protected float              offset;
 
 	  /**
 	   * Construtor.
 	   */
-	  public SubbandLayer1(int subbandnumber)
+	  public SubbandLayer1(@LOC("IN")int subbandnumber)
 	  {
 	    this.subbandnumber = subbandnumber;
 	    samplenumber = 0;  
@@ -226,9 +233,10 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_allocation(Bitstream stream, Header header, Crc16 crc) throws DecoderException
+	    public void read_allocation(@LOC("IN") Bitstream stream, @LOC("IN") Header header, 
+                                        @LOC("IN") Crc16 crc) throws DecoderException
 	  {
-	    if ((allocation = stream.get_bits (4)) == 15) 
+	    if ((allocation = stream.get_bits(4)) == 15) 
 	    {
 	    	// CGJ: catch this condition and throw appropriate exception
 	    	throw new DecoderException(DecoderErrors.ILLEGAL_SUBBAND_ALLOCATION, null);    	
@@ -236,19 +244,19 @@ class LayerIDecoder implements FrameDecoder
 			// MPEG-stream is corrupted!
 	    }
 
-		if (crc != null) crc.add_bits (allocation, 4);
+		if (crc != null) crc.add_bits(allocation, 4);
 	  	if (allocation != 0)
 	    {
 		 samplelength = allocation + 1;
 		 factor = table_factor[allocation];
-	     offset = table_offset[allocation];
+	         offset = table_offset[allocation];
 	    }
 	  }
 
 	  /**
 	   *
 	   */
-	  public void read_scalefactor(Bitstream stream, Header header)
+	    public void read_scalefactor(@LOC("IN") Bitstream stream, @LOC("IN") Header header)
 	  {
 	    if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
 	  }
@@ -256,7 +264,8 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean read_sampledata(Bitstream stream)
+	  @RETURNLOC("OUT") 
+	  public boolean read_sampledata(@LOC("IN") Bitstream stream)
 	  {
 	    if (allocation != 0)
 	    {
@@ -273,11 +282,13 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+	  @RETURNLOC("OUT")
+	  public boolean put_next_sample(@LOC("IN") int channels, @LOC("IN") SynthesisFilter filter1, 
+                                         @LOC("IN") SynthesisFilter filter2)
 	  {
 	    if ((allocation !=0) && (channels != OutputChannels.RIGHT_CHANNEL))
 	    {
-		   float scaled_sample = (sample * factor + offset) * scalefactor;
+		   @LOC("OUT") float scaled_sample = (sample * factor + offset) * scalefactor;
 		   filter1.input_sample (scaled_sample, subbandnumber);
 	    }
 	    return true;
@@ -287,14 +298,16 @@ class LayerIDecoder implements FrameDecoder
 	/**
 	 * Class for layer I subbands in joint stereo mode.
 	 */
+        @LATTICE("L<H,H<SH,SH*")
+	@METHODDEFAULT("OUT<V,V<SH,SH<IN,SH*,THISLOC=V,GLOBALLOC=IN")
 	static class SubbandLayer1IntensityStereo extends SubbandLayer1
 	{
-	  protected float 		channel2_scalefactor;
+	  @LOC("L") protected float 		channel2_scalefactor;
 
 	  /**
 	   * Constructor
 	   */
-	  public SubbandLayer1IntensityStereo(int subbandnumber)
+	  public SubbandLayer1IntensityStereo(@LOC("IN") int subbandnumber)
 	  {
 		super(subbandnumber);  
 	  }
@@ -302,7 +315,8 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_allocation(Bitstream stream, Header header, Crc16 crc) throws DecoderException
+	  public void read_allocation(@LOC("IN") Bitstream stream, @LOC("IN") Header header, 
+                                      @LOC("IN") Crc16 crc) throws DecoderException
 	  {
 	    super.read_allocation (stream, header, crc);
 	  }
@@ -310,7 +324,7 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_scalefactor (Bitstream stream, Header header)
+	  public void read_scalefactor (@LOC("IN") Bitstream stream, @LOC("IN") Header header)
 	  {
 	    if (allocation != 0)
 	    {
@@ -322,7 +336,8 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean read_sampledata(Bitstream stream)
+	  @RETURNLOC("OUT")
+	  public boolean read_sampledata(@LOC("IN") Bitstream stream)
 	  {
 	  	 return super.read_sampledata (stream);
 	  }
@@ -330,26 +345,28 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean put_next_sample (int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+	  @RETURNLOC("OUT")
+	  public boolean put_next_sample(@LOC("IN") int channels, @LOC("IN") SynthesisFilter filter1, 
+                                         @LOC("IN") SynthesisFilter filter2)
 	  {
 	    if (allocation !=0 )
 	    {
 	      sample = sample * factor + offset;		// requantization
 		  if (channels == OutputChannels.BOTH_CHANNELS)
 	      {
-			float sample1 = sample * scalefactor,
-			sample2 = sample * channel2_scalefactor;
+		        @LOC("OUT") float sample1 = sample * scalefactor;
+			@LOC("OUT") float sample2 = sample * channel2_scalefactor;
 			filter1.input_sample(sample1, subbandnumber);
 			filter2.input_sample(sample2, subbandnumber);
 		  }
 		  else if (channels == OutputChannels.LEFT_CHANNEL)
 		  {
-			float sample1 = sample * scalefactor;
+		        @LOC("OUT") float sample1 = sample * scalefactor;
 			filter1.input_sample(sample1, subbandnumber);
 		  }
 		  else
 		  {
-			float sample2 = sample * channel2_scalefactor;
+		        @LOC("OUT") float sample2 = sample * channel2_scalefactor;
 			filter1.input_sample(sample2, subbandnumber);
 		  }
 	    }
@@ -360,19 +377,22 @@ class LayerIDecoder implements FrameDecoder
 	/**
 	 * Class for layer I subbands in stereo mode.
 	 */
+        @LATTICE("L<H,H<SH,SH*")
+	@METHODDEFAULT("OUT<V,V<SH,SH<IN,SH*,THISLOC=V,GLOBALLOC=IN")
 	static class SubbandLayer1Stereo extends SubbandLayer1
 	{
-	  protected int 		channel2_allocation;
-	  protected float		channel2_scalefactor;
-	  protected int 		channel2_samplelength;
-	  protected float	 	channel2_sample;
-	  protected float 	 	channel2_factor, channel2_offset;
+	  @LOC("H") protected int 		channel2_allocation;
+	  @LOC("L") protected float		channel2_scalefactor;
+	  @LOC("L") protected int 		channel2_samplelength;
+	  @LOC("S") protected float	 	channel2_sample;
+	  @LOC("L") protected float 	 	channel2_factor;
+	  @LOC("L") protected float             channel2_offset;
 
 
 	  /**
 	   * Constructor
 	   */
-	  public SubbandLayer1Stereo(int subbandnumber)
+	  public SubbandLayer1Stereo(@LOC("IN") int subbandnumber)
 	  {
 	    super(subbandnumber);
 	  }
@@ -380,33 +400,34 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_allocation (Bitstream stream, Header header, Crc16 crc) throws DecoderException
+	  public void read_allocation (@LOC("IN") Bitstream stream, @LOC("IN") Header header, 
+          @LOC("IN") Crc16 crc) throws DecoderException
 	  {
-	 	 allocation = stream.get_bits(4);
+	     allocation = stream.get_bits(4);
 	     channel2_allocation = stream.get_bits(4);
 	     if (crc != null)
 	     {
-		   crc.add_bits (allocation, 4);
-	       crc.add_bits (channel2_allocation, 4);
+		crc.add_bits (allocation, 4);
+	        crc.add_bits (channel2_allocation, 4);
 	     }
 	     if (allocation != 0)
 	     {
-		    samplelength = allocation + 1;
+		samplelength = allocation + 1;
 	        factor = table_factor[allocation];
 	        offset = table_offset[allocation];
 	     }
 	     if (channel2_allocation != 0)
 	     {
 	        channel2_samplelength = channel2_allocation + 1;
-		    channel2_factor = table_factor[channel2_allocation];
-		    channel2_offset = table_offset[channel2_allocation];
+		channel2_factor = table_factor[channel2_allocation];
+		channel2_offset = table_offset[channel2_allocation];
 	     }
 	  }
 	  
 	  /**
 	   *
 	   */
-	  public void read_scalefactor(Bitstream stream, Header header)
+	  public void read_scalefactor(@LOC("IN") Bitstream stream, @LOC("IN") Header header)
 	  {
 	    if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
 	    if (channel2_allocation != 0) channel2_scalefactor = scalefactors[stream.get_bits(6)];
@@ -415,7 +436,8 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean read_sampledata (Bitstream stream)
+	  @RETURNLOC("OUT")
+	  public boolean read_sampledata (@LOC("IN")Bitstream stream)
 	  {
 	     boolean returnvalue = super.read_sampledata(stream);
 	     if (channel2_allocation != 0)
@@ -428,12 +450,14 @@ class LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+	  @RETURNLOC("OUT")
+	  public boolean put_next_sample(@LOC("IN") int channels, @LOC("IN") SynthesisFilter filter1, 
+                                         @LOC("IN") SynthesisFilter filter2)
 	  {
 	     super.put_next_sample (channels, filter1, filter2);
 	     if ((channel2_allocation != 0) && (channels != OutputChannels.LEFT_CHANNEL))
 	     {
-		    float sample2 = (channel2_sample * channel2_factor + channel2_offset) *
+		    @LOC("OUT") float sample2 = (channel2_sample * channel2_factor + channel2_offset) *
 					  channel2_scalefactor;
 		    if (channels == OutputChannels.BOTH_CHANNELS)
 			   filter2.input_sample (sample2, subbandnumber);
diff --git a/Robust/src/Tests/ssJava/mp3decoder/LayerIIDecoder.java b/Robust/src/Tests/ssJava/mp3decoder/LayerIIDecoder.java
index 0872aaa0..fe2b0060 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/LayerIIDecoder.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/LayerIIDecoder.java
@@ -31,7 +31,9 @@
 /**
  * Implements decoding of MPEG Audio Layer II frames. 
  */
-class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
+@LATTICE("L<SH,SH<H,SH*")
+@METHODDEFAULT("OUT<V,V<SH,SH<IN,SH*,THISLOC=V,GLOBALLOC=IN")
+class LayerIIDecoder extends LayerIDecoder //implements FrameDecoder  //compiler cannot do interfaces
 {
 
 	public LayerIIDecoder()
@@ -41,7 +43,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	
 	protected void createSubbands()
 	{		
-  		int i;
+	        @LOC("V,LayerIIDecoder.SH") int i;
 		if (mode == Header.SINGLE_CHANNEL)
   		  for (i = 0; i < num_subbands; ++i)
   		    subbands[i] = new SubbandLayer2(i);
@@ -62,7 +64,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	
 	protected void readScaleFactorSelection()
 	{
-  		for (int i = 0; i < num_subbands; ++i)
+	      for (@LOC("V,layerIIDecoder.SH") int i = 0; i < num_subbands; ++i)
   		  ((SubbandLayer2)subbands[i]).read_scalefactor_selection(stream, crc);		
 	}
 	
@@ -71,11 +73,13 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	 /**
 	  * Class for layer II subbands in single channel mode.
 	  */
+        @LATTICE("L<H,L<ARR,ARR<F,SN<F,GN<F,F<H,SN*,GN*")
+	@METHODDEFAULT("OUT<V,V<SH,SH<THIS,THIS<IN,SH*,THISLOC=THIS,GLOBALLOC=IN")
 	static class SubbandLayer2 extends Subband
 	{
 	  // this table contains 3 requantized samples for each legal codeword
 	  // when grouped in 5 bits, i.e. 3 quantizationsteps per sample
-	public static final float grouping_5bits[] = new float[]
+	@LOC("H") public static final float grouping_5bits[] = new float[]
 	{
 	  -2.0f/3.0f, -2.0f/3.0f, -2.0f/3.0f,
 			 0.0f, -2.0f/3.0f, -2.0f/3.0f,
@@ -108,7 +112,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 
 	// this table contains 3 requantized samples for each legal codeword
 	// when grouped in 7 bits, i.e. 5 quantizationsteps per sample
-	public static final float grouping_7bits[] = new float[]
+	@LOC("H") public static final float grouping_7bits[] = new float[]
 	{
 	  -0.8f, -0.8f, -0.8f,   -0.4f, -0.8f, -0.8f,    0.0f, -0.8f, -0.8f,    0.4f, -0.8f, -0.8f,    0.8f, -0.8f, -0.8f,
 	  -0.8f, -0.4f, -0.8f,   -0.4f, -0.4f, -0.8f,    0.0f, -0.4f, -0.8f,    0.4f, -0.4f, -0.8f,    0.8f, -0.4f, -0.8f,
@@ -139,7 +143,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 
 	// this table contains 3 requantized samples for each legal codeword
 	// when grouped in 10 bits, i.e. 9 quantizationsteps per sample
-	public static final float grouping_10bits[] =
+	@LOC("H") public static final float grouping_10bits[] =
 	{
 	  -8.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,
 	  -2.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,        0.0f, -8.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,
@@ -389,28 +393,28 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	// data taken from ISO/IEC DIS 11172, Annexes 3-B.2[abcd] and 3-B.4:
 
 	// subbands 0-2 in tables 3-B.2a and 2b: (index is allocation)
-	public static final int table_ab1_codelength[] =
+	@LOC("F") public static final int table_ab1_codelength[] =
 	  // bits per codeword
 	{ 0, 5, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
 
-	public static final float table_ab1_groupingtables[][] =
+	@LOC("F") public static final float table_ab1_groupingtables[][] =
 	  // pointer to sample grouping table, or NULL-pointer if ungrouped
 	{ null, grouping_5bits, null, null, null, null, null, null, null, null, null, null, null, null, null, null };
 
-	public static final float table_ab1_factor[] =
+	@LOC("F") public static final float table_ab1_factor[] =
 	  // factor for requantization: (real)sample * factor - 1.0 gives requantized sample
 	{ 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/16.0f, 1.0f/32.0f, 1.0f/64.0f,
 	  1.0f/128.0f, 1.0f/256.0f, 1.0f/512.0f, 1.0f/1024.0f, 1.0f/2048.0f,
 	  1.0f/4096.0f, 1.0f/8192.0f, 1.0f/16384.0f, 1.0f/32768.0f };
 
-	public static final float table_ab1_c[] =
+	@LOC("F") public static final float table_ab1_c[] =
 	  // factor c for requantization from table 3-B.4
 	{ 0.0f,           1.33333333333f, 1.14285714286f, 1.06666666666f, 1.03225806452f,
 	  1.01587301587f, 1.00787401575f, 1.00392156863f, 1.00195694716f, 1.00097751711f,
 	  1.00048851979f, 1.00024420024f, 1.00012208522f, 1.00006103888f, 1.00003051851f,
 	  1.00001525902f };
 
-	public static final float table_ab1_d[] =
+	@LOC("F") public static final float table_ab1_d[] =
 	  // addend d for requantization from table 3-B.4
 	{ 0.0f,           0.50000000000f, 0.25000000000f, 0.12500000000f, 0.06250000000f,
 	  0.03125000000f, 0.01562500000f, 0.00781250000f, 0.00390625000f, 0.00195312500f,
@@ -418,59 +422,59 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  0.00003051758f };
 
 	// subbands 3-... tables 3-B.2a and 2b:
-	public static final float[] table_ab234_groupingtables[] =
+	@LOC("F") public static final float[] table_ab234_groupingtables[] =
 	{ null, grouping_5bits, grouping_7bits, null, grouping_10bits, null, null, null, null, null, null, null, null, null, null, null };
 
 	// subbands 3-10 in tables 3-B.2a and 2b:
-	public static final int table_ab2_codelength[] =
+	@LOC("F") public static final int table_ab2_codelength[] =
 	{ 0, 5, 7, 3, 10, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16 };
-	public static final float table_ab2_factor[] =
+	@LOC("F") public static final float table_ab2_factor[] =
 	{ 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/8.0f, 1.0f/16.0f,
 	  1.0f/32.0f, 1.0f/64.0f, 1.0f/128.0f, 1.0f/256.0f, 1.0f/512.0f,
 	  1.0f/1024.0f, 1.0f/2048.0f, 1.0f/4096.0f, 1.0f/32768.0f };
-	public static final float table_ab2_c[] =
+	@LOC("F") public static final float table_ab2_c[] =
 	{ 0.0f,           1.33333333333f, 1.60000000000f, 1.14285714286f, 1.77777777777f,
 	  1.06666666666f, 1.03225806452f, 1.01587301587f, 1.00787401575f, 1.00392156863f,
 	  1.00195694716f, 1.00097751711f, 1.00048851979f, 1.00024420024f, 1.00012208522f,
 	  1.00001525902f };
-	public static final float table_ab2_d[] =
+	@LOC("F") public static final float table_ab2_d[] =
 	{ 0.0f,           0.50000000000f, 0.50000000000f, 0.25000000000f, 0.50000000000f,
 	  0.12500000000f, 0.06250000000f, 0.03125000000f, 0.01562500000f, 0.00781250000f,
 	  0.00390625000f, 0.00195312500f, 0.00097656250f, 0.00048828125f, 0.00024414063f,
 	  0.00003051758f };
 
 	// subbands 11-22 in tables 3-B.2a and 2b:
-	public static final int table_ab3_codelength[] = { 0, 5, 7, 3, 10, 4, 5, 16 };
-	public static final float table_ab3_factor[] =
+	@LOC("F") public static final int table_ab3_codelength[] = { 0, 5, 7, 3, 10, 4, 5, 16 };
+	@LOC("F") public static final float table_ab3_factor[] =
 	{ 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/8.0f, 1.0f/16.0f, 1.0f/32768.0f };
-	public static final float table_ab3_c[] =
+	@LOC("F") public static final float table_ab3_c[] =
 	{ 0.0f,           1.33333333333f, 1.60000000000f, 1.14285714286f, 1.77777777777f,
 	  1.06666666666f, 1.03225806452f, 1.00001525902f };
-	public static final float table_ab3_d[] =
+	@LOC("F") public static final float table_ab3_d[] =
 	{ 0.0f,           0.50000000000f, 0.50000000000f, 0.25000000000f, 0.50000000000f,
 	  0.12500000000f, 0.06250000000f, 0.00003051758f };
 
 	// subbands 23-... in tables 3-B.2a and 2b:
-	public static final int table_ab4_codelength[] = { 0, 5, 7, 16 };
-	public static final float table_ab4_factor[] = { 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/32768.0f };
-	public static final float table_ab4_c[] = { 0.0f, 1.33333333333f, 1.60000000000f, 1.00001525902f };
-	public static final float table_ab4_d[] = { 0.0f, 0.50000000000f, 0.50000000000f, 0.00003051758f };
+	@LOC("F") public static final int table_ab4_codelength[] = { 0, 5, 7, 16 };
+        @LOC("F") public static final float table_ab4_factor[] = { 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/32768.0f };
+	@LOC("F") public static final float table_ab4_c[] = { 0.0f, 1.33333333333f, 1.60000000000f, 1.00001525902f };
+	@LOC("F") public static final float table_ab4_d[] = { 0.0f, 0.50000000000f, 0.50000000000f, 0.00003051758f };
 
 	// subbands in tables 3-B.2c and 2d:
-	public static final int table_cd_codelength[] =
+	@LOC("F") public static final int table_cd_codelength[] =
 	{ 0, 5, 7, 10, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
-	public static final float table_cd_groupingtables[][] =
+	@LOC("F") public static final float table_cd_groupingtables[][] =
 	{ null, grouping_5bits, grouping_7bits, grouping_10bits, null, null, null, null, null, null, null, null, null, null, null, null };
-	public static final float table_cd_factor[] =
+	@LOC("F") public static final float table_cd_factor[] =
 	{ 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/8.0f, 1.0f/16.0f, 1.0f/32.0f, 1.0f/64.0f,
 	  1.0f/128.0f, 1.0f/256.0f, 1.0f/512.0f, 1.0f/1024.0f, 1.0f/2048.0f, 1.0f/4096.0f,
 	  1.0f/8192.0f, 1.0f/16384.0f };
-	public static final float table_cd_c[] =
+	@LOC("F") public static final float table_cd_c[] =
 	{ 0.0f,           1.33333333333f, 1.60000000000f, 1.77777777777f, 1.06666666666f,
 	  1.03225806452f, 1.01587301587f, 1.00787401575f, 1.00392156863f, 1.00195694716f,
 	  1.00097751711f, 1.00048851979f, 1.00024420024f, 1.00012208522f, 1.00006103888f,
 	  1.00003051851f };
-	public static final float table_cd_d[] =
+	@LOC("F") public static final float table_cd_d[] =
 	{ 0.0f,           0.50000000000f, 0.50000000000f, 0.50000000000f, 0.12500000000f,
 	  0.06250000000f, 0.03125000000f, 0.01562500000f, 0.00781250000f, 0.00390625000f,
 	  0.00195312500f, 0.00097656250f, 0.00048828125f, 0.00024414063f, 0.00012207031f,
@@ -478,23 +482,25 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 
 
 
-	  protected int 		    subbandnumber;
-	  protected int				allocation;
-	  protected int				scfsi;
-	  protected float			scalefactor1, scalefactor2, scalefactor3;
-	  protected int[] 			codelength = {0}; 
-	  protected float groupingtable[][] = new float[2][]; 
+	  @LOC("F") protected int 		        subbandnumber;
+	  @LOC("F") protected int				allocation;
+	  @LOC("ARR") protected int				scfsi;
+	  @LOC("L") protected float			scalefactor1;
+	  @LOC("L") protected float                     scalefactor2;
+	  @LOC("L") protected float                     scalefactor3;
+	  @LOC("ARR") protected int[] 			codelength = {0}; 
+	  @LOC("ARR") protected float                       groupingtable[][] = new float[2][]; 
 	  //protected float[][] 		groupingtable = {{0},{0}} ;
-	  protected float[]			factor = {0.0f};
-	  protected int				groupnumber;
-	  protected int 			samplenumber;
-	  protected float[]			samples = new float[3];
-	  protected float[]			c = {0};
-	  protected float[]		    d = {0};
+	  @LOC("ARR") protected float[]			factor = {0.0f};
+	  @LOC("GN") protected int				groupnumber;
+	  @LOC("SN") protected int 			samplenumber;
+	  @LOC("L") protected float[]			samples = new float[3];
+	  @LOC("ARR") protected float[]			c = {0};
+	  @LOC("ARR") protected float[]		        d = {0};
 	  /**
 	   * Constructor
 	   */
-	  public SubbandLayer2(int subbandnumber)
+	  public SubbandLayer2(@LOC("IN") int subbandnumber)
 	  {	
 		this.subbandnumber = subbandnumber;
 	    groupnumber = samplenumber = 0;  
@@ -504,11 +510,12 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  protected int get_allocationlength (Header header)
+	  @RETURNLOC("OUT") 
+	  protected int get_allocationlength (@LOC("IN") Header header)
 	  {
 	 	if (header.version() == Header.MPEG1)
 		{
-		  int channel_bitrate = header.bitrate_index();
+		  @LOC("SH") int channel_bitrate = header.bitrate_index();
 
 		  // calculate bitrate per channel:
 		  if (header.mode() != Header.SINGLE_CHANNEL)
@@ -548,13 +555,13 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	   protected void prepare_sample_reading(Header header, int allocation,
-											 //float[][] groupingtable,
-											   int channel,
-	                                         float[] factor, int[] codelength,
-	                                         float[] c, float[] d)
+	    protected void prepare_sample_reading(@LOC("IN") Header header, @LOC("IN") int allocation,
+						  //float[][] groupingtable,
+						  @LOC("IN") int channel,
+						  @LOC("V") float[] factor, @LOC("V") int[] codelength,
+						  @LOC("V") float[] c, @LOC("V") float[] d)
 	   {
-	 	 	int channel_bitrate = header.bitrate_index();
+	                @LOC("SH")int channel_bitrate = header.bitrate_index();
 	  		// calculate bitrate per channel:
 		  	if (header.mode() != Header.SINGLE_CHANNEL)
 		 		if (channel_bitrate == 4)
@@ -614,9 +621,10 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_allocation(Bitstream stream, Header header, Crc16 crc)
+          @LATTICE("OUT<V,V<SH,SH<IN,SH*,THISLOC=OUT,GLOBALLOC=IN")
+	  public void read_allocation(@LOC("IN") Bitstream stream, @LOC("IN") Header header, @LOC("IN") Crc16 crc)
 	  {
-		 int length = get_allocationlength(header);
+	         @LOC("V") int length = get_allocationlength(header);
 		 allocation = stream.get_bits(length);
 		 if (crc != null) 
 			 crc.add_bits(allocation, length);  
@@ -625,7 +633,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_scalefactor_selection (Bitstream stream, Crc16 crc)
+	  public void read_scalefactor_selection (@LOC("IN") Bitstream stream, @LOC("IN") Crc16 crc)
 	  {
 	 	if (allocation != 0)
 	 	{
@@ -637,13 +645,13 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_scalefactor (Bitstream stream, Header header)
+	  public void read_scalefactor (@LOC("IN") Bitstream stream, @LOC("IN") Header header)
 	  {
 	 	if (allocation != 0)
 	 	{
 	 	   switch (scfsi)
-	       {
-	      	case 0:
+	           {
+	      	   case 0:
 	  	  	 scalefactor1 = scalefactors[stream.get_bits(6)];
 		  	 scalefactor2 = scalefactors[stream.get_bits(6)];
 		  	 scalefactor3 = scalefactors[stream.get_bits(6)];
@@ -652,13 +660,13 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 		  	 scalefactor1 = scalefactor2 = scalefactors[stream.get_bits(6)];
 		  	 scalefactor3 = scalefactors[stream.get_bits(6)];
 		  	 break;
-	        case 2:
+	           case 2:
 		  	 scalefactor1 = scalefactor2 = scalefactor3 = scalefactors[stream.get_bits(6)];
 			 break;
-		    case 3:
+		   case 3:
 		  	 scalefactor1 = scalefactors[stream.get_bits(6)];
-		     scalefactor2 = scalefactor3 = scalefactors[stream.get_bits(6)];
-		     break;
+		         scalefactor2 = scalefactor3 = scalefactors[stream.get_bits(6)];
+		         break;
 	    	}
 	    	prepare_sample_reading(header, allocation, 0,
 				    factor, codelength, c, d);
@@ -668,16 +676,18 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean read_sampledata (Bitstream stream)
+          @LATTICE("OUT<V,V<SH,SH<TEMP,TEMP<TMP,TMP<THIS,THIS<IN,SH*,TEMP*,TMP*,THISLOC=THIS,GLOBALLOC=IN")
+	  @RETURNLOC("V")
+	  public boolean read_sampledata (@LOC("IN") Bitstream stream)
 	  {
 	  	if (allocation != 0)
 		 if (groupingtable[0] != null)
 		 {
-			int samplecode = stream.get_bits(codelength[0]);
+		        @LOC("SH") int samplecode = stream.get_bits(codelength[0]);
 			// create requantized samples:
 			samplecode += samplecode << 1;
-			float[] target = samples;
-			float[] source = groupingtable[0];
+			//float[] target = samples;  //subbed in variable to reduce areas
+			//float[] source = groupingtable[0];  //subbed in variable to reduce areas
 		  /*
 		  int tmp = 0;
 			int temp = 0;
@@ -688,16 +698,16 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 			target[tmp] = source[samplecode + temp];
 			*/
 			//Bugfix:
-			int tmp = 0;
-			int temp = samplecode;
+			@LOC("TMP") int tmp = 0;
+			@LOC("TEMP") int temp = samplecode;
 			
 			if(temp > source.length - 3) temp = source.length - 3;
 			
-			target[tmp] = source[temp];
+			samples[tmp] = groupingtable[0][temp];
 			temp++;tmp++;
-			target[tmp] = source[temp];
+			samples[tmp] = groupingtable[0][temp];
 			temp++;tmp++;
-			target[tmp] = source[temp];
+			samples[tmp] = groupingtable[0][temp];
 			
 			// memcpy (samples, groupingtable + samplecode, 3 * sizeof (real));
 		 }
@@ -718,11 +728,11 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+	  public boolean put_next_sample(@LOC("IN") int channels, @LOC("IN") SynthesisFilter filter1, @LOC("IN") SynthesisFilter filter2)
 	  {
 	    if ((allocation != 0) && (channels != OutputChannels.RIGHT_CHANNEL))
 	    {
-	  	 float sample = samples[samplenumber];
+		 @LOC("SH") float sample = samples[samplenumber];
 	  
 	  	 if (groupingtable[0] == null)
 	  		sample = (sample + d[0]) * c[0];
@@ -745,15 +755,19 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	 /**
 	  * Class for layer II subbands in joint stereo mode.
 	  */
+        @LATTICE("L<H,L<ARR,ARR<F,SN<F,GN<F,F<H,SN*,GN*")
+	@METHODDEFAULT("OUT<V,V<SH,SH<THIS,THIS<IN,SH*,THISLOC=THIS,GLOBALLOC=IN")
 	static class SubbandLayer2IntensityStereo extends SubbandLayer2
 	{
-	  protected int		 channel2_scfsi;
-	  protected float 	 channel2_scalefactor1, channel2_scalefactor2, channel2_scalefactor3;
+	  @LOC("ARR") protected int		 channel2_scfsi;
+	  @LOC("L") protected float 	 channel2_scalefactor1; 
+	  @LOC("L") protected float        channel2_scalefactor2;
+	  @LOC("L") protected float        channel2_scalefactor3;
 
 	  /**
 	   * Constructor
 	   */
-	  public SubbandLayer2IntensityStereo (int subbandnumber)
+	  public SubbandLayer2IntensityStereo (@LOC("IN") int subbandnumber)
 	  {
 	 	super(subbandnumber);
 	  }
@@ -761,7 +775,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_allocation(Bitstream stream, Header header, Crc16 crc)
+	  public void read_allocation(@LOC("IN") Bitstream stream, @LOC("IN") Header header, @LOC("IN") Crc16 crc)
 	  {
 	    super.read_allocation (stream, header, crc);
 	  }
@@ -769,7 +783,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_scalefactor_selection(Bitstream stream, Crc16 crc)
+	  public void read_scalefactor_selection(@LOC("IN") Bitstream stream, @LOC("IN") Crc16 crc)
 	  {
 	    if (allocation != 0)
 	    {
@@ -786,7 +800,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_scalefactor(Bitstream stream, Header header)
+	    public void read_scalefactor(@LOC("IN") Bitstream stream, @LOC("IN") Header header)
 	  {
 	    if (allocation != 0)
 	    {
@@ -821,7 +835,8 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean read_sampledata(Bitstream stream)
+	  @RETURNLOC("V")
+	  public boolean read_sampledata(@LOC("IN") Bitstream stream)
 	  {
 		 return super.read_sampledata (stream);
 	  }
@@ -829,17 +844,19 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+          @LATTICE("S2<S1,S1<THIS,THIS<GLOBAL,S1*,THISLOC=THIS,GLOBALLOC=GLOBAL")
+	  @RETURNLOC("S2")
+	  public boolean put_next_sample(@LOC("IN") int channels, @LOC("IN") SynthesisFilter filter1, @LOC("IN") SynthesisFilter filter2)
 	  {
 		  if (allocation != 0)
 		  {
-			 float sample = samples[samplenumber];
+		        @LOC("S1") float sample = samples[samplenumber];
 		
 			 if (groupingtable[0] == null)
 				sample = (sample + d[0]) * c[0];
 		       if (channels == OutputChannels.BOTH_CHANNELS)
 			   {
-				  float sample2 = sample;
+			      @LOC("S2") float sample2 = sample;
 			      if (groupnumber <= 4)
 			      {
 					sample *= scalefactor1;
@@ -890,23 +907,27 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	 /**
 	  * Class for layer II subbands in stereo mode.
 	  */
+        @LATTICE("L<H,L<ARR,ARR<F,SN<F,GN<F,F<H,SN*,GN*")
+	@METHODDEFAULT("OUT<V,V<SH,SH<THIS,THIS<IN,SH*,THISLOC=THIS,GLOBALLOC=IN")
 	static class SubbandLayer2Stereo extends SubbandLayer2
 	{
-	  protected int			channel2_allocation;
-	  protected int 		channel2_scfsi;
-	  protected float	 	channel2_scalefactor1, channel2_scalefactor2, channel2_scalefactor3;
+	  @LOC("F")protected int			channel2_allocation;
+	  @LOC("ARR") protected int 		channel2_scfsi;
+	  @LOC("L") protected float	 	channel2_scalefactor1;
+	  @LOC("L") protected float channel2_scalefactor2;
+	  @LOC("L") protected float channel2_scalefactor3;
 	  //protected boolean	 	channel2_grouping;  ???? Never used!
-	  protected int[] 		channel2_codelength = {0};
+	  @LOC("ARR") protected int[] 		channel2_codelength = {0};
 	  //protected float[][] 	channel2_groupingtable = {{0},{0}};
-	  protected float[]	 	channel2_factor = {0};
-	  protected float[] 	channel2_samples;
-	  protected float[]	 	channel2_c = {0};
-	  protected float[]		channel2_d = {0};
+	  @LOC("ARR") protected float[]	 	channel2_factor = {0};
+	  @LOC("L") protected float[] 	channel2_samples;
+	  @LOC("ARR") protected float[]	 	channel2_c = {0};
+	  @LOC("ARR") protected float[]		channel2_d = {0};
 	  
 	  /**
 	   * Constructor
 	   */
-	  public SubbandLayer2Stereo(int subbandnumber)
+	  public SubbandLayer2Stereo(@LOC("IN") int subbandnumber)
 	  {
 	 	super(subbandnumber);
 		channel2_samples = new float[3];
@@ -915,9 +936,10 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_allocation (Bitstream stream, Header header, Crc16 crc)
+          @LATTICE("OUT<SH,SH<THIS,THIS<V,V<IN,SH*,THISLOC=THIS,GLOBALLOC=IN")
+	  public void read_allocation(@LOC("IN") Bitstream stream, @LOC("IN") Header header, @LOC("IN") Crc16 crc)
 	  {
-	    int length = get_allocationlength(header);
+	    @LOC("V") int length = get_allocationlength(header);
 	    allocation = stream.get_bits(length);
 	    channel2_allocation = stream.get_bits(length);
 	    if (crc != null)
@@ -930,7 +952,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_scalefactor_selection(Bitstream stream, Crc16 crc)
+	  public void read_scalefactor_selection(@LOC("IN") Bitstream stream, @LOC("IN") Crc16 crc)
 	  {
 		  if (allocation != 0)
 		  {
@@ -949,7 +971,7 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public void read_scalefactor(Bitstream stream, Header header)
+	    public void read_scalefactor(@LOC("IN") Bitstream stream, @LOC("IN") Header header)
 	  {
 	    super.read_scalefactor(stream, header);
 	    if (channel2_allocation != 0)
@@ -988,14 +1010,16 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean read_sampledata (Bitstream stream)
+          @LATTICE("OUT<V,V<SH,SH<TEMP,TEMP<TMP,TMP<THIS,THIS<IN,SH*,TEMP*,TMP*,THISLOC=THIS,GLOBALLOC=IN")
+	  @RETURNLOC("V")
+	  public boolean read_sampledata (@LOC("IN") Bitstream stream)
 	  {
-	    boolean returnvalue = super.read_sampledata(stream);
+	    @LOC("V")boolean returnvalue = super.read_sampledata(stream);
 	  
 	    if (channel2_allocation != 0)
 	  	 if (groupingtable[1] != null)
 		 {
-	  		int samplecode = stream.get_bits(channel2_codelength[0]);
+		        @LOC("SH") int samplecode = stream.get_bits(channel2_codelength[0]);
 	  		// create requantized samples:
 	  		samplecode += samplecode << 1;
 	  	/*
@@ -1010,10 +1034,10 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  		target[tmp] = source[samplecode + temp];
 	  		// memcpy (channel2_samples, channel2_groupingtable + samplecode, 3 * sizeof (real));
 	  	*/
-	  	float[] target = channel2_samples;
-	    float[] source = groupingtable[1];
-			int tmp = 0;
-			int temp = samplecode;
+			@LOC("V") float[] target = channel2_samples;
+			@LOC("V") float[] source = groupingtable[1];
+			@LOC("TMP") int tmp = 0;
+			@LOC("TEMP") int temp = samplecode;
 	  	target[tmp] = source[temp];
 			temp++;tmp++;
 	  	target[tmp] = source[temp];
@@ -1036,12 +1060,13 @@ class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
 	  /**
 	   *
 	   */
-	  public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+	  @RETURNLOC("V")
+	  public boolean put_next_sample(@LOC("IN") int channels, @LOC("IN") SynthesisFilter filter1, @LOC("IN") SynthesisFilter filter2)
 	  {
-	    boolean returnvalue = super.put_next_sample(channels, filter1, filter2);
+	    @LOC("V") boolean returnvalue = super.put_next_sample(channels, filter1, filter2);
 	    if ((channel2_allocation != 0) && (channels != OutputChannels.LEFT_CHANNEL))
 	    {
-	  	 float sample = channel2_samples[samplenumber - 1];
+		@LOC("SH") float sample = channel2_samples[samplenumber - 1];
 	  
 	  	 if (groupingtable[1] == null)
 	  		sample = (sample + channel2_d[0]) * channel2_c[0];
diff --git a/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java b/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java
index 056d744c..3a0e36c8 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java
@@ -38,40 +38,51 @@
  * 
  * @since 0.0
  */
+@LATTICE("FS<BR,BR<SF,LR<IR,IR<IP,IP<SF,LR<K,K<F,LR<VAR,LR<RO,RO<F,VAR<F,VAR<RAW,CSH<F,SAM<O,O<F,
+SF<SI,SI<CH,SFREQ<H,MAX<H,H<CH,FLCH<CH,FLCH<WCH,SF<SFT,SFT<NS,NS<C,TS<RAW,O<TS,LY<F,
+C*,FS*,SI*,IP*,IR*,LR*,K*,O*,TS*,
+TS<BT,BT<GR,GR<SI,
+LR<S,S<ME,ME<CH,K<SH,K<LSF,LSF<H,LSF<CH,IP<SH,SH<J,J<S,S<ME,SH<SFREQ,SH<RO,IP<TMP2,LSF<H,TMP2<F,J*,SH*,
+O<RO2,RO2<RO3,RO3<RO4,RO4<RO5,O<RO1,RO1<RO5,RO5<RO6,RO6<RO7,RO7<RO8,RO8<RO9,RO9<SFREQ,RO9<F,RO1*,RO4*,RO5*,RO6*,RO9*")
+//4th: added for hybrid.
+//5th added for stereo
+//6th added for reorder method
+
+@METHODDEFAULT("OUT<V,V<THIS,THIS<SH,SH<IN,SH*,THISLOC=THIS,GLOBALLOC=IN")
 final class LayerIIIDecoder implements FrameDecoder {
-  final double d43 = (4.0 / 3.0);
-
-  public int[] scalefac_buffer;
+  @LOC("F") final double d43 = (4.0 / 3.0);
+  @LOC("SFT") public int[] scalefac_buffer;
 
   // MDM: removed, as this wasn't being used.
   // private float CheckSumOut1d = 0.0f;
-  private int CheckSumHuff = 0;
-  private int[] is_1d;
-  private float[][][] ro;
-  private float[][][] lr;
-  private float[] out_1d; // 576 samples
-  private float[][] prevblck;
-  private float[][] k;
-  private int[] nonzero;
-  private Bitstream stream;
-  private Header header;
-  private SynthesisFilter filter1, filter2;
-  private Obuffer buffer; // output buffer
-  private int which_channels;
-  private BitReserve br;
-  private III_side_info_t si;
-
-  private temporaire2[] III_scalefac_t;
-  private temporaire2[] scalefac;
+  @LOC("CSH") private int CheckSumHuff = 0;
+  @LOC("VAR") private int[] is_1d;
+  @LOC("VAR") private float[][][] ro;
+  @LOC("LR") private float[][][] lr;
+  @LOC("O") private float[] out_1d; // 576 samples
+  @LOC("VAR") private float[][] prevblck;
+  @LOC("K") private float[][] k;
+  @LOC("F") private int[] nonzero;
+  @LOC("F")private Bitstream stream;
+  @LOC("H") private Header header;
+  @LOC("F") private SynthesisFilter filter1;
+  @LOC("F") private SynthesisFilter filter2;
+  @LOC("F") private Obuffer buffer; // output buffer
+  @LOC("WC") private int which_channels;
+  @LOC("BR") private BitReserve br;
+  @LOC("SI") private III_side_info_t si;
+
+  @LOC("SBT") private temporaire2[] III_scalefac_t;
+  @LOC("SF") private temporaire2[] scalefac;
   // private III_scalefac_t scalefac;
 
-  private int max_gr;
-  private int frame_start;
-  private int part2_start;
-  private int channels;
-  private int first_channel;
-  private int last_channel;
-  private int sfreq;
+  @LOC("MAX") private int max_gr;
+  @LOC("FS") private int frame_start;
+  @LOC("F") private int part2_start;
+  @LOC("CH") private int channels;
+  @LOC("FLCH") private int first_channel;
+  @LOC("FLCH") private int last_channel;
+  @LOC("SFREQ") private int sfreq;
 
   /**
    * Constructor.
@@ -233,8 +244,8 @@ final class LayerIIIDecoder implements FrameDecoder {
 
   // subband samples are buffered and passed to the
   // SynthesisFilter in one go.
-  private float[] samples1 = new float[32];
-  private float[] samples2 = new float[32];
+  @LOC("SAM") private float[] samples1 = new float[32];
+  @LOC("SAM") private float[] samples2 = new float[32];
 
   /* location hierarchy of decode()
 {header} {stream} {si}
@@ -614,7 +625,7 @@ final class LayerIIIDecoder implements FrameDecoder {
 	 */
   // MDM: new_slen is fully initialized before use, no need
   // to reallocate array.
-  private final int[] new_slen = new int[4];
+  @LOC("NS") private final int[] new_slen = new int[4];
 
   private void get_LSF_scale_data(int ch, int gr) {
 
@@ -762,10 +773,10 @@ final class LayerIIIDecoder implements FrameDecoder {
   /**
 	 *
 	 */
-  int[] x = { 0 };
-  int[] y = { 0 };
-  int[] v = { 0 };
-  int[] w = { 0 };
+  @LOC("LY") int[] x = { 0 };
+  @LOC("F") int[] y = { 0 };
+  @LOC("LY") int[] v = { 0 };
+  @LOC("LY") int[] w = { 0 };
 
   private void huffman_decode(int ch, int gr) {
     x[0] = 0;
@@ -779,7 +790,8 @@ final class LayerIIIDecoder implements FrameDecoder {
     int region2Start;
     int index;
 
-    int buf, buf1;
+    int buf;
+    int buf1;
 
     huffcodetab h;
 
@@ -873,7 +885,7 @@ final class LayerIIIDecoder implements FrameDecoder {
   /**
 	 *
 	 */
-  private void i_stereo_k_values(int is_pos, int io_type, int i) {
+  private void i_stereo_k_values(@LOC("IN") int is_pos, @LOC("IN") int io_type, @LOC("IN") int i) {
     if (is_pos == 0) {
       k[0][i] = 1.0f;
       k[1][i] = 1.0f;
@@ -889,15 +901,18 @@ final class LayerIIIDecoder implements FrameDecoder {
   /**
 	 *
 	 */
-  private void dequantize_sample(float xr[][], int ch, int gr) {
-    gr_info_s gr_info = (si.ch[ch].gr[gr]);
-    int cb = 0;
-    int next_cb_boundary;
-    int cb_begin = 0;
-    int cb_width = 0;
-    int index = 0, t_index, j;
-    float g_gain;
-    float[][] xr_1d = xr;
+  @LATTICE("OUT<QUO,QUO<REST,REST<IDX,IDX<VAR,VAR<CB,CB<J,CB<GR,GR<IN,J<IN,QUO*,REST*,IDX*,CB*,J*,THISLOC=IN,GLOBALLOC=IN")
+  private void dequantize_sample(@LOC("OUT") float xr[][], @LOC("IN") int ch, @LOC("IN") int gr) {
+    @LOC("GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);
+    @LOC("CB") int cb = 0;
+    @LOC("CB") int next_cb_boundary;
+    @LOC("CB") int cb_begin = 0;
+    @LOC("CB") int cb_width = 0;
+    @LOC("IN") int index = 0;
+    @LOC("VAR") int t_index;
+    @LOC("J") int j;
+    @LOC("VAR") float g_gain;
+    //float[][] xr_1d = xr;//substituted xr for instances of xr_1d to decrease number of areas
 
     // choose correct scalefactor band per block type, initalize boundary
 
@@ -919,27 +934,27 @@ final class LayerIIIDecoder implements FrameDecoder {
 
     for (j = 0; j < nonzero[ch]; j++) {
       // Modif E.B 02/22/99
-      int reste = j % SSLIMIT;
-      int quotien = (int) ((j - reste) / SSLIMIT);
+      @LOC("REST") int reste = j % SSLIMIT;
+      @LOC("QUO") int quotien = (int) ((j - reste) / SSLIMIT);
       if (is_1d[j] == 0)
-        xr_1d[quotien][reste] = 0.0f;
+        xr[quotien][reste] = 0.0f;
       else {
-        int abv = is_1d[j];
+	@LOC("VAR") int abv = is_1d[j];
         // Pow Array fix (11/17/04)
         if (abv < t_43.length) {
           if (is_1d[j] > 0)
-            xr_1d[quotien][reste] = g_gain * t_43[abv];
+            xr[quotien][reste] = g_gain * t_43[abv];
           else {
             if (-abv < t_43.length)
-              xr_1d[quotien][reste] = -g_gain * t_43[-abv];
+              xr[quotien][reste] = -g_gain * t_43[-abv];
             else
-              xr_1d[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);
+              xr[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);
           }
         } else {
           if (is_1d[j] > 0)
-            xr_1d[quotien][reste] = g_gain * (float) Math.pow(abv, d43);
+            xr[quotien][reste] = g_gain * (float) Math.pow(abv, d43);
           else
-            xr_1d[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);
+            xr[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);
         }
       }
     }
@@ -947,8 +962,8 @@ final class LayerIIIDecoder implements FrameDecoder {
     // apply formula per block type
     for (j = 0; j < nonzero[ch]; j++) {
       // Modif E.B 02/22/99
-      int reste = j % SSLIMIT;
-      int quotien = (int) ((j - reste) / SSLIMIT);
+      @LOC("REST") int reste = j % SSLIMIT;
+      @LOC("QUO") int quotien = (int) ((j - reste) / SSLIMIT);
 
       if (index == next_cb_boundary) { /* Adjust critical band boundary */
         if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
@@ -1005,36 +1020,36 @@ final class LayerIIIDecoder implements FrameDecoder {
          * xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info.subblock_gain[t_index]) -(0.5
          * * (1.0 + gr_info.scalefac_scale) scalefac[ch].s[t_index][cb])));
          */
-        int idx = scalefac[ch].s[t_index][cb] << gr_info.scalefac_scale;
+        @LOC("IDX") int idx = scalefac[ch].s[t_index][cb] << gr_info.scalefac_scale;
         idx += (gr_info.subblock_gain[t_index] << 2);
 
-        xr_1d[quotien][reste] *= two_to_negative_half_pow[idx];
+        xr[quotien][reste] *= two_to_negative_half_pow[idx];
 
       } else { // LONG block types 0,1,3 & 1st 2 subbands of switched blocks
         /*
          * xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info.scalefac_scale)
          * (scalefac[ch].l[cb] + gr_info.preflag * pretab[cb]));
          */
-        int idx = scalefac[ch].l[cb];
+	@LOC("IDX") int idx = scalefac[ch].l[cb];
 
         if (gr_info.preflag != 0)
           idx += pretab[cb];
 
         idx = idx << gr_info.scalefac_scale;
-        xr_1d[quotien][reste] *= two_to_negative_half_pow[idx];
+        xr[quotien][reste] *= two_to_negative_half_pow[idx];
       }
       index++;
     }
 
     for (j = nonzero[ch]; j < 576; j++) {
       // Modif E.B 02/22/99
-      int reste = j % SSLIMIT;
-      int quotien = (int) ((j - reste) / SSLIMIT);
+      @LOC("REST") int reste = j % SSLIMIT;
+      @LOC("QUO") int quotien = (int) ((j - reste) / SSLIMIT);
       if (reste < 0)
         reste = 0;
       if (quotien < 0)
         quotien = 0;
-      xr_1d[quotien][reste] = 0.0f;
+      xr[quotien][reste] = 0.0f;
     }
 
     return;
@@ -1043,19 +1058,24 @@ final class LayerIIIDecoder implements FrameDecoder {
   /**
 	 *
 	 */
-  private void reorder(float xr[][], int ch, int gr) {
+  @LATTICE("THIS<I,I<GR,GR<IN,I*,THISLOC=THIS,GLOBALLOC=IN")
+  private void reorder(@LOC("IN") float xr[][], @LOC("IN") int ch, @LOC("IN") int gr) {
     // the purpose of reordering: move 'short samples' back to their original position
     // after reorder, the samples are no long ordered by frequency
     
     // the format of input data to reorder: 
     // three small chunks of 192 samples each are combined to 576 samples ordered by frequency 
     
-    gr_info_s gr_info = (si.ch[ch].gr[gr]);
-    int freq, freq3;
-    int index;
-    int sfb, sfb_start, sfb_lines;
-    int src_line, des_line;
-    float[][] xr_1d = xr;
+    @LOC("GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);
+    @LOC("THIS,LayerIIIDecoder.RO6") int freq;
+    @LOC("THIS,LayerIIIDecoder.RO5") int freq3;
+    @LOC("I") int index;
+    @LOC("THIS,LayerIIIDecoder.RO9") int sfb;
+    @LOC("THIS,LayerIIIDecoder.RO8") int sfb_start;
+    @LOC("THIS,LayerIIIDecoder.RO7") int sfb_lines;
+    @LOC("THIS,LayerIIIDecoder.RO4") int src_line;
+    @LOC("THIS,LayerIIIDecoder.RO1") int des_line;
+    //float[][] xr_1d = xr;  subbed in xr for xr_1d so as not to create extra areas
 
     if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
 
@@ -1066,9 +1086,9 @@ final class LayerIIIDecoder implements FrameDecoder {
         // NO REORDER FOR LOW 2 SUBBANDS
         for (index = 0; index < 36; index++) {
           // Modif E.B 02/22/99
-          int reste = index % SSLIMIT;
-          int quotien = (int) ((index - reste) / SSLIMIT);
-          out_1d[index] = xr_1d[quotien][reste];
+	  @LOC("THIS,LayerIIIDecoder.RO3") int reste = index % SSLIMIT;
+          @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((index - reste) / SSLIMIT);
+          out_1d[index] = xr[quotien][reste];
         }
         // REORDERING FOR REST SWITCHED SHORT
         /*
@@ -1082,48 +1102,48 @@ final class LayerIIIDecoder implements FrameDecoder {
           sfb_start = sfBandIndex[sfreq].s[sfb];
           sfb_lines = sfBandIndex[sfreq].s[sfb + 1] - sfb_start;
 
-          int sfb_start3 = (sfb_start << 2) - sfb_start;
+          @LOC("THIS,LayerIIIDecoder.RO7") int sfb_start3 = (sfb_start << 2) - sfb_start;
 
           for (freq = 0, freq3 = 0; freq < sfb_lines; freq++, freq3 += 3) {
 
             src_line = sfb_start3 + freq;
             des_line = sfb_start3 + freq3;
             // Modif E.B 02/22/99
-            int reste = src_line % SSLIMIT;
-            int quotien = (int) ((src_line - reste) / SSLIMIT);
+            @LOC("THIS,LayerIIIDecoder.RO3") int reste = src_line % SSLIMIT;
+            @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((src_line - reste) / SSLIMIT);
 
-            out_1d[des_line] = xr_1d[quotien][reste];
+            out_1d[des_line] = xr[quotien][reste];
             src_line += sfb_lines;
             des_line++;
 
             reste = src_line % SSLIMIT;
             quotien = (int) ((src_line - reste) / SSLIMIT);
 
-            out_1d[des_line] = xr_1d[quotien][reste];
+            out_1d[des_line] = xr[quotien][reste];
             src_line += sfb_lines;
             des_line++;
 
             reste = src_line % SSLIMIT;
             quotien = (int) ((src_line - reste) / SSLIMIT);
 
-            out_1d[des_line] = xr_1d[quotien][reste];
+            out_1d[des_line] = xr[quotien][reste];
           }
         }
 
       } else { // pure short
         for (index = 0; index < 576; index++) {
-          int j = reorder_table[sfreq][index];
-          int reste = j % SSLIMIT;
-          int quotien = (int) ((j - reste) / SSLIMIT);
-          out_1d[index] = xr_1d[quotien][reste];
+	  @LOC("THIS,LayerIIIDecoder.RO8") int j = reorder_table[sfreq][index];
+          @LOC("THIS,LayerIIIDecoder.RO3") int reste = j % SSLIMIT;
+          @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((j - reste) / SSLIMIT);
+          out_1d[index] = xr[quotien][reste];
         }
       }
     } else { // long blocks
       for (index = 0; index < 576; index++) {
         // Modif E.B 02/22/99
-        int reste = index % SSLIMIT;
-        int quotien = (int) ((index - reste) / SSLIMIT);
-        out_1d[index] = xr_1d[quotien][reste];
+	@LOC("THIS,LayerIIIDecoder.RO3") int reste = index % SSLIMIT;
+        @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((index - reste) / SSLIMIT);
+        out_1d[index] = xr[quotien][reste];
       }
     }
   }
@@ -1132,11 +1152,13 @@ final class LayerIIIDecoder implements FrameDecoder {
 	 *
 	 */
 
-  int[] is_pos = new int[576];
-  float[] is_ratio = new float[576];
+  @LOC("IP") int[] is_pos = new int[576];
+  @LOC("IR") float[] is_ratio = new float[576];
 
-  private void stereo(int gr) {
-    int sb, ss;
+  @LATTICE("IO<THIS,THIS<IN,THISLOC=THIS,GLOBALLOC=IN") 
+  private void stereo(@LOC("IN") int gr) {
+    @LOC("SH") int sb;
+    @LOC("SH") int ss;
 
     if (channels == 1) { // mono , bypass xr[0][][] to lr[0][][]
 
@@ -1149,18 +1171,20 @@ final class LayerIIIDecoder implements FrameDecoder {
 
     } else {
 
-      gr_info_s gr_info = (si.ch[0].gr[gr]);
-      int mode_ext = header.mode_extension();
-      int sfb;
-      int i;
-      int lines, temp, temp2;
-
-      boolean ms_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x2) != 0));
-      boolean i_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x1) != 0));
-      boolean lsf =
+      @LOC("THIS,LayerIIIDecoder.ME") gr_info_s gr_info = (si.ch[0].gr[gr]);
+      @LOC("THIS,LayerIIIDecoder.ME") int mode_ext = header.mode_extension();
+      @LOC("THIS,LayerIIIDecoder.SH") int sfb;
+      @LOC("THIS,LayerIIIDecoder.SH") int i;
+      @LOC("THIS,LayerIIIDecoder.SH") int line;
+      @LOC("THIS,LayerIIIDecoder.SH") int temp;
+      @LOC("THIS,LayerIIIDecoder.TMP2") int temp2;
+
+      @LOC("THIS,LayerIIIDecoder.S") boolean ms_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x2) != 0));
+      @LOC("THIS,LayerIIIDecoder.S") boolean i_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x1) != 0));
+      @LOC("THIS,LayerIIIDecoder.LSF") boolean lsf =
           ((header.version() == Header.MPEG2_LSF || header.version() == Header.MPEG25_LSF)); // SZD
 
-      int io_type = (gr_info.scalefac_compress & 1);
+      @LOC("IO") int io_type = (gr_info.scalefac_compress & 1);
 
       // initialization
 
@@ -1174,10 +1198,10 @@ final class LayerIIIDecoder implements FrameDecoder {
         if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
           if (gr_info.mixed_block_flag != 0) {
 
-            int max_sfb = 0;
+	    @LOC("THIS,LayerIIIDecoder.SH") int max_sfb = 0;
 
-            for (int j = 0; j < 3; j++) {
-              int sfbcnt;
+            for (@LOC("THIS,LayerIIIDecoder.J") int j = 0; j < 3; j++) {
+	      @LOC("THIS,LayerIIIDecoder.SH") int sfbcnt;
               sfbcnt = 2;
               for (sfb = 12; sfb >= 3; sfb--) {
                 i = sfBandIndex[sfreq].s[sfb];
@@ -1276,8 +1300,8 @@ final class LayerIIIDecoder implements FrameDecoder {
               } // for (; sfb<8 ...
             } // for (j=0 ...
           } else { // if (gr_info.mixed_block_flag)
-            for (int j = 0; j < 3; j++) {
-              int sfbcnt;
+	    for (@LOC("THIS,LayerIIIDecoder.J") int j = 0; j < 3; j++) {
+	      @LOC("THIS,LayerIIIDecoder.SH") int sfbcnt;
               sfbcnt = -1;
               for (sfb = 12; sfb >= 0; sfb--) {
                 temp = sfBandIndex[sfreq].s[sfb];
@@ -1418,9 +1442,12 @@ final class LayerIIIDecoder implements FrameDecoder {
   /**
 	 *
 	 */
-  private void antialias(int ch, int gr) {
-    int sb18, ss, sb18lim;
-    gr_info_s gr_info = (si.ch[ch].gr[gr]);
+  @LATTICE("THIS<SRC<SS,SS<SB18,SB18<SB18LIM,SB18LIM<GR,GR<IN,SB18*,SS*,THISLOC=THIS")
+  private void antialias(@LOC("IN") int ch, @LOC("IN") int gr) {
+    @LOC("SB18") int sb18;
+    @LOC("SS") int ss;
+    @LOC("SB18LIM") int sb18lim;
+    @LOC("GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);
     // 31 alias-reduction operations between each pair of sub-bands
     // with 8 butterflies between each pair
 
@@ -1437,10 +1464,10 @@ final class LayerIIIDecoder implements FrameDecoder {
 
     for (sb18 = 0; sb18 < sb18lim; sb18 += 18) {
       for (ss = 0; ss < 8; ss++) {
-        int src_idx1 = sb18 + 17 - ss;
-        int src_idx2 = sb18 + 18 + ss;
-        float bu = out_1d[src_idx1];
-        float bd = out_1d[src_idx2];
+	@LOC("SRC") int src_idx1 = sb18 + 17 - ss;
+        @LOC("SRC") int src_idx2 = sb18 + 18 + ss;
+        @LOC("THIS,LayerIIIDecoder.O") float bu = out_1d[src_idx1];
+        @LOC("THIS,LayerIIIDecoder.0") float bd = out_1d[src_idx2];
         out_1d[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);
         out_1d[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);
       }
@@ -1453,16 +1480,17 @@ final class LayerIIIDecoder implements FrameDecoder {
 
   // MDM: tsOutCopy and rawout do not need initializing, so the arrays
   // can be reused.
-  float[] tsOutCopy = new float[18];
-  float[] rawout = new float[36];
-
-  private void hybrid(int ch, int gr) {
-    int bt;
-    int sb18;
-    gr_info_s gr_info = (si.ch[ch].gr[gr]);
-    float[] tsOut;
-
-    float[][] prvblk;
+  @LOC("TS") float[] tsOutCopy = new float[18];
+  @LOC("RAW") float[] rawout = new float[36];
+  
+@LATTICE("THIS<SB,THIS<SH,SH<IN,IN<GLOBAL,SB*,SH*,THISLOC=THIS,GLOBALLOC=GLOBAL")
+    private void hybrid(@LOC("IN") int ch, @LOC("IN") int gr) {
+    @LOC("THIS,LayerIIIDecoder.BT") int bt;
+    @LOC("SB") int sb18;
+    @LOC("THIS,LayerIIIDecoder.GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);
+    @LOC("THIS,LayerIIIDecoder.TS") float[] tsOut;
+
+    //float[][] prvblk;
 
     for (sb18 = 0; sb18 < 576; sb18 += 18) {
       bt =
@@ -1471,63 +1499,64 @@ final class LayerIIIDecoder implements FrameDecoder {
 
       tsOut = out_1d;
       // Modif E.B 02/22/99
-      for (int cc = 0; cc < 18; cc++)
+      for (@LOC("SH") int cc = 0; cc < 18; cc++)
         tsOutCopy[cc] = tsOut[cc + sb18];
 
       inv_mdct(tsOutCopy, rawout, bt);
 
-      for (int cc = 0; cc < 18; cc++)
+      for (@LOC("SH") int cc = 0; cc < 18; cc++)
         tsOut[cc + sb18] = tsOutCopy[cc];
       // Fin Modif
 
       // overlap addition
-      prvblk = prevblck;
-
-      tsOut[0 + sb18] = rawout[0] + prvblk[ch][sb18 + 0];
-      prvblk[ch][sb18 + 0] = rawout[18];
-      tsOut[1 + sb18] = rawout[1] + prvblk[ch][sb18 + 1];
-      prvblk[ch][sb18 + 1] = rawout[19];
-      tsOut[2 + sb18] = rawout[2] + prvblk[ch][sb18 + 2];
-      prvblk[ch][sb18 + 2] = rawout[20];
-      tsOut[3 + sb18] = rawout[3] + prvblk[ch][sb18 + 3];
-      prvblk[ch][sb18 + 3] = rawout[21];
-      tsOut[4 + sb18] = rawout[4] + prvblk[ch][sb18 + 4];
-      prvblk[ch][sb18 + 4] = rawout[22];
-      tsOut[5 + sb18] = rawout[5] + prvblk[ch][sb18 + 5];
-      prvblk[ch][sb18 + 5] = rawout[23];
-      tsOut[6 + sb18] = rawout[6] + prvblk[ch][sb18 + 6];
-      prvblk[ch][sb18 + 6] = rawout[24];
-      tsOut[7 + sb18] = rawout[7] + prvblk[ch][sb18 + 7];
-      prvblk[ch][sb18 + 7] = rawout[25];
-      tsOut[8 + sb18] = rawout[8] + prvblk[ch][sb18 + 8];
-      prvblk[ch][sb18 + 8] = rawout[26];
-      tsOut[9 + sb18] = rawout[9] + prvblk[ch][sb18 + 9];
-      prvblk[ch][sb18 + 9] = rawout[27];
-      tsOut[10 + sb18] = rawout[10] + prvblk[ch][sb18 + 10];
-      prvblk[ch][sb18 + 10] = rawout[28];
-      tsOut[11 + sb18] = rawout[11] + prvblk[ch][sb18 + 11];
-      prvblk[ch][sb18 + 11] = rawout[29];
-      tsOut[12 + sb18] = rawout[12] + prvblk[ch][sb18 + 12];
-      prvblk[ch][sb18 + 12] = rawout[30];
-      tsOut[13 + sb18] = rawout[13] + prvblk[ch][sb18 + 13];
-      prvblk[ch][sb18 + 13] = rawout[31];
-      tsOut[14 + sb18] = rawout[14] + prvblk[ch][sb18 + 14];
-      prvblk[ch][sb18 + 14] = rawout[32];
-      tsOut[15 + sb18] = rawout[15] + prvblk[ch][sb18 + 15];
-      prvblk[ch][sb18 + 15] = rawout[33];
-      tsOut[16 + sb18] = rawout[16] + prvblk[ch][sb18 + 16];
-      prvblk[ch][sb18 + 16] = rawout[34];
-      tsOut[17 + sb18] = rawout[17] + prvblk[ch][sb18 + 17];
-      prvblk[ch][sb18 + 17] = rawout[35];
+      //prvblk = prevblck; //eliminated unnecessary areas
+
+      tsOut[0 + sb18] = rawout[0] + prevblk[ch][sb18 + 0];
+      prevblk[ch][sb18 + 0] = rawout[18];
+      tsOut[1 + sb18] = rawout[1] + prevblk[ch][sb18 + 1];
+      prevblk[ch][sb18 + 1] = rawout[19];
+      tsOut[2 + sb18] = rawout[2] + prevblk[ch][sb18 + 2];
+      prevblk[ch][sb18 + 2] = rawout[20];
+      tsOut[3 + sb18] = rawout[3] + prevblk[ch][sb18 + 3];
+      prevblk[ch][sb18 + 3] = rawout[21];
+      tsOut[4 + sb18] = rawout[4] + prevblk[ch][sb18 + 4];
+      prevblk[ch][sb18 + 4] = rawout[22];
+      tsOut[5 + sb18] = rawout[5] + prevblk[ch][sb18 + 5];
+      prevblk[ch][sb18 + 5] = rawout[23];
+      tsOut[6 + sb18] = rawout[6] + prevblk[ch][sb18 + 6];
+      prevblk[ch][sb18 + 6] = rawout[24];
+      tsOut[7 + sb18] = rawout[7] + prevblk[ch][sb18 + 7];
+      prevblk[ch][sb18 + 7] = rawout[25];
+      tsOut[8 + sb18] = rawout[8] + prevblk[ch][sb18 + 8];
+      prevblk[ch][sb18 + 8] = rawout[26];
+      tsOut[9 + sb18] = rawout[9] + prevblk[ch][sb18 + 9];
+      prevblk[ch][sb18 + 9] = rawout[27];
+      tsOut[10 + sb18] = rawout[10] + prevblk[ch][sb18 + 10];
+      prevblk[ch][sb18 + 10] = rawout[28];
+      tsOut[11 + sb18] = rawout[11] + prevblk[ch][sb18 + 11];
+      prevblk[ch][sb18 + 11] = rawout[29];
+      tsOut[12 + sb18] = rawout[12] + prevblk[ch][sb18 + 12];
+      prevblk[ch][sb18 + 12] = rawout[30];
+      tsOut[13 + sb18] = rawout[13] + prevblk[ch][sb18 + 13];
+      prevblk[ch][sb18 + 13] = rawout[31];
+      tsOut[14 + sb18] = rawout[14] + prevblk[ch][sb18 + 14];
+      prevblk[ch][sb18 + 14] = rawout[32];
+      tsOut[15 + sb18] = rawout[15] + prevblk[ch][sb18 + 15];
+      prevblk[ch][sb18 + 15] = rawout[33];
+      tsOut[16 + sb18] = rawout[16] + prevblk[ch][sb18 + 16];
+      prevblk[ch][sb18 + 16] = rawout[34];
+      tsOut[17 + sb18] = rawout[17] + prevblk[ch][sb18 + 17];
+      prevblk[ch][sb18 + 17] = rawout[35];
     }
   }
 
   /**
 	 *
 	 */
+  @LATTICE("THIS<SB,THIS<SS,SB<GLOBAL,SS<GLOBAL,SS*,SB*,THISLOC=THIS,GLOBALLOC=GLOBAL")
   private void do_downmix() {
-    for (int sb = 0; sb < SSLIMIT; sb++) {
-      for (int ss = 0; ss < SSLIMIT; ss += 3) {
+    for (@LOC("SB") int sb = 0; sb < SSLIMIT; sb++) {
+      for (@LOC("SS") int ss = 0; ss < SSLIMIT; ss += 3) {
         lr[0][sb][ss] = (lr[0][sb][ss] + lr[1][sb][ss]) * 0.5f;
         lr[0][sb][ss + 1] = (lr[0][sb][ss + 1] + lr[1][sb][ss + 1]) * 0.5f;
         lr[0][sb][ss + 2] = (lr[0][sb][ss + 2] + lr[1][sb][ss + 2]) * 0.5f;
@@ -1538,13 +1567,29 @@ final class LayerIIIDecoder implements FrameDecoder {
   /**
    * Fast INV_MDCT.
    */
-
-  public void inv_mdct(float[] in, float[] out, int block_type) {
-    float[] win_bt;
-    int i;
-
-    float tmpf_0, tmpf_1, tmpf_2, tmpf_3, tmpf_4, tmpf_5, tmpf_6, tmpf_7, tmpf_8, tmpf_9;
-    float tmpf_10, tmpf_11, tmpf_12, tmpf_13, tmpf_14, tmpf_15, tmpf_16, tmpf_17;
+@LATTICE("OUT<6I,OUT<TMPF,TMPF<EO,EO<TMP,TMP<SUM,TMP<IIP,IIP<I00,I00<SH,SUM<PP,PP<SH,SH<I,I<IN,TMPF*,SH*,I*,6I*,GLOBALLOC=IN")
+public void inv_mdct(@LOC("SH") float[] in, @LOC("OUT") float[] out, @LOC("IN") int block_type) {
+    //float[] win_bt;
+    @LOC("I") int i;
+
+    @LOC("TMPF") float tmpf_0;
+    @LOC("TMPF") float tmpf_1;
+    @LOC("TMPF") float tmpf_2;
+    @LOC("TMPF") float tmpf_3;
+    @LOC("TMPF") float tmpf_4;
+    @LOC("TMPF") float tmpf_5;
+    @LOC("TMPF") float tmpf_6;
+    @LOC("TMPF") float tmpf_7;
+    @LOC("TMPF") float tmpf_8;
+    @LOC("TMPF") float tmpf_9;
+    @LOC("TMPF") float tmpf_10;
+    @LOC("TMPF") float tmpf_11;
+    @LOC("TMPF") float tmpf_12;
+    @LOC("TMPF") float tmpf_13;
+    @LOC("TMPF") float tmpf_14;
+    @LOC("TMPF") float tmpf_15;
+    @LOC("TMPF") float tmpf_16;
+    @LOC("TMPF") float tmpf_17;
 
     tmpf_0 =
         tmpf_1 =
@@ -1609,7 +1654,7 @@ final class LayerIIIDecoder implements FrameDecoder {
       out[34] = 0.0f;
       out[35] = 0.0f;
 
-      int six_i = 0;
+      @LOC("6I") int six_i = 0;
 
       for (i = 0; i < 3; i++) {
         // 12 point IMDCT
@@ -1626,7 +1671,9 @@ final class LayerIIIDecoder implements FrameDecoder {
         in[9 + i] += in[3 + i];
 
         // 3 point IDCT on even indices
-        float pp1, pp2, sum;
+        @LOC("PP") float pp1;
+	@LOC("PP") float pp2;
+        @LOC("SUM") float sum;
         pp2 = in[12 + i] * 0.500000000f;
         pp1 = in[6 + i] * 0.866025403f;
         sum = in[0 + i] + pp2;
@@ -1650,7 +1697,7 @@ final class LayerIIIDecoder implements FrameDecoder {
         tmpf_5 *= 0.517638090f;
 
         // Output butterflies on 2 3 point IDCT's (for 6 point IDCT)
-        float save = tmpf_0;
+        @LOC("SH") float save = tmpf_0;
         tmpf_0 += tmpf_5;
         tmpf_5 = save - tmpf_5;
         save = tmpf_1;
@@ -1737,8 +1784,24 @@ final class LayerIIIDecoder implements FrameDecoder {
       in[5] += in[3];
       in[3] += in[1];
 
-      float tmp0, tmp1, tmp2, tmp3, tmp4, tmp0_, tmp1_, tmp2_, tmp3_;
-      float tmp0o, tmp1o, tmp2o, tmp3o, tmp4o, tmp0_o, tmp1_o, tmp2_o, tmp3_o;
+      @LOC("TMP") float tmp0;
+      @LOC("TMP") float tmp1;
+      @LOC("TMP") float tmp2;
+      @LOC("TMP") float tmp3;
+      @LOC("TMP") float tmp4;
+      @LOC("TMP") float tmp0_;
+      @LOC("TMP") float tmp1_;
+      @LOC("TMP") float tmp2_;
+      @LOC("TMP") float tmp3_;
+      @LOC("TMP") float tmp0o;
+      @LOC("TMP") float tmp1o;
+      @LOC("TMP") float tmp2o;
+      @LOC("TMP") float tmp3o;
+      @LOC("TMP") float tmp4o;
+      @LOC("TMP") float tmp0_o;
+      @LOC("TMP") float tmp1_o;
+      @LOC("TMP") float tmp2_o;
+      @LOC("TMP") float tmp3_o;
 
       // Fast 9 Point Inverse Discrete Cosine Transform
       //
@@ -1755,8 +1818,8 @@ final class LayerIIIDecoder implements FrameDecoder {
       // 9 point IDCT on even indices
 
       // 5 points on odd indices (not realy an IDCT)
-      float i00 = in[0] + in[0];
-      float iip12 = i00 + in[12];
+      @LOC("I00") float i00 = in[0] + in[0];
+      @LOC("IIP") float iip12 = i00 + in[12];
 
       tmp0 =
           iip12 + in[4] * 1.8793852415718f + in[8] * 1.532088886238f + in[16] * 0.34729635533386f;
@@ -1768,7 +1831,7 @@ final class LayerIIIDecoder implements FrameDecoder {
       tmp4 = in[0] - in[4] + in[8] - in[12] + in[16];
 
       // 4 points on even indices
-      float i66_ = in[6] * 1.732050808f; // Sqrt[3]
+      @LOC("I00") float i66_ = in[6] * 1.732050808f; // Sqrt[3]
 
       tmp0_ =
           in[2] * 1.9696155060244f + i66_ + in[10] * 1.2855752193731f + in[14] * 0.68404028665134f;
@@ -1780,8 +1843,8 @@ final class LayerIIIDecoder implements FrameDecoder {
 
       // 9 point IDCT on odd indices
       // 5 points on odd indices (not realy an IDCT)
-      float i0 = in[0 + 1] + in[0 + 1];
-      float i0p12 = i0 + in[12 + 1];
+      @LOC("I00") float i0 = in[0 + 1] + in[0 + 1];
+      @LOC("IIP") float i0p12 = i0 + in[12 + 1];
 
       tmp0o =
           i0p12 + in[4 + 1] * 1.8793852415718f + in[8 + 1] * 1.532088886238f + in[16 + 1]
@@ -1796,7 +1859,7 @@ final class LayerIIIDecoder implements FrameDecoder {
       tmp4o = (in[0 + 1] - in[4 + 1] + in[8 + 1] - in[12 + 1] + in[16 + 1]) * 0.707106781f; // Twiddled
 
       // 4 points on even indices
-      float i6_ = in[6 + 1] * 1.732050808f; // Sqrt[3]
+      @LOC("I00") float i6_ = in[6 + 1] * 1.732050808f; // Sqrt[3]
 
       tmp0_o =
           in[2 + 1] * 1.9696155060244f + i6_ + in[10 + 1] * 1.2855752193731f + in[14 + 1]
@@ -1815,7 +1878,8 @@ final class LayerIIIDecoder implements FrameDecoder {
       // and
       // twiddle factors for 36 point IDCT
 
-      float e, o;
+      @LOC("EO") float e;
+      @LOC("EO") float o;
       e = tmp0 + tmp0_;
       o = (tmp0o + tmp0_o) * 0.501909918f;
       tmpf_0 = e + o;
@@ -1853,50 +1917,50 @@ final class LayerIIIDecoder implements FrameDecoder {
 
       // end 36 point IDCT */
       // shift to modified IDCT
-      win_bt = win[block_type];
-
-      out[0] = -tmpf_9 * win_bt[0];
-      out[1] = -tmpf_10 * win_bt[1];
-      out[2] = -tmpf_11 * win_bt[2];
-      out[3] = -tmpf_12 * win_bt[3];
-      out[4] = -tmpf_13 * win_bt[4];
-      out[5] = -tmpf_14 * win_bt[5];
-      out[6] = -tmpf_15 * win_bt[6];
-      out[7] = -tmpf_16 * win_bt[7];
-      out[8] = -tmpf_17 * win_bt[8];
-      out[9] = tmpf_17 * win_bt[9];
-      out[10] = tmpf_16 * win_bt[10];
-      out[11] = tmpf_15 * win_bt[11];
-      out[12] = tmpf_14 * win_bt[12];
-      out[13] = tmpf_13 * win_bt[13];
-      out[14] = tmpf_12 * win_bt[14];
-      out[15] = tmpf_11 * win_bt[15];
-      out[16] = tmpf_10 * win_bt[16];
-      out[17] = tmpf_9 * win_bt[17];
-      out[18] = tmpf_8 * win_bt[18];
-      out[19] = tmpf_7 * win_bt[19];
-      out[20] = tmpf_6 * win_bt[20];
-      out[21] = tmpf_5 * win_bt[21];
-      out[22] = tmpf_4 * win_bt[22];
-      out[23] = tmpf_3 * win_bt[23];
-      out[24] = tmpf_2 * win_bt[24];
-      out[25] = tmpf_1 * win_bt[25];
-      out[26] = tmpf_0 * win_bt[26];
-      out[27] = tmpf_0 * win_bt[27];
-      out[28] = tmpf_1 * win_bt[28];
-      out[29] = tmpf_2 * win_bt[29];
-      out[30] = tmpf_3 * win_bt[30];
-      out[31] = tmpf_4 * win_bt[31];
-      out[32] = tmpf_5 * win_bt[32];
-      out[33] = tmpf_6 * win_bt[33];
-      out[34] = tmpf_7 * win_bt[34];
-      out[35] = tmpf_8 * win_bt[35];
+      //win_bt = win[block_type]; //substituted this so that a new area does not become created
+
+      out[0] = -tmpf_9 * win[block_type][0];
+      out[1] = -tmpf_10 * win[block_type][1];
+      out[2] = -tmpf_11 * win[block_type][2];
+      out[3] = -tmpf_12 * win[block_type][3];
+      out[4] = -tmpf_13 * win[block_type][4];
+      out[5] = -tmpf_14 * win[block_type][5];
+      out[6] = -tmpf_15 * win[block_type][6];
+      out[7] = -tmpf_16 * win[block_type][7];
+      out[8] = -tmpf_17 * win[block_type][8];
+      out[9] = tmpf_17 * win[block_type][9];
+      out[10] = tmpf_16 * win[block_type][10];
+      out[11] = tmpf_15 * win[block_type][11];
+      out[12] = tmpf_14 * win[block_type][12];
+      out[13] = tmpf_13 * win[block_type][13];
+      out[14] = tmpf_12 * win[block_type][14];
+      out[15] = tmpf_11 * win[block_type][15];
+      out[16] = tmpf_10 * win[block_type][16];
+      out[17] = tmpf_9 * win[block_type][17];
+      out[18] = tmpf_8 * win[block_type][18];
+      out[19] = tmpf_7 * win[block_type][19];
+      out[20] = tmpf_6 * win[block_type][20];
+      out[21] = tmpf_5 * win[block_type][21];
+      out[22] = tmpf_4 * win[block_type][22];
+      out[23] = tmpf_3 * win[block_type][23];
+      out[24] = tmpf_2 * win[block_type][24];
+      out[25] = tmpf_1 * win[block_type][25];
+      out[26] = tmpf_0 * win[block_type][26];
+      out[27] = tmpf_0 * win[block_type][27];
+      out[28] = tmpf_1 * win[block_type][28];
+      out[29] = tmpf_2 * win[block_type][29];
+      out[30] = tmpf_3 * win[block_type][30];
+      out[31] = tmpf_4 * win[block_type][31];
+      out[32] = tmpf_5 * win[block_type][32];
+      out[33] = tmpf_6 * win[block_type][33];
+      out[34] = tmpf_7 * win[block_type][34];
+      out[35] = tmpf_8 * win[block_type][35];
     }
   }
 
-  private int counter = 0;
-  private static final int SSLIMIT = 18;
-  private static final int SBLIMIT = 32;
+  @LOC("C") private int counter = 0;
+  @LOC("F") private static final int SSLIMIT = 18;
+  @LOC("F") private static final int SBLIMIT = 32;
 
   // Size of the table of whole numbers raised to 4/3 power.
   // This may be adjusted for performance without any problems.
@@ -2002,15 +2066,15 @@ final class LayerIIIDecoder implements FrameDecoder {
   // }
   // }
 
-  private static final int slen[][] = { { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
+  @LOC("F") private static final int slen[][] = { { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
       { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 } };
 
-  public static final int pretab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3,
+  @LOC("F") public static final int pretab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3,
       2, 0 };
 
-  private SBI[] sfBandIndex; // Init in the constructor.
+  @LOC("F") private SBI[] sfBandIndex; // Init in the constructor.
 
-  public static final float two_to_negative_half_pow[] = { 1.0000000000E+00f, 7.0710678119E-01f,
+  @LOC("F") public static final float two_to_negative_half_pow[] = { 1.0000000000E+00f, 7.0710678119E-01f,
       5.0000000000E-01f, 3.5355339059E-01f, 2.5000000000E-01f, 1.7677669530E-01f,
       1.2500000000E-01f, 8.8388347648E-02f, 6.2500000000E-02f, 4.4194173824E-02f,
       3.1250000000E-02f, 2.2097086912E-02f, 1.5625000000E-02f, 1.1048543456E-02f,
@@ -2028,19 +2092,20 @@ final class LayerIIIDecoder implements FrameDecoder {
       1.8626451492E-09f, 1.3170890160E-09f, 9.3132257462E-10f, 6.5854450798E-10f,
       4.6566128731E-10f, 3.2927225399E-10f };
 
-  public static final float t_43[] = create_t_43();
+  @LOC("F") public static final float t_43[] = create_t_43();
 
+  @RETURNLOC("OUT")
   static private float[] create_t_43() {
-    float[] t43 = new float[8192];
+      @LOC("OUT") float[] t43 = new float[8192];
     final double d43 = (4.0 / 3.0);
 
-    for (int i = 0; i < 8192; i++) {
+    for (@LOC("SH") int i = 0; i < 8192; i++) {
       t43[i] = (float) Math.pow(i, d43);
     }
     return t43;
   }
 
-  public static final float io[][] = {
+  @LOC("F") public static final float io[][] = {
       { 1.0000000000E+00f, 8.4089641526E-01f, 7.0710678119E-01f, 5.9460355751E-01f,
           5.0000000001E-01f, 4.2044820763E-01f, 3.5355339060E-01f, 2.9730177876E-01f,
           2.5000000001E-01f, 2.1022410382E-01f, 1.7677669530E-01f, 1.4865088938E-01f,
@@ -2058,7 +2123,7 @@ final class LayerIIIDecoder implements FrameDecoder {
           2.4414062501E-04f, 1.7263349151E-04f, 1.2207031251E-04f, 8.6316745755E-05f,
           6.1035156254E-05f, 4.3158372878E-05f, 3.0517578127E-05f, 2.1579186439E-05f } };
 
-  public static final float TAN12[] = { 0.0f, 0.26794919f, 0.57735027f, 1.0f, 1.73205081f,
+   @LOC("F") public static final float TAN12[] = { 0.0f, 0.26794919f, 0.57735027f, 1.0f, 1.73205081f,
       3.73205081f, 9.9999999e10f, -3.73205081f, -1.73205081f, -1.0f, -0.57735027f, -0.26794919f,
       0.0f, 0.26794919f, 0.57735027f, 1.0f };
 
@@ -2125,7 +2190,7 @@ final class LayerIIIDecoder implements FrameDecoder {
    * 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
    * 12, 13, 14, 15, 16, 17 };
    */
-  private static/* final */int reorder_table[][]/* = loadReorderTable() */; // SZD:
+  @LOC("F") private static/* final */int reorder_table[][]/* = loadReorderTable() */; // SZD:
                                                                             // will
                                                                             // be
                                                                             // generated
@@ -2142,10 +2207,10 @@ final class LayerIIIDecoder implements FrameDecoder {
    * return (int[][])o; } catch (IOException ex) { throw new
    * ExceptionInInitializerError(ex); } }
    */
-
-  static int[] reorder(int scalefac_band[]) { // SZD: converted from LAME
-    int j = 0;
-    int ix[] = new int[576];
+  @LATTICE("OUT<J,J<I,I<SE,I<WIN,SE<SF,SE<SFB,WIN<SFB,J*,I*,WIN*,SFB*")
+  static int[] reorder(@LOC("SF") int scalefac_band[]) { // SZD: converted from LAME
+    @LOC("J") int j = 0;
+    @LOC("OUT") int ix[] = new int[576];
     for (int sfb = 0; sfb < 13; sfb++) {
       int start = scalefac_band[sfb];
       int end = scalefac_band[sfb + 1];
@@ -2370,10 +2435,10 @@ final class LayerIIIDecoder implements FrameDecoder {
    * 570,547,559,571,548,560,572,549,561,573,550,562,574,551,563,575} };
    */
 
-  private static final float cs[] = { 0.857492925712f, 0.881741997318f, 0.949628649103f,
+  @LOC("F") private static final float cs[] = { 0.857492925712f, 0.881741997318f, 0.949628649103f,
       0.983314592492f, 0.995517816065f, 0.999160558175f, 0.999899195243f, 0.999993155067f };
 
-  private static final float ca[] = { -0.5144957554270f, -0.4717319685650f, -0.3133774542040f,
+  @LOC("F") private static final float ca[] = { -0.5144957554270f, -0.4717319685650f, -0.3133774542040f,
       -0.1819131996110f, -0.0945741925262f, -0.0409655828852f, -0.0141985685725f,
       -0.00369997467375f };
 
@@ -2392,7 +2457,7 @@ final class LayerIIIDecoder implements FrameDecoder {
   /***************************************************************/
   /* INV_MDCT */
   /***************************************************************/
-  public static final float win[][] = {
+  @LOC("F") public static final float win[][] = {
       { -1.6141214951E-02f, -5.3603178919E-02f, -1.0070713296E-01f, -1.6280817573E-01f,
           -4.9999999679E-01f, -3.8388735032E-01f, -6.2061144372E-01f, -1.1659756083E+00f,
           -3.8720752656E+00f, -4.2256286556E+00f, -1.5195289984E+00f, -9.7416483388E-01f,
@@ -2452,9 +2517,9 @@ final class LayerIIIDecoder implements FrameDecoder {
     }
   }
 
-  public Sftable sftable;
+  @LOC("F") public Sftable sftable;
 
-  public static final int nr_of_sfb_block[][][] = {
+  @LOC("F") public static final int nr_of_sfb_block[][][] = {
       { { 6, 5, 5, 5 }, { 9, 9, 9, 9 }, { 6, 9, 9, 9 } },
       { { 6, 5, 7, 3 }, { 9, 9, 12, 6 }, { 6, 9, 12, 6 } },
       { { 11, 10, 0, 0 }, { 18, 18, 0, 0 }, { 15, 18, 0, 0 } },
diff --git a/Robust/src/Tests/ssJava/mp3decoder/Obuffer.java b/Robust/src/Tests/ssJava/mp3decoder/Obuffer.java
index d05900d0..339f3ac9 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/Obuffer.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/Obuffer.java
@@ -36,11 +36,12 @@
 /**
  * Base Class for audio output.
  */
-@METHODDEFAULT("D<IN,D<C")
+@LATTICE("B<T")
+@METHODDEFAULT("D<IN,D<C,C*")
 public abstract class Obuffer
 {
-  public static final int     OBUFFERSIZE = 2 * 1152;  // max. 2 * 1152 samples per frame
-  public static final int   MAXCHANNELS = 2;        // max. number of channels
+  @LOC("T") public static final int     OBUFFERSIZE = 2 * 1152;  // max. 2 * 1152 samples per frame
+  @LOC("T") public static final int   MAXCHANNELS = 2;        // max. number of channels
 
   /**
    * Takes a 16 Bit PCM sample.
@@ -63,6 +64,7 @@ public abstract class Obuffer
   /**
    * Clip Sample to 16 Bits
    */
+  @RETURNLOC("IN")
   private final short clip(@LOC("IN") float sample)
   {
     return ((sample > 32767.0f) ? 32767 :
diff --git a/Robust/src/Tests/ssJava/mp3decoder/OutputChannels.java b/Robust/src/Tests/ssJava/mp3decoder/OutputChannels.java
index 91458859..edf00278 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/OutputChannels.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/OutputChannels.java
@@ -29,36 +29,38 @@
  * @author	Mat McGowan 12/12/99 
  * @since	0.0.7
  */
+@LATTICE("B<T")
+@METHODDEFAULT("OUT<IN")
 public class OutputChannels
 {		
 	/**
 	 * Flag to indicate output should include both channels. 
 	 */
-	public static final int	BOTH_CHANNELS = 0;
+        @LOC("T") public static final int	BOTH_CHANNELS = 0;
 		
 	/**
 	 * Flag to indicate output should include the left channel only. 
 	 */
-	public static final int	LEFT_CHANNEL = 1;
+        @LOC("T") public static final int	LEFT_CHANNEL = 1;
 
 	/**
 	 * Flag to indicate output should include the right channel only. 
 	 */
-	public static final int	RIGHT_CHANNEL = 2;
+        @LOC("T") public static final int	RIGHT_CHANNEL = 2;
 		
 	/**
 	 * Flag to indicate output is mono. 
 	 */
-	public static final int	DOWNMIX_CHANNELS = 3;
+        @LOC("T") public static final int	DOWNMIX_CHANNELS = 3;
 
 	
-	public static final OutputChannels LEFT = new OutputChannels(LEFT_CHANNEL);
-	public static final OutputChannels RIGHT = new OutputChannels(RIGHT_CHANNEL);
-	public static final OutputChannels BOTH = new OutputChannels(BOTH_CHANNELS);
-	public static final OutputChannels DOWNMIX = new OutputChannels(DOWNMIX_CHANNELS);
+        @LOC("B") public static final OutputChannels LEFT = new OutputChannels(LEFT_CHANNEL);
+        @LOC("B") public static final OutputChannels RIGHT = new OutputChannels(RIGHT_CHANNEL);
+        @LOC("B") public static final OutputChannels BOTH = new OutputChannels(BOTH_CHANNELS);
+        @LOC("B") public static final OutputChannels DOWNMIX = new OutputChannels(DOWNMIX_CHANNELS);
 				
 	
-	private /*final*/ int	outputChannels;
+        @LOC("T") private /*final*/ int	outputChannels;
 			
 	/**
 	 * Creates an <code>OutputChannels</code> instance
@@ -85,8 +87,8 @@ public class OutputChannels
 			throw new IllegalArgumentException("Invalid channel code: "+code);
 		}
 	}
-		
-	private OutputChannels(int channels)
+	
+        private OutputChannels(@LOC("IN") int channels)
 	{
 		outputChannels = channels;
 			
diff --git a/Robust/src/Tests/ssJava/mp3decoder/Player.java b/Robust/src/Tests/ssJava/mp3decoder/Player.java
index 406876e2..b4048110 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/Player.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/Player.java
@@ -110,7 +110,7 @@ public class Player
 	{
 		boolean ret = true;
 		
-		
+	    SSJAVA:
 		while (frames-- > 0 && ret)
 		{
 			ret = decodeFrame();			
diff --git a/Robust/src/Tests/ssJava/mp3decoder/SampleBuffer.java b/Robust/src/Tests/ssJava/mp3decoder/SampleBuffer.java
index a1e20aa1..913b8b02 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/SampleBuffer.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/SampleBuffer.java
@@ -27,14 +27,15 @@
  * The <code>SampleBuffer</code> class implements an output buffer
  * that provides storage for a fixed size block of samples. 
  */
-@LATTICE("BUF<BUFP,BUFP<CONT,BUFP*")
+@LATTICE("BUF<BUFP,BUFP<IDX,IDX<CONT,BUFP*,IDX*")
 @METHODDEFAULT("D<IN,D<C,C*,THISLOC=D")
 public class SampleBuffer extends Obuffer
 {
   @LOC("BUF") private short[]           buffer;
-  @LOC("BUFP") private int[]       bufferp;
+  @LOC("BUFP") private int[]            bufferp;
   @LOC("CONT") private int              channels;
   @LOC("CONT") private int              frequency;
+  @LOC("IDX") private int               idx;
 
   /**
    * Constructor
@@ -94,7 +95,7 @@ public class SampleBuffer extends Obuffer
   public void appendSamples(@LOC("IN") int channel, @LOC("IN") float[] f)
   {
     @LOC("D, SampleBuffer.BUFP") int pos = bufferp[channel]; 
-    // LOC(bufferp[channel])=[D,SampleBuffer.BUF]
+    // LOC(bufferp[channel])=[D,SampleBuffer.BUFP]
     // LOC(pos)=[D,SampleBuffer.BUFP]
 
     @LOC("D,SampleBuffer.BUFP") short s;    
@@ -153,10 +154,11 @@ public class SampleBuffer extends Obuffer
   /**
    *
    */
+
   public void clear_buffer()
   {
-    for (int i = 0; i < channels; ++i) 
-      bufferp[i] = (short)i;
+    for (idx = 0; idx < channels; ++idx) 
+      bufferp[idx] = (short)idx;
   }
 
   /**
diff --git a/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java b/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java
index 61d06aeb..2fd98ff6 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java
@@ -29,23 +29,25 @@
  *----------------------------------------------------------------------
  */
 
-import java.io.IOException;
+//import java.io.IOException; //Compiler does not support imports
 
 /**
  * A class for the synthesis filter bank.
  * This class does a fast downsampling from 32, 44.1 or 48 kHz to 8 kHz, if ULAW is defined.
  * Frequencies above 4 kHz are removed by ignoring higher subbands.
  */
+@LATTICE("TMP<PCM,PCM<AV,AV<V2,V2<V1,V1<L1,L1<L2,L2<L3,L3<L4,L4<LSH,LSH<S,S<SA,SA<EQ,EQ<SH,SH*,LSH*,V1*")
+@METHODDEFAULT("OUT<V,V<SH,SH<IN,IN<GLOBAL,SH*,THISLOC=IN,GLOBALLOC=GLOBAL")
 final class SynthesisFilter
 {
-  private float[] 			 v1;
-  private float[]		 	 v2;
-  private float[]			 actual_v;			// v1 or v2
-  private int 			 	 actual_write_pos;	// 0-15
-  private float[]			 samples;			// 32 new subband samples
-  private int				 channel;
-  private float 			 scalefactor;
-  private float[]			 eq;
+  @LOC("V1") private float[] 			 v1;
+  @LOC("V2") private float[]		 	 v2;
+  @LOC("AV") private float[]			 actual_v;			// v1 or v2
+  @LOC("SH") private int 			 actual_write_pos;	// 0-15
+  @LOC("SA") private float[]			 samples;			// 32 new subband samples
+  @LOC("V2") private int				 channel;
+  @LOC("V2") private float 			 scalefactor;
+  @LOC("EQ") private float[]			 eq;
 	
 	/**
 	 * Quality value for controlling CPU usage/quality tradeoff. 
@@ -152,7 +154,7 @@ final class SynthesisFilter
   /**
    * Inject Sample.
    */
-  public void input_sample(float sample, int subbandnumber)
+    public void input_sample(@LOC("V") float sample, @LOC("V") int subbandnumber)
   {	 	 		  
 	  samples[subbandnumber] = eq[subbandnumber]*sample;
   }
@@ -188,10 +190,38 @@ final class SynthesisFilter
 	 }
 	  */
 	  
-	float new_v0, new_v1, new_v2, new_v3, new_v4, new_v5, new_v6, new_v7, new_v8, new_v9;
-	float new_v10, new_v11, new_v12, new_v13, new_v14, new_v15, new_v16, new_v17, new_v18, new_v19;
-	float new_v20, new_v21, new_v22, new_v23, new_v24, new_v25, new_v26, new_v27, new_v28, new_v29;
-	float new_v30, new_v31;
+      @LOC("IN,SynthesisFilter.L4") float new_v0;
+      @LOC("IN,SynthesisFilter.L2") float new_v1;
+      @LOC("IN,SynthesisFilter.L4") float new_v2;
+      @LOC("IN,SynthesisFilter.L2") float new_v3;
+      @LOC("IN,SynthesisFilter.L3") float new_v4;
+      @LOC("IN,SynthesisFilter.L4") float new_v5;
+      @LOC("IN,SynthesisFilter.L2") float new_v6;
+      @LOC("IN,SynthesisFilter.L3") float new_v7;
+      @LOC("IN,SynthesisFilter.L4") float new_v8;
+      @LOC("IN,SynthesisFilter.L4") float new_v9;
+      @LOC("IN,SynthesisFilter.L3") float new_v10;
+      @LOC("IN,SynthesisFilter.L2") float new_v11;
+      @LOC("IN,SynthesisFilter.L4") float new_v12;
+      @LOC("IN,SynthesisFilter.L3") float new_v13;
+      @LOC("IN,SynthesisFilter.L4") float new_v14;
+      @LOC("IN,SynthesisFilter.L4") float new_v15;
+      @LOC("IN,SynthesisFilter.L1") float new_v16;
+      @LOC("IN,SynthesisFilter.L3") float new_v17;
+      @LOC("IN,SynthesisFilter.L1") float new_v18;
+      @LOC("IN,SynthesisFilter.L2") float new_v19;
+      @LOC("IN,SynthesisFilter.L2") float new_v20;
+      @LOC("IN,SynthesisFilter.L2") float new_v21;
+      @LOC("IN,SynthesisFilter.L2") float new_v22;
+      @LOC("IN,SynthesisFilter.L3") float new_v23;
+      @LOC("IN,SynthesisFilter.L2") float new_v24;
+      @LOC("IN,SynthesisFilter.L2") float new_v25;
+      @LOC("IN,SynthesisFilter.L2") float new_v26;
+      @LOC("IN,SynthesisFilter.L4") float new_v27;
+      @LOC("IN,SynthesisFilter.L2") float new_v28;
+      @LOC("IN,SynthesisFilter.L4") float new_v29;
+      @LOC("IN,SynthesisFilter.L2") float new_v30;
+      @LOC("IN,SynthesisFilter.L4") float new_v31;
 	  
 	new_v0 = new_v1 = new_v2 = new_v3 = new_v4 = new_v5 = new_v6 = new_v7 = new_v8 = new_v9 = 
 	new_v10 = new_v11 = new_v12 = new_v13 = new_v14 = new_v15 = new_v16 = new_v17 = new_v18 = new_v19 = 
@@ -203,74 +233,74 @@ final class SynthesisFilter
 //	float[] p = new float[16];
 //	float[] pp = new float[16];
 
-    float[] s = samples;
-	
-	float s0 = s[0];
-	float s1 = s[1];
-	float s2 = s[2];
-	float s3 = s[3];
-	float s4 = s[4];
-	float s5 = s[5];
-	float s6 = s[6];
-	float s7 = s[7];
-	float s8 = s[8];
-	float s9 = s[9];
-	float s10 = s[10];	
-	float s11 = s[11];
-	float s12 = s[12];
-	float s13 = s[13];
-	float s14 = s[14];
-	float s15 = s[15];
-	float s16 = s[16];
-	float s17 = s[17];
-	float s18 = s[18];
-	float s19 = s[19];
-	float s20 = s[20];	
-	float s21 = s[21];
-	float s22 = s[22];
-	float s23 = s[23];
-	float s24 = s[24];
-	float s25 = s[25];
-	float s26 = s[26];
-	float s27 = s[27];
-	float s28 = s[28];
-	float s29 = s[29];
-	float s30 = s[30];	
-	float s31 = s[31];
+	//float[] s = samples; // subbed in samples directly below to reduce uneccesary areas
+	
+	@LOC("IN,SynthesisFilter.S") float s0 = samples[0];
+	@LOC("IN,SynthesisFilter.S") float s1 = samples[1];
+	@LOC("IN,SynthesisFilter.S") float s2 = samples[2];
+	@LOC("IN,SynthesisFilter.S") float s3 = samples[3];
+	@LOC("IN,SynthesisFilter.S") float s4 = samples[4];
+	@LOC("IN,SynthesisFilter.S") float s5 = samples[5];
+	@LOC("IN,SynthesisFilter.S") float s6 = samples[6];
+	@LOC("IN,SynthesisFilter.S") float s7 = samples[7];
+	@LOC("IN,SynthesisFilter.S") float s8 = samples[8];
+	@LOC("IN,SynthesisFilter.S") float s9 = samples[9];
+	@LOC("IN,SynthesisFilter.S") float s10 = samples[10];	
+	@LOC("IN,SynthesisFilter.S") float s11 = samples[11];
+	@LOC("IN,SynthesisFilter.S") float s12 = samples[12];
+	@LOC("IN,SynthesisFilter.S") float s13 = samples[13];
+	@LOC("IN,SynthesisFilter.S") float s14 = samples[14];
+	@LOC("IN,SynthesisFilter.S") float s15 = samples[15];
+	@LOC("IN,SynthesisFilter.S") float s16 = samples[16];
+	@LOC("IN,SynthesisFilter.S") float s17 = samples[17];
+	@LOC("IN,SynthesisFilter.S") float s18 = samples[18];
+	@LOC("IN,SynthesisFilter.S") float s19 = samples[19];
+	@LOC("IN,SynthesisFilter.S") float s20 = samples[20];	
+	@LOC("IN,SynthesisFilter.S") float s21 = samples[21];
+	@LOC("IN,SynthesisFilter.S") float s22 = samples[22];
+	@LOC("IN,SynthesisFilter.S") float s23 = samples[23];
+	@LOC("IN,SynthesisFilter.S") float s24 = samples[24];
+	@LOC("IN,SynthesisFilter.S") float s25 = samples[25];
+	@LOC("IN,SynthesisFilter.S") float s26 = samples[26];
+	@LOC("IN,SynthesisFilter.S") float s27 = samples[27];
+	@LOC("IN,SynthesisFilter.S") float s28 = samples[28];
+	@LOC("IN,SynthesisFilter.S") float s29 = samples[29];
+	@LOC("IN,SynthesisFilter.S") float s30 = samples[30];	
+	@LOC("IN,SynthesisFilter.S") float s31 = samples[31];
 		
-	float p0 = s0 + s31;
-	float p1 = s1 + s30;
-	float p2 = s2 + s29;
-	float p3 = s3 + s28;
-	float p4 = s4 + s27;
-	float p5 = s5 + s26;
-	float p6 = s6 + s25;
-	float p7 = s7 + s24;
-	float p8 = s8 + s23;
-	float p9 = s9 + s22;
-	float p10 = s10 + s21;
-	float p11 = s11 + s20;
-	float p12 = s12 + s19;
-	float p13 = s13 + s18;
-	float p14 = s14 + s17;
-	float p15 = s15 + s16;
-	
-	float pp0 = p0 + p15;
-	float pp1 = p1 + p14;
-	float pp2 = p2 + p13;
-	float pp3 = p3 + p12;
-	float pp4 = p4 + p11;
-	float pp5 = p5 + p10;
-	float pp6 = p6 + p9;
-	float pp7 = p7 + p8;
-	float pp8 = (p0 - p15) * cos1_32;
-	float pp9 = (p1 - p14) * cos3_32;
-	float pp10 = (p2 - p13) * cos5_32;
-	float pp11 = (p3 - p12) * cos7_32;
-	float pp12 = (p4 - p11) * cos9_32;
-	float pp13 = (p5 - p10) * cos11_32;
-	float pp14 = (p6 - p9) * cos13_32;
-	float pp15 = (p7 - p8) * cos15_32;
+	@LOC("IN,SynthesisFilter.LSH") float p0 = s0 + s31;
+	@LOC("IN,SynthesisFilter.LSH") float p1 = s1 + s30;
+	@LOC("IN,SynthesisFilter.LSH") float p2 = s2 + s29;
+	@LOC("IN,SynthesisFilter.LSH") float p3 = s3 + s28;
+	@LOC("IN,SynthesisFilter.LSH") float p4 = s4 + s27;
+	@LOC("IN,SynthesisFilter.LSH") float p5 = s5 + s26;
+	@LOC("IN,SynthesisFilter.LSH") float p6 = s6 + s25;
+	@LOC("IN,SynthesisFilter.LSH") float p7 = s7 + s24;
+	@LOC("IN,SynthesisFilter.LSH") float p8 = s8 + s23;
+	@LOC("IN,SynthesisFilter.LSH") float p9 = s9 + s22;
+	@LOC("IN,SynthesisFilter.LSH") float p10 = s10 + s21;
+	@LOC("IN,SynthesisFilter.LSH") float p11 = s11 + s20;
+	@LOC("IN,SynthesisFilter.LSH") float p12 = s12 + s19;
+	@LOC("IN,SynthesisFilter.LSH") float p13 = s13 + s18;
+	@LOC("IN,SynthesisFilter.LSH") float p14 = s14 + s17;
+	@LOC("IN,SynthesisFilter.LSH") float p15 = s15 + s16;
+	
+	@LOC("IN,SynthesisFilter.LSH") float pp0 = p0 + p15;
+	@LOC("IN,SynthesisFilter.LSH") float pp1 = p1 + p14;
+	@LOC("IN,SynthesisFilter.LSH") float pp2 = p2 + p13;
+	@LOC("IN,SynthesisFilter.LSH") float pp3 = p3 + p12;
+	@LOC("IN,SynthesisFilter.LSH") float pp4 = p4 + p11;
+	@LOC("IN,SynthesisFilter.LSH") float pp5 = p5 + p10;
+	@LOC("IN,SynthesisFilter.LSH") float pp6 = p6 + p9;
+	@LOC("IN,SynthesisFilter.LSH") float pp7 = p7 + p8;
+	@LOC("IN,SynthesisFilter.LSH") float pp8 = (p0 - p15) * cos1_32;
+	@LOC("IN,SynthesisFilter.LSH") float pp9 = (p1 - p14) * cos3_32;
+	@LOC("IN,SynthesisFilter.LSH") float pp10 = (p2 - p13) * cos5_32;
+	@LOC("IN,SynthesisFilter.LSH") float pp11 = (p3 - p12) * cos7_32;
+	@LOC("IN,SynthesisFilter.LSH") float pp12 = (p4 - p11) * cos9_32;
+	@LOC("IN,SynthesisFilter.LSH") float pp13 = (p5 - p10) * cos11_32;
+	@LOC("IN,SynthesisFilter.LSH") float pp14 = (p6 - p9) * cos13_32;
+	@LOC("IN,SynthesisFilter.LSH") float pp15 = (p7 - p8) * cos15_32;
 
 	p0 = pp0 + pp7;
 	p1 = pp1 + pp6;
@@ -326,7 +356,7 @@ final class SynthesisFilter
 	p15 = (pp14 - pp15) * cos1_4;
 
 	// this is pretty insane coding
-	float tmp1;
+	@LOC("IN,SynthesisFilter.L3") float tmp1;
 	new_v19/*36-17*/ = -(new_v4 = (new_v12 = p7) + p5) - p6;
 	new_v27/*44-17*/ = -p6 - p7 - p4;
 	new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;
@@ -430,7 +460,7 @@ final class SynthesisFilter
 
 	// manually doing something that a compiler should handle sucks
 	// coding like this is hard to read
-	float tmp2;
+	@LOC("IN,SynthesisFilter.L4") float tmp2;
 	new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11)
 							+ p5 + p13;
 	new_v7 = (new_v9 = p15 + p11 + p3) + p13;
@@ -447,85 +477,122 @@ final class SynthesisFilter
 
 	// insert V[0-15] (== new_v[0-15]) into actual v:	
 	// float[] x2 = actual_v + actual_write_pos;
-	float dest[] = actual_v;
-	
-	int pos = actual_write_pos;
-	
-	dest[0 + pos] = new_v0;
-	dest[16 + pos] = new_v1;
-	dest[32 + pos] = new_v2;
-	dest[48 + pos] = new_v3;
-	dest[64 + pos] = new_v4;
-	dest[80 + pos] = new_v5;
-	dest[96 + pos] = new_v6;
-	dest[112 + pos] = new_v7;
-	dest[128 + pos] = new_v8;
-	dest[144 + pos] = new_v9;
-	dest[160 + pos] = new_v10;
-	dest[176 + pos] = new_v11;
-	dest[192 + pos] = new_v12;
-	dest[208 + pos] = new_v13;
-	dest[224 + pos] = new_v14;
-	dest[240 + pos] = new_v15;
+	//float dest[] = actual_v; //actual_v subbed in so as not to create a new area
+	
+	//int pos = actual_write_pos; //substituted to simplify location relations
+	
+	actual_v[0 + actual_write_pos] = new_v0;
+	actual_v[16 + actual_write_pos] = new_v1;
+	actual_v[32 + actual_write_pos] = new_v2;
+	actual_v[48 + actual_write_pos] = new_v3;
+	actual_v[64 + actual_write_pos] = new_v4;
+	actual_v[80 + actual_write_pos] = new_v5;
+	actual_v[96 + actual_write_pos] = new_v6;
+	actual_v[112 + actual_write_pos] = new_v7;
+	actual_v[128 + actual_write_pos] = new_v8;
+	actual_v[144 + actual_write_pos] = new_v9;
+	actual_v[160 + actual_write_pos] = new_v10;
+	actual_v[176 + actual_write_pos] = new_v11;
+	actual_v[192 + actual_write_pos] = new_v12;
+	actual_v[208 + actual_write_pos] = new_v13;
+	actual_v[224 + actual_write_pos] = new_v14;
+	actual_v[240 + actual_write_pos] = new_v15;
 
 	// V[16] is always 0.0:
-	dest[256 + pos] = 0.0f;
+	actual_v[256 + actual_write_pos] = 0.0f;
 
 	// insert V[17-31] (== -new_v[15-1]) into actual v:
-	dest[272 + pos] = -new_v15;
-	dest[288 + pos] = -new_v14;
-	dest[304 + pos] = -new_v13;
-	dest[320 + pos] = -new_v12;
-	dest[336 + pos] = -new_v11;
-	dest[352 + pos] = -new_v10;
-	dest[368 + pos] = -new_v9;
-	dest[384 + pos] = -new_v8;
-	dest[400 + pos] = -new_v7;
-	dest[416 + pos] = -new_v6;
-	dest[432 + pos] = -new_v5;
-	dest[448 + pos] = -new_v4;
-	dest[464 + pos] = -new_v3;
-	dest[480 + pos] = -new_v2;
-	dest[496 + pos] = -new_v1;
+	actual_v[272 + actual_write_pos] = -new_v15;
+	actual_v[288 + actual_write_pos] = -new_v14;
+	actual_v[304 + actual_write_pos] = -new_v13;
+	actual_v[320 + actual_write_pos] = -new_v12;
+	actual_v[336 + actual_write_pos] = -new_v11;
+	actual_v[352 + actual_write_pos] = -new_v10;
+	actual_v[368 + actual_write_pos] = -new_v9;
+	actual_v[384 + actual_write_pos] = -new_v8;
+	actual_v[400 + actual_write_pos] = -new_v7;
+	actual_v[416 + actual_write_pos] = -new_v6;
+	actual_v[432 + actual_write_pos] = -new_v5;
+	actual_v[448 + actual_write_pos] = -new_v4;
+	actual_v[464 + actual_write_pos] = -new_v3;
+	actual_v[480 + actual_write_pos] = -new_v2;
+	actual_v[496 + actual_write_pos] = -new_v1;
 
 	// insert V[32] (== -new_v[0]) into other v:
-	dest = (actual_v==v1) ? v2 : v1;
-	
-	dest[0 + pos] = -new_v0;
+	//dest = (actual_v==v1) ? v2 : v1;  //assignment replaced with if statement so that new areas are not created
+	if(actual_v == v1){
+	    v2[0 + actual_write_pos] = -new_v0;
 	// insert V[33-48] (== new_v[16-31]) into other v:
-	dest[16 + pos] = new_v16;
-	dest[32 + pos] = new_v17;
-	dest[48 + pos] = new_v18;
-	dest[64 + pos] = new_v19;
-	dest[80 + pos] = new_v20;
-	dest[96 + pos] = new_v21;
-	dest[112 + pos] = new_v22;
-	dest[128 + pos] = new_v23;
-	dest[144 + pos] = new_v24;
-	dest[160 + pos] = new_v25;
-	dest[176 + pos] = new_v26;
-	dest[192 + pos] = new_v27;
-	dest[208 + pos] = new_v28;
-	dest[224 + pos] = new_v29;
-	dest[240 + pos] = new_v30;
-	dest[256 + pos] = new_v31;
+	    v2[16 + actual_write_pos] = new_v16;
+	    v2[32 + actual_write_pos] = new_v17;
+	    v2[48 + actual_write_pos] = new_v18;
+	    v2[64 + actual_write_pos] = new_v19;
+	    v2[80 + actual_write_pos] = new_v20;
+	    v2[96 + actual_write_pos] = new_v21;
+	    v2[112 + actual_write_pos] = new_v22;
+	    v2[128 + actual_write_pos] = new_v23;
+	    v2[144 + actual_write_pos] = new_v24;
+	    v2[160 + actual_write_pos] = new_v25;
+	    v2[176 + actual_write_pos] = new_v26;
+	    v2[192 + actual_write_pos] = new_v27;
+	    v2[208 + actual_write_pos] = new_v28;
+	    v2[224 + actual_write_pos] = new_v29;
+	    v2[240 + actual_write_pos] = new_v30;
+	    v2[256 + actual_write_pos] = new_v31;
 	
 	// insert V[49-63] (== new_v[30-16]) into other v:
-	dest[272 + pos] = new_v30;
-	dest[288 + pos] = new_v29;
-	dest[304 + pos] = new_v28;
-	dest[320 + pos] = new_v27;
-	dest[336 + pos] = new_v26;
-	dest[352 + pos] = new_v25;
-	dest[368 + pos] = new_v24;
-	dest[384 + pos] = new_v23;
-	dest[400 + pos] = new_v22;
-	dest[416 + pos] = new_v21;
-	dest[432 + pos] = new_v20;
-	dest[448 + pos] = new_v19;
-	dest[464 + pos] = new_v18;
-	dest[480 + pos] = new_v17;
-	dest[496 + pos] = new_v16; 			
+	    v2[272 + actual_write_pos] = new_v30;
+	    v2[288 + actual_write_pos] = new_v29;
+	    v2[304 + actual_write_pos] = new_v28;
+	    v2[320 + actual_write_pos] = new_v27;
+	    v2[336 + actual_write_pos] = new_v26;
+	    v2[352 + actual_write_pos] = new_v25;
+	    v2[368 + actual_write_pos] = new_v24;
+	    v2[384 + actual_write_pos] = new_v23;
+	    v2[400 + actual_write_pos] = new_v22;
+	    v2[416 + actual_write_pos] = new_v21;
+	    v2[432 + actual_write_pos] = new_v20;
+	    v2[448 + actual_write_pos] = new_v19;
+	    v2[464 + actual_write_pos] = new_v18;
+	    v2[480 + actual_write_pos] = new_v17;
+	    v2[496 + actual_write_pos] = new_v16;
+	} 
+	else{
+	    v1[0 + actual_write_pos] = -new_v0;
+	    v1[16 + actual_write_pos] = new_v16;
+	    v1[32 + actual_write_pos] = new_v17;
+	    v1[48 + actual_write_pos] = new_v18;
+	    v1[64 + actual_write_pos] = new_v19;
+	    v1[80 + actual_write_pos] = new_v20;
+	    v1[96 + actual_write_pos] = new_v21;
+	    v1[112 + actual_write_pos] = new_v22;
+	    v1[128 + actual_write_pos] = new_v23;
+	    v1[144 + actual_write_pos] = new_v24;
+	    v1[160 + actual_write_pos] = new_v25;
+	    v1[176 + actual_write_pos] = new_v26;
+	    v1[192 + actual_write_pos] = new_v27;
+	    v1[208 + actual_write_pos] = new_v28;
+	    v1[224 + actual_write_pos] = new_v29;
+	    v1[240 + actual_write_pos] = new_v30;
+	    v1[256 + actual_write_pos] = new_v31;
+	
+	// insert V[49-63] (== new_v[30-16]) into other v:
+	    v1[272 + actual_write_pos] = new_v30;
+	    v1[288 + actual_write_pos] = new_v29;
+	    v1[304 + actual_write_pos] = new_v28;
+	    v1[320 + actual_write_pos] = new_v27;
+	    v1[336 + actual_write_pos] = new_v26;
+	    v1[352 + actual_write_pos] = new_v25;
+	    v1[368 + actual_write_pos] = new_v24;
+	    v1[384 + actual_write_pos] = new_v23;
+	    v1[400 + actual_write_pos] = new_v22;
+	    v1[416 + actual_write_pos] = new_v21;
+	    v1[432 + actual_write_pos] = new_v20;
+	    v1[448 + actual_write_pos] = new_v19;
+	    v1[464 + actual_write_pos] = new_v18;
+	    v1[480 + actual_write_pos] = new_v17;
+	    v1[496 + actual_write_pos] = new_v16;
+	}
 /*
 	}
 	else
@@ -853,396 +920,398 @@ final class SynthesisFilter
    * Compute PCM Samples.
    */
   
-  private float[] _tmpOut = new float[32];
+  @LOC("TMP") private float[] _tmpOut = new float[32];
   
-  
-  private void compute_pcm_samples0(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples0(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;	
+      //final float[] vp = actual_v;  //subbed in variable name instead to reduce areas	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut; //subbed in variable name instread to reduce areas
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
-			{
-		float pcm_sample;
-		final float[] dp = d16[i];
-		pcm_sample = (float)(((vp[0 + dvp] * dp[0]) +
-			(vp[15 + dvp] * dp[1]) +
-			(vp[14 + dvp] * dp[2]) +
-			(vp[13 + dvp] * dp[3]) +
-			(vp[12 + dvp] * dp[4]) +
-			(vp[11 + dvp] * dp[5]) +
-			(vp[10 + dvp] * dp[6]) +
-			(vp[9 + dvp] * dp[7]) +
-			(vp[8 + dvp] * dp[8]) +
-			(vp[7 + dvp] * dp[9]) +
-			(vp[6 + dvp] * dp[10]) +
-			(vp[5 + dvp] * dp[11]) +
-			(vp[4 + dvp] * dp[12]) +
-			(vp[3 + dvp] * dp[13]) +
-			(vp[2 + dvp] * dp[14]) +
-			(vp[1 + dvp] * dp[15])
+	        for(@LOC("I") int i=0; i<32; i++)
+		{
+		@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+		//final float[] dp = d16[i]; //subbed in variable name instead to reduce areas
+		pcm_sample = (float)(((actual_v[0 + dvp] * d16[0]) +
+			(actual_v[15 + dvp] * d16[1]) +
+			(actual_v[14 + dvp] * d16[2]) +
+			(actual_v[13 + dvp] * d16[3]) +
+			(actual_v[12 + dvp] * d16[4]) +
+			(actual_v[11 + dvp] * d16[5]) +
+			(actual_v[10 + dvp] * d16[6]) +
+			(actual_v[9 + dvp] * d16[7]) +
+			(actual_v[8 + dvp] * d16[8]) +
+			(actual_v[7 + dvp] * d16[9]) +
+			(actual_v[6 + dvp] * d16[10]) +
+			(actual_v[5 + dvp] * d16[11]) +
+			(actual_v[4 + dvp] * d16[12]) +
+			(actual_v[3 + dvp] * d16[13]) +
+			(actual_v[2 + dvp] * d16[14]) +
+			(actual_v[1 + dvp] * d16[15])
 			) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 	} // for
   }
-  
-  private void compute_pcm_samples1(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples1(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;	
+      //final float[] vp = actual_v;	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[1 + dvp] * dp[0]) +
-					(vp[0 + dvp] * dp[1]) +
-					(vp[15 + dvp] * dp[2]) +
-					(vp[14 + dvp] * dp[3]) +
-					(vp[13 + dvp] * dp[4]) +
-					(vp[12 + dvp] * dp[5]) +
-					(vp[11 + dvp] * dp[6]) +
-					(vp[10 + dvp] * dp[7]) +
-					(vp[9 + dvp] * dp[8]) +
-					(vp[8 + dvp] * dp[9]) +
-					(vp[7 + dvp] * dp[10]) +
-					(vp[6 + dvp] * dp[11]) +
-					(vp[5 + dvp] * dp[12]) +
-					(vp[4 + dvp] * dp[13]) +
-					(vp[3 + dvp] * dp[14]) +
-					(vp[2 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[1 + dvp] * d16[0]) +
+						      (actual_v[0 + dvp] * d16[1]) +
+					(actual_v[15 + dvp] * d16[2]) +
+					(actual_v[14 + dvp] * d16[3]) +
+					(actual_v[13 + dvp] * d16[4]) +
+					(actual_v[12 + dvp] * d16[5]) +
+					(actual_v[11 + dvp] * d16[6]) +
+					(actual_v[10 + dvp] * d16[7]) +
+					(actual_v[9 + dvp] * d16[8]) +
+					(actual_v[8 + dvp] * d16[9]) +
+					(actual_v[7 + dvp] * d16[10]) +
+					(actual_v[6 + dvp] * d16[11]) +
+					(actual_v[5 + dvp] * d16[12]) +
+					(actual_v[4 + dvp] * d16[13]) +
+					(actual_v[3 + dvp] * d16[14]) +
+					(actual_v[2 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
-			
+            _tmpOut[i] = pcm_sample;
+			actual_v
 			dvp += 16;
          } // for
   }
-    private void compute_pcm_samples2(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples2(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[2 + dvp] * dp[0]) +
-					(vp[1 + dvp] * dp[1]) +
-					(vp[0 + dvp] * dp[2]) +
-					(vp[15 + dvp] * dp[3]) +
-					(vp[14 + dvp] * dp[4]) +
-					(vp[13 + dvp] * dp[5]) +
-					(vp[12 + dvp] * dp[6]) +
-					(vp[11 + dvp] * dp[7]) +
-					(vp[10 + dvp] * dp[8]) +
-					(vp[9 + dvp] * dp[9]) +
-					(vp[8 + dvp] * dp[10]) +
-					(vp[7 + dvp] * dp[11]) +
-					(vp[6 + dvp] * dp[12]) +
-					(vp[5 + dvp] * dp[13]) +
-					(vp[4 + dvp] * dp[14]) +
-					(vp[3 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[2 + dvp] * d16[0]) +
+					(actual_v[1 + dvp] * d16[1]) +
+					(actual_v[0 + dvp] * d16[2]) +
+					(actual_v[15 + dvp] * d16[3]) +
+					(actual_v[14 + dvp] * d16[4]) +
+					(actual_v[13 + dvp] * d16[5]) +
+					(actual_v[12 + dvp] * d16[6]) +
+					(actual_v[11 + dvp] * d16[7]) +
+					(actual_v[10 + dvp] * d16[8]) +
+					(actual_v[9 + dvp] * d16[9]) +
+					(actual_v[8 + dvp] * d16[10]) +
+					(actual_v[7 + dvp] * d16[11]) +
+					(actual_v[6 + dvp] * d16[12]) +
+					(actual_v[5 + dvp] * d16[13]) +
+					(actual_v[4 + dvp] * d16[14]) +
+					(actual_v[3 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
-	}
-	
-	  private void compute_pcm_samples3(Obuffer buffer)
+  }
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")	
+  private void compute_pcm_samples3(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	int idx = 0;
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[3 + dvp] * dp[0]) +
-					(vp[2 + dvp] * dp[1]) +
-					(vp[1 + dvp] * dp[2]) +
-					(vp[0 + dvp] * dp[3]) +
-					(vp[15 + dvp] * dp[4]) +
-					(vp[14 + dvp] * dp[5]) +
-					(vp[13 + dvp] * dp[6]) +
-					(vp[12 + dvp] * dp[7]) +
-					(vp[11 + dvp] * dp[8]) +
-					(vp[10 + dvp] * dp[9]) +
-					(vp[9 + dvp] * dp[10]) +
-					(vp[8 + dvp] * dp[11]) +
-					(vp[7 + dvp] * dp[12]) +
-					(vp[6 + dvp] * dp[13]) +
-					(vp[5 + dvp] * dp[14]) +
-					(vp[4 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[3 + dvp] * d16[0]) +
+					(actual_v[2 + dvp] * d16[1]) +
+					(actual_v[1 + dvp] * d16[2]) +
+					(actual_v[0 + dvp] * d16[3]) +
+					(actual_v[15 + dvp] * d16[4]) +
+					(actual_v[14 + dvp] * d16[5]) +
+					(actual_v[13 + dvp] * d16[6]) +
+					(actual_v[12 + dvp] * d16[7]) +
+					(actual_v[11 + dvp] * d16[8]) +
+					(actual_v[10 + dvp] * d16[9]) +
+					(actual_v[9 + dvp] * d16[10]) +
+					(actual_v[8 + dvp] * d16[11]) +
+					(actual_v[7 + dvp] * d16[12]) +
+					(actual_v[6 + dvp] * d16[13]) +
+					(actual_v[5 + dvp] * d16[14]) +
+					(actual_v[4 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
-	  }
-			
-  private void compute_pcm_samples4(Obuffer buffer)
+  }
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")			
+  private void compute_pcm_samples4(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[4 + dvp] * dp[0]) +
-					(vp[3 + dvp] * dp[1]) +
-					(vp[2 + dvp] * dp[2]) +
-					(vp[1 + dvp] * dp[3]) +
-					(vp[0 + dvp] * dp[4]) +
-					(vp[15 + dvp] * dp[5]) +
-					(vp[14 + dvp] * dp[6]) +
-					(vp[13 + dvp] * dp[7]) +
-					(vp[12 + dvp] * dp[8]) +
-					(vp[11 + dvp] * dp[9]) +
-					(vp[10 + dvp] * dp[10]) +
-					(vp[9 + dvp] * dp[11]) +
-					(vp[8 + dvp] * dp[12]) +
-					(vp[7 + dvp] * dp[13]) +
-					(vp[6 + dvp] * dp[14]) +
-					(vp[5 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[4 + dvp] * d16[0]) +
+					(actual_v[3 + dvp] * d16[1]) +
+					(actual_v[2 + dvp] * d16[2]) +
+					(actual_v[1 + dvp] * d16[3]) +
+					(actual_v[0 + dvp] * d16[4]) +
+					(actual_v[15 + dvp] * d16[5]) +
+					(actual_v[14 + dvp] * d16[6]) +
+					(actual_v[13 + dvp] * d16[7]) +
+					(actual_v[12 + dvp] * d16[8]) +
+					(actual_v[11 + dvp] * d16[9]) +
+					(actual_v[10 + dvp] * d16[10]) +@LOC("I")
+					(actual_v[9 + dvp] * d16[11]) +
+					(actual_v[8 + dvp] * d16[12]) +
+					(actual_v[7 + dvp] * d16[13]) +
+					(actual_v[6 + dvp] * d16[14]) +
+					(actual_v[5 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
   }
-  
-  private void compute_pcm_samples5(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples5(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[5 + dvp] * dp[0]) +
-					(vp[4 + dvp] * dp[1]) +
-					(vp[3 + dvp] * dp[2]) +
-					(vp[2 + dvp] * dp[3]) +
-					(vp[1 + dvp] * dp[4]) +
-					(vp[0 + dvp] * dp[5]) +
-					(vp[15 + dvp] * dp[6]) +
-					(vp[14 + dvp] * dp[7]) +
-					(vp[13 + dvp] * dp[8]) +
-					(vp[12 + dvp] * dp[9]) +
-					(vp[11 + dvp] * dp[10]) +
-					(vp[10 + dvp] * dp[11]) +
-					(vp[9 + dvp] * dp[12]) +
-					(vp[8 + dvp] * dp[13]) +
-					(vp[7 + dvp] * dp[14]) +
-					(vp[6 + dvp] * dp[15])
+			    //	final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[5 + dvp] * d16[0]) +
+					(actual_v[4 + dvp] * d16[1]) +
+					(actual_v[3 + dvp] * d16[2]) +
+					(actual_v[2 + dvp] * d16[3]) +
+					(actual_v[1 + dvp] * d16[4]) +
+					(actual_v[0 + dvp] * d16[5]) +
+					(actual_v[15 + dvp] * d16[6]) +
+					(actual_v[14 + dvp] * d16[7]) +
+					(actual_v[13 + dvp] * d16[8]) +
+					(actual_v[12 + dvp] * d16[9]) +
+					(actual_v[11 + dvp] * d16[10]) +
+					(actual_v[10 + dvp] * d16[11]) +
+					(actual_v[9 + dvp] * d16[12]) +
+					(actual_v[8 + dvp] * d16[13]) +
+					(actual_v[7 + dvp] * d16[14]) +
+					(actual_v[6 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
   }
-  
-  private void compute_pcm_samples6(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples6(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;	
+      //final float[] vp = actual_v;	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[6 + dvp] * dp[0]) +
-					(vp[5 + dvp] * dp[1]) +
-					(vp[4 + dvp] * dp[2]) +
-					(vp[3 + dvp] * dp[3]) +
-					(vp[2 + dvp] * dp[4]) +
-					(vp[1 + dvp] * dp[5]) +
-					(vp[0 + dvp] * dp[6]) +
-					(vp[15 + dvp] * dp[7]) +
-					(vp[14 + dvp] * dp[8]) +
-					(vp[13 + dvp] * dp[9]) +
-					(vp[12 + dvp] * dp[10]) +
-					(vp[11 + dvp] * dp[11]) +
-					(vp[10 + dvp] * dp[12]) +
-					(vp[9 + dvp] * dp[13]) +
-					(vp[8 + dvp] * dp[14]) +
-					(vp[7 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[6 + dvp] * d16[0]) +
+					(actual_v[5 + dvp] * d61[1]) +
+					(actual_v[4 + dvp] * d16[2]) +
+					(actual_v[3 + dvp] * d16[3]) +
+					(actual_v[2 + dvp] * d16[4]) +
+					(actual_v[1 + dvp] * d16[5]) +
+					(actual_v[0 + dvp] * d16[6]) +
+					(actual_v[15 + dvp] * d16[7]) +
+					(actual_v[14 + dvp] * d16[8]) +
+					(actual_v[13 + dvp] * d16[9]) +
+					(actual_v[12 + dvp] * d16[10]) +
+					(actual_v[11 + dvp] * d16[11]) +
+					(actual_v[10 + dvp] * d16[12]) +
+					(actual_v[9 + dvp] * d16[13]) +
+					(actual_v[8 + dvp] * d16[14]) +
+					(actual_v[7 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
   }
-  
-    private void compute_pcm_samples7(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples7(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[7 + dvp] * dp[0]) +
-					(vp[6 + dvp] * dp[1]) +
-					(vp[5 + dvp] * dp[2]) +
-					(vp[4 + dvp] * dp[3]) +
-					(vp[3 + dvp] * dp[4]) +
-					(vp[2 + dvp] * dp[5]) +
-					(vp[1 + dvp] * dp[6]) +
-					(vp[0 + dvp] * dp[7]) +
-					(vp[15 + dvp] * dp[8]) +
-					(vp[14 + dvp] * dp[9]) +
-					(vp[13 + dvp] * dp[10]) +
-					(vp[12 + dvp] * dp[11]) +
-					(vp[11 + dvp] * dp[12]) +
-					(vp[10 + dvp] * dp[13]) +
-					(vp[9 + dvp] * dp[14]) +
-					(vp[8 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[7 + dvp] * d16[0]) +
+					(actual_v[6 + dvp] * d16[1]) +
+					(actual_v[5 + dvp] * d16[2]) +
+					(actual_v[4 + dvp] * d16[3]) +
+					(actual_v[3 + dvp] * d16[4]) +
+					(actual_v[2 + dvp] * d16[5]) +
+					(actual_v[1 + dvp] * d16[6]) +
+					(actual_v[0 + dvp] * d16[7]) +
+					(actual_v[15 + dvp] * d16[8]) +
+					(actual_v[14 + dvp] * d16[9]) +
+					(actual_v[13 + dvp] * d16[10]) +
+					(actual_v[12 + dvp] * d16[11]) +
+					(actual_v[11 + dvp] * d16[12]) +
+					(actual_v[10 + dvp] * d16[13]) +
+					(actual_v[9 + dvp] * d16[14]) +
+					(actual_v[8 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
-	}
-  private void compute_pcm_samples8(Obuffer buffer)
+  }
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples8(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[8 + dvp] * dp[0]) +
-					(vp[7 + dvp] * dp[1]) +
-					(vp[6 + dvp] * dp[2]) +
-					(vp[5 + dvp] * dp[3]) +
-					(vp[4 + dvp] * dp[4]) +
-					(vp[3 + dvp] * dp[5]) +
-					(vp[2 + dvp] * dp[6]) +
-					(vp[1 + dvp] * dp[7]) +
-					(vp[0 + dvp] * dp[8]) +
-					(vp[15 + dvp] * dp[9]) +
-					(vp[14 + dvp] * dp[10]) +
-					(vp[13 + dvp] * dp[11]) +
-					(vp[12 + dvp] * dp[12]) +
-					(vp[11 + dvp] * dp[13]) +
-					(vp[10 + dvp] * dp[14]) +
-					(vp[9 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[8 + dvp] * d16[0]) +
+					(actual_v[7 + dvp] * d16[1]) +
+					(actual_v[6 + dvp] * d16[2]) +
+					(actual_v[5 + dvp] * d16[3]) +
+					(actual_v[4 + dvp] * d16[4]) +
+					(actual_v[3 + dvp] * d16[5]) +
+					(actual_v[2 + dvp] * d16[6]) +
+					(actual_v[1 + dvp] * d16[7]) +
+					(actual_v[0 + dvp] * d16[8]) +
+					(actual_v[15 + dvp] * d16[9]) +
+					(actual_v[14 + dvp] * d16[10]) +
+					(actual_v[13 + dvp] * d16[11]) +
+					(actual_v[12 + dvp] * d16[12]) +
+					(actual_v[11 + dvp] * d16[13]) +
+					(actual_v[10 + dvp] * d16[14]) +
+					(actual_v[9 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
   }
-  
-  private void compute_pcm_samples9(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples9(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[9 + dvp] * dp[0]) +
-					(vp[8 + dvp] * dp[1]) +
-					(vp[7 + dvp] * dp[2]) +
-					(vp[6 + dvp] * dp[3]) +
-					(vp[5 + dvp] * dp[4]) +
-					(vp[4 + dvp] * dp[5]) +
-					(vp[3 + dvp] * dp[6]) +
-					(vp[2 + dvp] * dp[7]) +
-					(vp[1 + dvp] * dp[8]) +
-					(vp[0 + dvp] * dp[9]) +
-					(vp[15 + dvp] * dp[10]) +
-					(vp[14 + dvp] * dp[11]) +
-					(vp[13 + dvp] * dp[12]) +
-					(vp[12 + dvp] * dp[13]) +
-					(vp[11 + dvp] * dp[14]) +
-					(vp[10 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[9 + dvp] * d16[0]) +
+					(actual_v[8 + dvp] * d16[1]) +
+					(actual_v[7 + dvp] * d16[2]) +
+					(actual_v[6 + dvp] * d16[3]) +
+					(actual_v[5 + dvp] * d16[4]) +
+					(actual_v[4 + dvp] * d16[5]) +
+					(actual_v[3 + dvp] * d16[6]) +
+					(actual_v[2 + dvp] * d16[7]) +
+					(actual_v[1 + dvp] * d16[8]) +
+					(actual_v[0 + dvp] * d16[9]) +
+					(actual_v[15 + dvp] * d16[10]) +
+					(actual_v[14 + dvp] * d16[11]) +
+					(actual_v[13 + dvp] * d16[12]) +
+					(actual_v[12 + dvp] * d16[13]) +
+					(actual_v[11 + dvp] * d16[14]) +
+					(actual_v[10 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
   }
-  
-  private void compute_pcm_samples10(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples10(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;	
+      //final float[] vp = actual_v;	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
 
 				pcm_sample = (float)(((vp[10 + dvp] * dp[0]) +
 					(vp[9 + dvp] * dp[1]) +
@@ -1267,36 +1336,37 @@ final class SynthesisFilter
 			dvp += 16;
 			} // for
   }
-  private void compute_pcm_samples11(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples11(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[11 + dvp] * dp[0]) +
-					(vp[10 + dvp] * dp[1]) +
-					(vp[9 + dvp] * dp[2]) +
-					(vp[8 + dvp] * dp[3]) +
-					(vp[7 + dvp] * dp[4]) +
-					(vp[6 + dvp] * dp[5]) +
-					(vp[5 + dvp] * dp[6]) +
-					(vp[4 + dvp] * dp[7]) +
-					(vp[3 + dvp] * dp[8]) +
-					(vp[2 + dvp] * dp[9]) +
-					(vp[1 + dvp] * dp[10]) +
-					(vp[0 + dvp] * dp[11]) +
-					(vp[15 + dvp] * dp[12]) +
-					(vp[14 + dvp] * dp[13]) +
-					(vp[13 + dvp] * dp[14]) +
-					(vp[12 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[11 + dvp] * d16[0]) +
+					(actual_v[10 + dvp] * d16[1]) +
+					(actual_v[9 + dvp] * d16[2]) +
+					(actual_v[8 + dvp] * d16[3]) +
+					(actual_v[7 + dvp] * d16[4]) +
+					(actual_v[6 + dvp] * d16[5]) +
+					(actual_v[5 + dvp] * d16[6]) +
+					(actual_v[4 + dvp] * d16[7]) +
+					(actual_v[3 + dvp] * d16[8]) +
+					(actual_v[2 + dvp] * d16[9]) +
+					(actual_v[1 + dvp] * d16[10]) +
+					(actual_v[0 + dvp] * d16[11]) +
+					(actual_v[15 + dvp] * d16[12]) +
+					(actual_v[14 + dvp] * d16[13]) +
+					(actual_v[13 + dvp] * d16[14]) +
+					(actual_v[12 + dvp] * d16[15])
 					) * scalefactor);
 
             tmpOut[i] = pcm_sample;
@@ -1304,153 +1374,157 @@ final class SynthesisFilter
 			dvp += 16;
 			} // for
   }
-    private void compute_pcm_samples12(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples12(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;	
+      //final float[] vp = actual_v;	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-			    final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[12 + dvp] * dp[0]) +
-					(vp[11 + dvp] * dp[1]) +
-					(vp[10 + dvp] * dp[2]) +
-					(vp[9 + dvp] * dp[3]) +
-					(vp[8 + dvp] * dp[4]) +
-					(vp[7 + dvp] * dp[5]) +
-					(vp[6 + dvp] * dp[6]) +
-					(vp[5 + dvp] * dp[7]) +
-					(vp[4 + dvp] * dp[8]) +
-					(vp[3 + dvp] * dp[9]) +
-					(vp[2 + dvp] * dp[10]) +
-					(vp[1 + dvp] * dp[11]) +
-					(vp[0 + dvp] * dp[12]) +
-					(vp[15 + dvp] * dp[13]) +
-					(vp[14 + dvp] * dp[14]) +
-					(vp[13 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[12 + dvp] * d16[0]) +
+					(actual_v[11 + dvp] * d16[1]) +
+					(actual_v[10 + dvp] * d16[2]) +
+					(actual_v[9 + dvp] * d16[3]) +
+					(actual_v[8 + dvp] * d16[4]) +
+					(actual_v[7 + dvp] * d16[5]) +
+					(actual_v[6 + dvp] * d16[6]) +
+					(actual_v[5 + dvp] * d16[7]) +
+					(actual_v[4 + dvp] * d16[8]) +
+					(actual_v[3 + dvp] * d16[9]) +
+					(actual_v[2 + dvp] * d16[10]) +
+					(actual_v[1 + dvp] * d16[11]) +
+					(actual_v[0 + dvp] * d16[12]) +
+					(actual_v[15 + dvp] * d16[13]) +
+					(actual_v[14 + dvp] * d16[14]) +
+					(actual_v[13 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
-	}
-  private void compute_pcm_samples13(Obuffer buffer)
+  }
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples13(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[13 + dvp] * dp[0]) +
-					(vp[12 + dvp] * dp[1]) +
-					(vp[11 + dvp] * dp[2]) +
-					(vp[10 + dvp] * dp[3]) +
-					(vp[9 + dvp] * dp[4]) +
-					(vp[8 + dvp] * dp[5]) +
-					(vp[7 + dvp] * dp[6]) +
-					(vp[6 + dvp] * dp[7]) +
-					(vp[5 + dvp] * dp[8]) +
-					(vp[4 + dvp] * dp[9]) +
-					(vp[3 + dvp] * dp[10]) +
-					(vp[2 + dvp] * dp[11]) +
-					(vp[1 + dvp] * dp[12]) +
-					(vp[0 + dvp] * dp[13]) +
-					(vp[15 + dvp] * dp[14]) +
-					(vp[14 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[13 + dvp] * d16[0]) +
+					(actual_v[12 + dvp] * d16[1]) +
+					(actual_v[11 + dvp] * d16[2]) +
+					(actual_v[10 + dvp] * d16[3]) +
+					(actual_v[9 + dvp] * d16[4]) +
+					(actual_v[8 + dvp] * d16[5]) +
+					(actual_v[7 + dvp] * d16[6]) +
+					(actual_v[6 + dvp] * d16[7]) +
+					(actual_v[5 + dvp] * d16[8]) +
+					(actual_v[4 + dvp] * d16[9]) +
+					(actual_v[3 + dvp] * d16[10]) +
+					(actual_v[2 + dvp] * d16[11]) +
+					(actual_v[1 + dvp] * d16[12]) +
+					(actual_v[0 + dvp] * d16[13]) +
+					(actual_v[15 + dvp] * d16[14]) +
+					(actual_v[14 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
   }
-  private void compute_pcm_samples14(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples14(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 	
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+	 @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				final float[] dp = d16[i];
-				float pcm_sample;
-
-				pcm_sample = (float)(((vp[14 + dvp] * dp[0]) +
-					(vp[13 + dvp] * dp[1]) +
-					(vp[12 + dvp] * dp[2]) +
-					(vp[11 + dvp] * dp[3]) +
-					(vp[10 + dvp] * dp[4]) +
-					(vp[9 + dvp] * dp[5]) +
-					(vp[8 + dvp] * dp[6]) +
-					(vp[7 + dvp] * dp[7]) +
-					(vp[6 + dvp] * dp[8]) +
-					(vp[5 + dvp] * dp[9]) +
-					(vp[4 + dvp] * dp[10]) +
-					(vp[3 + dvp] * dp[11]) +
-					(vp[2 + dvp] * dp[12]) +
-					(vp[1 + dvp] * dp[13]) +
-					(vp[0 + dvp] * dp[14]) +
-					(vp[15 + dvp] * dp[15])
+			    //final float[] dp = d16[i];
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+
+				pcm_sample = (float)(((actual_v[14 + dvp] * d16[0]) +
+					(actual_v[13 + dvp] * d16[1]) +
+					(actual_v[12 + dvp] * d16[2]) +
+					(actual_v[11 + dvp] * d16[3]) +
+					(actual_v[10 + dvp] * d16[4]) +
+					(actual_v[9 + dvp] * d16[5]) +
+					(actual_v[8 + dvp] * d16[6]) +
+					(actual_v[7 + dvp] * d16[7]) +
+					(actual_v[6 + dvp] * d16[8]) +
+					(actual_v[5 + dvp] * d16[9]) +
+					(actual_v[4 + dvp] * d16[10]) +
+					(actual_v[3 + dvp] * d16[11]) +
+					(actual_v[2 + dvp] * d16[12]) +
+					(actual_v[1 + dvp] * d16[13]) +
+					(actual_v[0 + dvp] * d16[14]) +
+					(actual_v[15 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;
+            _tmpOut[i] = pcm_sample;
 			
 			dvp += 16;
 			} // for
   }
-  private void compute_pcm_samples15(Obuffer buffer)
+  @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")
+  private void compute_pcm_samples15(@LOC("THIS") Obuffer buffer)
   {
-	final float[] vp = actual_v;
+      //final float[] vp = actual_v;
 		
 	//int inc = v_inc;
-	final float[] tmpOut = _tmpOut;
-	 int dvp =0;
+	//final float[] tmpOut = _tmpOut;
+      @LOC("DVP") int dvp =0;
 	
 			// fat chance of having this loop unroll
-			for( int i=0; i<32; i++)
+			for(@LOC("I") int i=0; i<32; i++)
 			{
-				float pcm_sample;
-				final float dp[] = d16[i];
-				pcm_sample = (float)(((vp[15 + dvp] * dp[0]) +
-					(vp[14 + dvp] * dp[1]) +
-					(vp[13 + dvp] * dp[2]) +
-					(vp[12 + dvp] * dp[3]) +
-					(vp[11 + dvp] * dp[4]) +
-					(vp[10 + dvp] * dp[5]) +
-					(vp[9 + dvp] * dp[6]) +
-					(vp[8 + dvp] * dp[7]) +
-					(vp[7 + dvp] * dp[8]) +
-					(vp[6 + dvp] * dp[9]) +
-					(vp[5 + dvp] * dp[10]) +
-					(vp[4 + dvp] * dp[11]) +
-					(vp[3 + dvp] * dp[12]) +
-					(vp[2 + dvp] * dp[13]) +
-					(vp[1 + dvp] * dp[14]) +
-					(vp[0 + dvp] * dp[15])
+				@LOC("THIS,SynthesisFilter.PCM") float pcm_sample;
+				//final float dp[] = d16[i];
+				pcm_sample = (float)(((vp[15 + dvp] * d16[0]) +
+					(actual_v[14 + dvp] * d16[1]) +
+					(actual_v[13 + dvp] * d16[2]) +
+					(actual_v[12 + dvp] * d16[3]) +
+					(actual_v[11 + dvp] * d16[4]) +
+					(actual_v[10 + dvp] * d16[5]) +
+					(actual_v[9 + dvp] * d16[6]) +
+					(actual_v[8 + dvp] * d16[7]) +
+					(actual_v[7 + dvp] * d16[8]) +
+					(actual_v[6 + dvp] * d16[9]) +
+					(actual_v[5 + dvp] * d16[10]) +
+					(actual_v[4 + dvp] * d16[11]) +
+					(actual_v[3 + dvp] * d16[12]) +
+					(actual_v[2 + dvp] * d16[13]) +
+					(actual_v[1 + dvp] * d16[14]) +
+					(actual_v[0 + dvp] * d16[15])
 					) * scalefactor);
 
-            tmpOut[i] = pcm_sample;			
+            _tmpOut[i] = pcm_sample;			
 			dvp += 16;
 			} // for
 		}
 	 	 	 	 
-private void compute_pcm_samples(Obuffer buffer)
+private void compute_pcm_samples(@LOC("GLOBAL") Obuffer buffer)
 {
 	
 	switch (actual_write_pos)
@@ -1543,8 +1617,9 @@ private void compute_pcm_samples(Obuffer buffer)
   /**
    * Calculate 32 PCM samples and put the into the Obuffer-object.
    */
-	
-  public void calculate_pcm_samples(Obuffer buffer)
+  
+  @LATTICE("V<THIS,THIS<SH,SH*,THISLOC=THIS")	
+  public void calculate_pcm_samples(@LOC("V") Obuffer buffer)
   {
 	compute_new_v();	
 	compute_pcm_samples(buffer);
@@ -1558,56 +1633,56 @@ private void compute_pcm_samples(Obuffer buffer)
 	
 	// MDM: this may not be necessary. The Layer III decoder always
 	// outputs 32 subband samples, but I haven't checked layer I & II.
-	for (int p=0;p<32;p++) 
+	for (@LOC("SH") int p=0;p<32;p++) 
 		samples[p] = 0.0f;
   }
   
   
-  private static final double MY_PI = 3.14159265358979323846;
-  private static final float cos1_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 64.0)));
-  private static final float cos3_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 64.0)));
-  private static final float cos5_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 64.0)));
-  private static final float cos7_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 64.0)));
-  private static final float cos9_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0  / 64.0)));
-  private static final float cos11_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));
-  private static final float cos13_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));
-  private static final float cos15_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));
-  private static final float cos17_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));
-  private static final float cos19_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));
-  private static final float cos21_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));
-  private static final float cos23_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));
-  private static final float cos25_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));
-  private static final float cos27_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));
-  private static final float cos29_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));
-  private static final float cos31_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));
-  private static final float cos1_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 32.0)));
-  private static final float cos3_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 32.0)));
-  private static final float cos5_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 32.0)));
-  private static final float cos7_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 32.0)));
-  private static final float cos9_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0  / 32.0)));
-  private static final float cos11_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));
-  private static final float cos13_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));
-  private static final float cos15_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));
-  private static final float cos1_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 16.0)));
-  private static final float cos3_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 16.0)));
-  private static final float cos5_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 16.0)));
-  private static final float cos7_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 16.0)));
-  private static final float cos1_8   =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 8.0)));
-  private static final float cos3_8   =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 8.0)));
-  private static final float cos1_4   =(float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));
+  @LOC("EQ") private static final double MY_PI = 3.14159265358979323846;
+  @LOC("SA") private static final float cos1_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 64.0)));
+  @LOC("SA") private static final float cos3_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 64.0)));
+  @LOC("SA") private static final float cos5_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 64.0)));
+  @LOC("SA") private static final float cos7_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 64.0)));
+  @LOC("SA") private static final float cos9_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0  / 64.0)));
+  @LOC("SA") private static final float cos11_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));
+  @LOC("SA") private static final float cos13_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));
+  @LOC("SA") private static final float cos15_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));
+  @LOC("SA") private static final float cos17_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));
+  @LOC("SA") private static final float cos19_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));
+  @LOC("SA") private static final float cos21_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));
+  @LOC("SA") private static final float cos23_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));
+  @LOC("SA") private static final float cos25_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));
+  @LOC("SA") private static final float cos27_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));
+  @LOC("SA") private static final float cos29_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));
+  @LOC("SA") private static final float cos31_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));
+  @LOC("SA") private static final float cos1_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 32.0)));
+  @LOC("SA") private static final float cos3_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 32.0)));
+  @LOC("SA") private static final float cos5_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 32.0)));
+  @LOC("SA") private static final float cos7_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 32.0)));
+  @LOC("SA") private static final float cos9_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0  / 32.0)));
+  @LOC("SA") private static final float cos11_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));
+  @LOC("SA") private static final float cos13_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));
+  @LOC("SA") private static final float cos15_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));
+  @LOC("SA") private static final float cos1_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 16.0)));
+  @LOC("SA") private static final float cos3_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 16.0)));
+  @LOC("SA") private static final float cos5_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 16.0)));
+  @LOC("SA") private static final float cos7_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 16.0)));
+  @LOC("SA") private static final float cos1_8   =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 8.0)));
+  @LOC("SA") private static final float cos3_8   =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 8.0)));
+  @LOC("SA") private static final float cos1_4   =(float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));
   
   // Note: These values are not in the same order
   // as in Annex 3-B.3 of the ISO/IEC DIS 11172-3 
   // private float d[] = {0.000000000, -4.000442505};
   
-  private static float d[] = null;
+  @LOC("V2") private static float d[] = null;
   
   /** 
    * d[] split into subarrays of length 16. This provides for
    * more faster access by allowing a block of 16 to be addressed
    * with constant offset. 
    **/
-  private static float d16[][] = null;	
+  @LOC("V2") private static float d16[][] = null;	
   
   /**
    * Loads the data for the d[] from the resource SFd.ser. 
diff --git a/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java b/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java
index d64d1f25..17b665a8 100644
--- a/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java
+++ b/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java
@@ -41,60 +41,62 @@
 /**
  * Class to implements Huffman decoder.
  */
+@LATTICE("FIELD<FINAL")
+@METHODDEFAULT("OUT<V,V<SH,SH<IN,SH*,THISLOC=IN,GLOBALLOC=IN");
 final class huffcodetab
 {
-  private static final int	 MXOFF=250;
-  private static final int	 HTN=34;
+  @LOC("FINAL") private static final int	 MXOFF=250;
+  @LOC("FINAL") private static final int	 HTN=34;
   
-  private char				 tablename0 = ' ';      /* string, containing table_description   */
-  private char				 tablename1 = ' ';      /* string, containing table_description   */
-  private char				 tablename2 = ' ';      /* string, containing table_description   */
+  @LOC("FIELD") private char				 tablename0 = ' ';      /* string, containing table_description   */
+  @LOC("FIELD") private char				 tablename1 = ' ';      /* string, containing table_description   */
+  @LOC("FIELD") private char				 tablename2 = ' ';      /* string, containing table_description   */
   
-  private int				 xlen; 			        /* max. x-index+                          */
-  private int				 ylen;	                /* max. y-index+				          */
-  private int				 linbits; 		        /* number of linbits   	                  */
-  private int 				 linmax;		        /* max number to be stored in linbits	  */
-  private int				 ref;			        /* a positive value indicates a reference */
-  private int[]				 table=null;	        /* pointer to array[xlen][ylen]		      */
-  private int[]   			 hlen=null;             /* pointer to array[xlen][ylen]		      */
-  private int[][]			 val=null;		        /* decoder tree		    	              */
-  private int 				 treelen;	            /* length of decoder tree  	              */
+  @LOC("FIELD") private int				 xlen; 			        /* max. x-index+                          */
+  @LOC("FIELD") private int				 ylen;	                /* max. y-index+				          */
+  @LOC("FIELD") private int				 linbits; 		        /* number of linbits   	                  */
+  @LOC("FIELD") private int 				 linmax;		        /* max number to be stored in linbits	  */
+  @LOC("FIELD") private int				 ref;			        /* a positive value indicates a reference */
+  @LOC("FIELD") private int[]				 table=null;	        /* pointer to array[xlen][ylen]		      */
+  @LOC("FIELD") private int[]   			 hlen=null;             /* pointer to array[xlen][ylen]		      */
+  @LOC("FIELD") private int[][]			 val=null;		        /* decoder tree		    	              */
+  @LOC("FIELD") private int 				 treelen;	            /* length of decoder tree  	              */
 
-  private static int ValTab0[][] = {
+  @LOC("FINAL") private static int ValTab0[][] = {
 	{0,0}	// dummy
 	};
 
-  private static int ValTab1[][] = {
+  @LOC("FINAL") private static int ValTab1[][] = {
 	{2,1},{0,0},{2,1},{0,16},{2,1},{0,1},{0,17},
 	};
 	
-  private static int ValTab2[][] = {
+  @LOC("FINAL") private static int ValTab2[][] = {
 	{2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{2,1},{0,17},{4,1},{2,1},
 	{0,32},{0,33},{2,1},{0,18},{2,1},{0,2},{0,34},
 	};
 	
-  private static int ValTab3[][] = {
+  @LOC("FINAL") private static int ValTab3[][] = {
 	{4,1},{2,1},{0,0},{0,1},{2,1},{0,17},{2,1},{0,16},{4,1},{2,1},
 	{0,32},{0,33},{2,1},{0,18},{2,1},{0,2},{0,34},
 	};
 
-  private static int ValTab4[][] = {{0,0}};	// dummy
+  @LOC("FINAL") private static int ValTab4[][] = {{0,0}};	// dummy
 
-  private static int ValTab5[][] = {
+  @LOC("FINAL") private static int ValTab5[][] = {
 	{2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{2,1},{0,17},{8,1},{4,1},
 	{2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{8,1},{4,1},{2,1},{0,34},
 	{0,48},{2,1},{0,3},{0,19},{2,1},{0,49},{2,1},{0,50},{2,1},{0,35},
 	{0,51},
 	};
 
-  private static int ValTab6[][] = {
+  @LOC("FINAL") private static int ValTab6[][] = {
 	{6,1},{4,1},{2,1},{0,0},{0,16},{0,17},{6,1},{2,1},{0,1},{2,1},
 	{0,32},{0,33},{6,1},{2,1},{0,18},{2,1},{0,2},{0,34},{4,1},{2,1},
 	{0,49},{0,19},{4,1},{2,1},{0,48},{0,50},{2,1},{0,35},{2,1},{0,3},
 	{0,51},
 	};
 	
-  private static int ValTab7[][] = {
+  @LOC("FINAL") private static int ValTab7[][] = {
 	{2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{8,1},{2,1},{0,17},{4,1},
 	{2,1},{0,32},{0,2},{0,33},{18,1},{6,1},{2,1},{0,18},{2,1},{0,34},
 	{0,48},{4,1},{2,1},{0,49},{0,19},{4,1},{2,1},{0,3},{0,50},{2,1},
@@ -105,7 +107,7 @@ final class huffcodetab
 	{0,85},
 	};
 	
-  private static int ValTab8[][] = {
+  @LOC("FINAL") private static int ValTab8[][] = {
 	{6,1},{2,1},{0,0},{2,1},{0,16},{0,1},{2,1},{0,17},{4,1},{2,1},
 	{0,33},{0,18},{14,1},{4,1},{2,1},{0,32},{0,2},{2,1},{0,34},{4,1},
 	{2,1},{0,48},{0,3},{2,1},{0,49},{0,19},{14,1},{8,1},{4,1},{2,1},
@@ -116,7 +118,7 @@ final class huffcodetab
 	{0,85},
 	};
 	
-  private static int ValTab9[][] = {
+  @LOC("FINAL") private static int ValTab9[][] = {
 	{8,1},{4,1},{2,1},{0,0},{0,16},{2,1},{0,1},{0,17},{10,1},{4,1},
 	{2,1},{0,32},{0,33},{2,1},{0,18},{2,1},{0,2},{0,34},{12,1},{6,1},
 	{4,1},{2,1},{0,48},{0,3},{0,49},{2,1},{0,19},{2,1},{0,50},{0,35},
@@ -127,7 +129,7 @@ final class huffcodetab
 	{0,85},
 	};
 	
-  private static int ValTab10[][] = {
+  @LOC("FINAL") private static int ValTab10[][] = {
 	{2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{10,1},{2,1},{0,17},{4,1},
 	{2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{28,1},{8,1},{4,1},{2,1},
 	{0,34},{0,48},{2,1},{0,49},{0,19},{8,1},{4,1},{2,1},{0,3},{0,50},
@@ -143,7 +145,7 @@ final class huffcodetab
 	{4,1},{2,1},{0,87},{0,118},{2,1},{0,103},{0,119},
 	};
 
-  private static int ValTab11[][] = {
+  @LOC("FINAL") private static int ValTab11[][] = {
 	{6,1},{2,1},{0,0},{2,1},{0,16},{0,1},{8,1},{2,1},{0,17},{4,1},
 	{2,1},{0,32},{0,2},{0,18},{24,1},{8,1},{2,1},{0,33},{2,1},{0,34},
 	{2,1},{0,48},{0,3},{4,1},{2,1},{0,49},{0,19},{4,1},{2,1},{0,50},
@@ -159,7 +161,7 @@ final class huffcodetab
 	{4,1},{2,1},{0,117},{0,118},{2,1},{0,103},{0,119},
 	};
 
-  private static int ValTab12[][] = {
+  @LOC("FINAL") private static int ValTab12[][] = {
 	{12,1},{4,1},{2,1},{0,16},{0,1},{2,1},{0,17},{2,1},{0,0},{2,1},
 	{0,32},{0,2},{16,1},{4,1},{2,1},{0,33},{0,18},{4,1},{2,1},{0,34},
 	{0,49},{2,1},{0,19},{2,1},{0,48},{2,1},{0,3},{0,64},{26,1},{8,1},
@@ -175,7 +177,7 @@ final class huffcodetab
 	{0,117},{0,87},{2,1},{0,118},{2,1},{0,103},{0,119},
 	};
 
-  private static int ValTab13[][] = {
+  @LOC("FINAL") private static int ValTab13[][] = {
 	{2,1},{0,0},{6,1},{2,1},{0,16},{2,1},{0,1},{0,17},{28,1},{8,1},
 	{4,1},{2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{8,1},{4,1},{2,1},
 	{0,34},{0,48},{2,1},{0,3},{0,49},{6,1},{2,1},{0,19},{2,1},{0,50},
@@ -230,11 +232,11 @@ final class huffcodetab
 	{0,254},
 	};
 
-  private static int ValTab14[][] = {
+  @LOC("FINAL") private static int ValTab14[][] = {
 	{0,0}  // dummy
 	};
 
-  private static int ValTab15[][] = {
+  @LOC("FINAL") private static int ValTab15[][] = {
 	{16,1},{6,1},{2,1},{0,0},{2,1},{0,16},{0,1},{2,1},{0,17},{4,1},
 	{2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{50,1},{16,1},{6,1},{2,1},
 	{0,34},{2,1},{0,48},{0,49},{6,1},{2,1},{0,19},{2,1},{0,3},{0,64},
@@ -289,7 +291,7 @@ final class huffcodetab
 	{0,255},
 	};
 
-  private static int  ValTab16[][] = {
+  @LOC("FINAL") private static int  ValTab16[][] = {
 	{2,1},{0,0},{6,1},{2,1},{0,16},{2,1},{0,1},{0,17},{42,1},{8,1},
 	{4,1},{2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{10,1},{6,1},{2,1},
 	{0,34},{2,1},{0,48},{0,3},{2,1},{0,49},{0,19},{10,1},{4,1},{2,1},
@@ -344,7 +346,7 @@ final class huffcodetab
 	{0,239},
 	};
 	
-  private static int ValTab24[][] = {
+  @LOC("FINAL") private static int ValTab24[][] = {
 	{60,1},{8,1},{4,1},{2,1},{0,0},{0,16},{2,1},{0,1},{0,17},{14,1},
 	{6,1},{4,1},{2,1},{0,32},{0,2},{0,33},{2,1},{0,18},{2,1},{0,34},
 	{2,1},{0,48},{0,3},{14,1},{4,1},{2,1},{0,49},{0,19},{4,1},{2,1},
@@ -399,14 +401,14 @@ final class huffcodetab
 	{0,254},{0,239},
 	};
 	
-  private static int ValTab32[][] = {
+  @LOC("FINAL") private static int ValTab32[][] = {
 	{2,1},{0,0},{8,1},{4,1},{2,1},{0,8},{0,4},{2,1},{0,1},{0,2},
 	{8,1},{4,1},{2,1},{0,12},{0,10},{2,1},{0,3},{0,6},{6,1},{2,1},
 	{0,9},{2,1},{0,5},{0,7},{4,1},{2,1},{0,14},{0,13},{2,1},{0,15},
 	{0,11},
 	};
 
-  private static int ValTab33[][] = {
+  @LOC("FINAL") private static int ValTab33[][] = {
 	{16,1},{8,1},{4,1},{2,1},{0,0},{0,1},{2,1},{0,2},{0,3},{4,1},
 	{2,1},{0,4},{0,5},{2,1},{0,6},{0,7},{8,1},{4,1},{2,1},{0,8},
 	{0,9},{2,1},{0,10},{0,11},{4,1},{2,1},{0,12},{0,13},{2,1},{0,14},
@@ -414,15 +416,16 @@ final class huffcodetab
 	};
 
 
-  public static huffcodetab[]  ht = null;     /* Simulate extern struct                 */
+  @LOC("FINAL") public static huffcodetab[]  ht = null;     /* Simulate extern struct                 */
 
-  private static int[] bitbuf = new int[32];
+  @LOC("FINAL") private static int[] bitbuf = new int[32];
   
   /**
    * Big Constructor : Computes all Huffman Tables.
    */
-  private huffcodetab(String S,int XLEN, int YLEN, int LINBITS, int LINMAX, int REF,
-                     int[] TABLE, int[] HLEN, int[][] VAL, int TREELEN)                     
+  private huffcodetab(@LOC("V") String S,@LOC("V") int XLEN, @LOC("V") int YLEN, @LOC("V") int LINBITS,
+		      @LOC("V") int LINMAX, @LOC("V") int REF,@LOC("V") int[] TABLE, @LOC("V") int[] HLEN, 
+                      @LOC("V") int[][] VAL, @LOC("V") int TREELEN)                     
   {
     tablename0 = S.charAt(0);
 	tablename1 = S.charAt(1);
@@ -433,8 +436,11 @@ final class huffcodetab
     linmax = LINMAX;
     ref = REF;
     table = TABLE;
+    TABLE = null;
     hlen = HLEN;
+    HLEN = null;
     val = VAL;
+    VAL = null;
     treelen = TREELEN;
   }
 
@@ -445,25 +451,28 @@ final class huffcodetab
    * note! for counta,countb -the 4 bit value is returned in y,
    * discard x.
    */
-  public static int huffman_decoder(huffcodetab h, int[] x, int[] y, int[] v, int[] w, BitReserve br)
+  @LATTICE("X<Y,V<Y,W<Y,Y<VAR,VAR<IN,OUT<IN,VAR*,Y*,X*,V*,W*,THISLOC=IN,GLOBALLOC=IN")
+  @RETURNLOC("OUT")
+  public static int huffman_decoder(@LOC("IN") huffcodetab h, @LOC("X") int[] x, @LOC("Y") int[] y, @LOC("V") int[] v, @LOC("W") int[] w, @LOC("IN") BitReserve br)
   {
 	// array of all huffcodtable headers
 	// 0..31 Huffman code table 0..31
 	// 32,33 count1-tables
 
-	int dmask = 1 << ((4 * 8) - 1);
-	int hs    = 4 * 8;
-  	int level;
-  	int point = 0;
-  	int error = 1;
+        @LOC("IN") int dmask = 1 << ((4 * 8) - 1);
+	@LOC("IN") int hs    = 4 * 8;
+  	@LOC("VAR") int level;
+  	@LOC("VAR") int point = 0;
+  	@LOC("OUT") int error = 1;
   	level = dmask;
 
   	if (h.val == null) return 2;
 
      /* table 0 needs no bits */
      if ( h.treelen == 0)
-	 { 
-	   x[0] = y[0] = 0;
+	 {   
+	   y[0] = 0;
+	   x[0] = 0;
 	   return 0;
      }
 
@@ -476,7 +485,7 @@ final class huffcodetab
    	 do 
 	 {
 	    if (h.val[point][0]==0)
-		{   /*end of tree*/
+	    {   /*end of tree*/
 		   x[0] = h.val[point][1] >>> 4;
 		   y[0] = h.val[point][1] & 0xf;
 		   error = 0;
@@ -533,7 +542,7 @@ final class huffcodetab
 		  if (br.hget1bit() != 0) x[0] = -x[0];
 	  	if (y[0]!=0)
 		  if (br.hget1bit() != 0) y[0] = -y[0];
-       }
+           }
 	   else
 	   {
 		  // Process sign and escape encodings for dual tables.
@@ -560,7 +569,7 @@ final class huffcodetab
 	if (ht!=null)
 		return;
 	
-	ht = new huffcodetab[HTN];
+    ht = new huffcodetab[HTN];
     ht[0] = new huffcodetab("0  ",0,0,0,0,-1,null,null,ValTab0,0);
     ht[1] = new huffcodetab("1  ",2,2,0,0,-1,null,null,ValTab1,7);
     ht[2] = new huffcodetab("2  ",3,3,0,0,-1,null,null,ValTab2,17);
@@ -589,7 +598,7 @@ final class huffcodetab
     ht[25] = new huffcodetab("25 ",16,16,5,31,24,null,null,ValTab24,512);
     ht[26] = new huffcodetab("26 ",16,16,6,63,24,null,null,ValTab24,512);
     ht[27] = new huffcodetab("27 ",16,16,7,127,24,null,null,ValTab24,512);
-	ht[28] = new huffcodetab("28 ",16,16,8,255,24,null,null,ValTab24,512);  
+    ht[28] = new huffcodetab("28 ",16,16,8,255,24,null,null,ValTab24,512);  
     ht[29] = new huffcodetab("29 ",16,16,9,511,24,null,null,ValTab24,512);
     ht[30] = new huffcodetab("30 ",16,16,11,2047,24,null,null,ValTab24,512);
     ht[31] = new huffcodetab("31 ",16,16,13,8191,24,null,null,ValTab24,512);
-- 
2.34.1