adding more annotations for mp3decoder
[IRC.git] / Robust / src / Tests / ssJava / mp3decoder / SynthesisFilter.java
index 2fd98ff68541a9bb9a9930bf375f9a71090a7098..dab977a3ef42ba693b788f3eada1781af65a66e4 100644 (file)
@@ -159,7 +159,7 @@ final class SynthesisFilter
          samples[subbandnumber] = eq[subbandnumber]*sample;\r
   }\r
 \r
-  public void input_samples(float[] s)\r
+  public void input_samples(@LOC("V") float[] s)\r
   {\r
          for (int i=31; i>=0; i--)\r
          {             \r
@@ -935,22 +935,22 @@ final class SynthesisFilter
                {\r
                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
                //final float[] dp = d16[i]; //subbed in variable name instead to reduce areas\r
-               pcm_sample = (float)(((actual_v[0 + dvp] * d16[0]) +\r
-                       (actual_v[15 + dvp] * d16[1]) +\r
-                       (actual_v[14 + dvp] * d16[2]) +\r
-                       (actual_v[13 + dvp] * d16[3]) +\r
-                       (actual_v[12 + dvp] * d16[4]) +\r
-                       (actual_v[11 + dvp] * d16[5]) +\r
-                       (actual_v[10 + dvp] * d16[6]) +\r
-                       (actual_v[9 + dvp] * d16[7]) +\r
-                       (actual_v[8 + dvp] * d16[8]) +\r
-                       (actual_v[7 + dvp] * d16[9]) +\r
-                       (actual_v[6 + dvp] * d16[10]) +\r
-                       (actual_v[5 + dvp] * d16[11]) +\r
-                       (actual_v[4 + dvp] * d16[12]) +\r
-                       (actual_v[3 + dvp] * d16[13]) +\r
-                       (actual_v[2 + dvp] * d16[14]) +\r
-                       (actual_v[1 + dvp] * d16[15])\r
+               pcm_sample = (float)(((actual_v[0 + dvp] * d16[i][0]) +\r
+                       (actual_v[15 + dvp] * d16[i][1]) +\r
+                       (actual_v[14 + dvp] * d16[i][2]) +\r
+                       (actual_v[13 + dvp] * d16[i][3]) +\r
+                       (actual_v[12 + dvp] * d16[i][4]) +\r
+                       (actual_v[11 + dvp] * d16[i][5]) +\r
+                       (actual_v[10 + dvp] * d16[i][6]) +\r
+                       (actual_v[9 + dvp] * d16[i][7]) +\r
+                       (actual_v[8 + dvp] * d16[i][8]) +\r
+                       (actual_v[7 + dvp] * d16[i][9]) +\r
+                       (actual_v[6 + dvp] * d16[i][10]) +\r
+                       (actual_v[5 + dvp] * d16[i][11]) +\r
+                       (actual_v[4 + dvp] * d16[i][12]) +\r
+                       (actual_v[3 + dvp] * d16[i][13]) +\r
+                       (actual_v[2 + dvp] * d16[i][14]) +\r
+                       (actual_v[1 + dvp] * d16[i][15])\r
                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -972,26 +972,26 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[1 + dvp] * d16[0]) +\r
-                                                     (actual_v[0 + dvp] * d16[1]) +\r
-                                       (actual_v[15 + dvp] * d16[2]) +\r
-                                       (actual_v[14 + dvp] * d16[3]) +\r
-                                       (actual_v[13 + dvp] * d16[4]) +\r
-                                       (actual_v[12 + dvp] * d16[5]) +\r
-                                       (actual_v[11 + dvp] * d16[6]) +\r
-                                       (actual_v[10 + dvp] * d16[7]) +\r
-                                       (actual_v[9 + dvp] * d16[8]) +\r
-                                       (actual_v[8 + dvp] * d16[9]) +\r
-                                       (actual_v[7 + dvp] * d16[10]) +\r
-                                       (actual_v[6 + dvp] * d16[11]) +\r
-                                       (actual_v[5 + dvp] * d16[12]) +\r
-                                       (actual_v[4 + dvp] * d16[13]) +\r
-                                       (actual_v[3 + dvp] * d16[14]) +\r
-                                       (actual_v[2 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[1 + dvp] * d16[i][0]) +\r
+                                                     (actual_v[0 + dvp] * d16[i][1]) +\r
+                                       (actual_v[15 + dvp] * d16[i][2]) +\r
+                                       (actual_v[14 + dvp] * d16[i][3]) +\r
+                                       (actual_v[13 + dvp] * d16[i][4]) +\r
+                                       (actual_v[12 + dvp] * d16[i][5]) +\r
+                                       (actual_v[11 + dvp] * d16[i][6]) +\r
+                                       (actual_v[10 + dvp] * d16[i][7]) +\r
+                                       (actual_v[9 + dvp] * d16[i][8]) +\r
+                                       (actual_v[8 + dvp] * d16[i][9]) +\r
+                                       (actual_v[7 + dvp] * d16[i][10]) +\r
+                                       (actual_v[6 + dvp] * d16[i][11]) +\r
+                                       (actual_v[5 + dvp] * d16[i][12]) +\r
+                                       (actual_v[4 + dvp] * d16[i][13]) +\r
+                                       (actual_v[3 + dvp] * d16[i][14]) +\r
+                                       (actual_v[2 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
-                       actual_v\r
+//                     actual_v\r
                        dvp += 16;\r
          } // for\r
   }\r
@@ -1010,22 +1010,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[2 + dvp] * d16[0]) +\r
-                                       (actual_v[1 + dvp] * d16[1]) +\r
-                                       (actual_v[0 + dvp] * d16[2]) +\r
-                                       (actual_v[15 + dvp] * d16[3]) +\r
-                                       (actual_v[14 + dvp] * d16[4]) +\r
-                                       (actual_v[13 + dvp] * d16[5]) +\r
-                                       (actual_v[12 + dvp] * d16[6]) +\r
-                                       (actual_v[11 + dvp] * d16[7]) +\r
-                                       (actual_v[10 + dvp] * d16[8]) +\r
-                                       (actual_v[9 + dvp] * d16[9]) +\r
-                                       (actual_v[8 + dvp] * d16[10]) +\r
-                                       (actual_v[7 + dvp] * d16[11]) +\r
-                                       (actual_v[6 + dvp] * d16[12]) +\r
-                                       (actual_v[5 + dvp] * d16[13]) +\r
-                                       (actual_v[4 + dvp] * d16[14]) +\r
-                                       (actual_v[3 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[2 + dvp] * d16[i][0]) +\r
+                                       (actual_v[1 + dvp] * d16[i][1]) +\r
+                                       (actual_v[0 + dvp] * d16[i][2]) +\r
+                                       (actual_v[15 + dvp] * d16[i][3]) +\r
+                                       (actual_v[14 + dvp] * d16[i][4]) +\r
+                                       (actual_v[13 + dvp] * d16[i][5]) +\r
+                                       (actual_v[12 + dvp] * d16[i][6]) +\r
+                                       (actual_v[11 + dvp] * d16[i][7]) +\r
+                                       (actual_v[10 + dvp] * d16[i][8]) +\r
+                                       (actual_v[9 + dvp] * d16[i][9]) +\r
+                                       (actual_v[8 + dvp] * d16[i][10]) +\r
+                                       (actual_v[7 + dvp] * d16[i][11]) +\r
+                                       (actual_v[6 + dvp] * d16[i][12]) +\r
+                                       (actual_v[5 + dvp] * d16[i][13]) +\r
+                                       (actual_v[4 + dvp] * d16[i][14]) +\r
+                                       (actual_v[3 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1049,22 +1049,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[3 + dvp] * d16[0]) +\r
-                                       (actual_v[2 + dvp] * d16[1]) +\r
-                                       (actual_v[1 + dvp] * d16[2]) +\r
-                                       (actual_v[0 + dvp] * d16[3]) +\r
-                                       (actual_v[15 + dvp] * d16[4]) +\r
-                                       (actual_v[14 + dvp] * d16[5]) +\r
-                                       (actual_v[13 + dvp] * d16[6]) +\r
-                                       (actual_v[12 + dvp] * d16[7]) +\r
-                                       (actual_v[11 + dvp] * d16[8]) +\r
-                                       (actual_v[10 + dvp] * d16[9]) +\r
-                                       (actual_v[9 + dvp] * d16[10]) +\r
-                                       (actual_v[8 + dvp] * d16[11]) +\r
-                                       (actual_v[7 + dvp] * d16[12]) +\r
-                                       (actual_v[6 + dvp] * d16[13]) +\r
-                                       (actual_v[5 + dvp] * d16[14]) +\r
-                                       (actual_v[4 + dvp] * d16[15])\r
+                               pcm_sample = (float) ( ( (actual_v[3 + dvp] * d16[i][0]) +\r
+                                       (actual_v[2 + dvp] * d16[i][1]) +\r
+                                       (actual_v[1 + dvp] * d16[i][2]) +\r
+                                       (actual_v[0 + dvp] * d16[i][3]) +\r
+                                       (actual_v[15 + dvp] * d16[i][4]) +\r
+                                       (actual_v[14 + dvp] * d16[i][5]) +\r
+                                       (actual_v[13 + dvp] * d16[i][6]) +\r
+                                       (actual_v[12 + dvp] * d16[i][7]) +\r
+                                       (actual_v[11 + dvp] * d16[i][8]) +\r
+                                       (actual_v[10 + dvp] * d16[i][9]) +\r
+                                       (actual_v[9 + dvp] * d16[i][10]) +\r
+                                       (actual_v[8 + dvp] * d16[i][11]) +\r
+                                       (actual_v[7 + dvp] * d16[i][12]) +\r
+                                       (actual_v[6 + dvp] * d16[i][13]) +\r
+                                       (actual_v[5 + dvp] * d16[i][14]) +\r
+                                       (actual_v[4 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1087,22 +1087,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[4 + dvp] * d16[0]) +\r
-                                       (actual_v[3 + dvp] * d16[1]) +\r
-                                       (actual_v[2 + dvp] * d16[2]) +\r
-                                       (actual_v[1 + dvp] * d16[3]) +\r
-                                       (actual_v[0 + dvp] * d16[4]) +\r
-                                       (actual_v[15 + dvp] * d16[5]) +\r
-                                       (actual_v[14 + dvp] * d16[6]) +\r
-                                       (actual_v[13 + dvp] * d16[7]) +\r
-                                       (actual_v[12 + dvp] * d16[8]) +\r
-                                       (actual_v[11 + dvp] * d16[9]) +\r
-                                       (actual_v[10 + dvp] * d16[10]) +@LOC("I")\r
-                                       (actual_v[9 + dvp] * d16[11]) +\r
-                                       (actual_v[8 + dvp] * d16[12]) +\r
-                                       (actual_v[7 + dvp] * d16[13]) +\r
-                                       (actual_v[6 + dvp] * d16[14]) +\r
-                                       (actual_v[5 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[4 + dvp] * d16[i][0]) +\r
+                                       (actual_v[3 + dvp] * d16[i][1]) +\r
+                                       (actual_v[2 + dvp] * d16[i][2]) +\r
+                                       (actual_v[1 + dvp] * d16[i][3]) +\r
+                                       (actual_v[0 + dvp] * d16[i][4]) +\r
+                                       (actual_v[15 + dvp] * d16[i][5]) +\r
+                                       (actual_v[14 + dvp] * d16[i][6]) +\r
+                                       (actual_v[13 + dvp] * d16[i][7]) +\r
+                                       (actual_v[12 + dvp] * d16[i][8]) +\r
+                                       (actual_v[11 + dvp] * d16[i][9]) +\r
+                                       (actual_v[10 + dvp] * d16[i][10]) +\r
+                                       (actual_v[9 + dvp] * d16[i][11]) +\r
+                                       (actual_v[8 + dvp] * d16[i][12]) +\r
+                                       (actual_v[7 + dvp] * d16[i][13]) +\r
+                                       (actual_v[6 + dvp] * d16[i][14]) +\r
+                                       (actual_v[5 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1125,22 +1125,22 @@ final class SynthesisFilter
                            //  final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[5 + dvp] * d16[0]) +\r
-                                       (actual_v[4 + dvp] * d16[1]) +\r
-                                       (actual_v[3 + dvp] * d16[2]) +\r
-                                       (actual_v[2 + dvp] * d16[3]) +\r
-                                       (actual_v[1 + dvp] * d16[4]) +\r
-                                       (actual_v[0 + dvp] * d16[5]) +\r
-                                       (actual_v[15 + dvp] * d16[6]) +\r
-                                       (actual_v[14 + dvp] * d16[7]) +\r
-                                       (actual_v[13 + dvp] * d16[8]) +\r
-                                       (actual_v[12 + dvp] * d16[9]) +\r
-                                       (actual_v[11 + dvp] * d16[10]) +\r
-                                       (actual_v[10 + dvp] * d16[11]) +\r
-                                       (actual_v[9 + dvp] * d16[12]) +\r
-                                       (actual_v[8 + dvp] * d16[13]) +\r
-                                       (actual_v[7 + dvp] * d16[14]) +\r
-                                       (actual_v[6 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[5 + dvp] * d16[i][0]) +\r
+                                       (actual_v[4 + dvp] * d16[i][1]) +\r
+                                       (actual_v[3 + dvp] * d16[i][2]) +\r
+                                       (actual_v[2 + dvp] * d16[i][3]) +\r
+                                       (actual_v[1 + dvp] * d16[i][4]) +\r
+                                       (actual_v[0 + dvp] * d16[i][5]) +\r
+                                       (actual_v[15 + dvp] * d16[i][6]) +\r
+                                       (actual_v[14 + dvp] * d16[i][7]) +\r
+                                       (actual_v[13 + dvp] * d16[i][8]) +\r
+                                       (actual_v[12 + dvp] * d16[i][9]) +\r
+                                       (actual_v[11 + dvp] * d16[i][10]) +\r
+                                       (actual_v[10 + dvp] * d16[i][11]) +\r
+                                       (actual_v[9 + dvp] * d16[i][12]) +\r
+                                       (actual_v[8 + dvp] * d16[i][13]) +\r
+                                       (actual_v[7 + dvp] * d16[i][14]) +\r
+                                       (actual_v[6 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1162,22 +1162,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[6 + dvp] * d16[0]) +\r
-                                       (actual_v[5 + dvp] * d61[1]) +\r
-                                       (actual_v[4 + dvp] * d16[2]) +\r
-                                       (actual_v[3 + dvp] * d16[3]) +\r
-                                       (actual_v[2 + dvp] * d16[4]) +\r
-                                       (actual_v[1 + dvp] * d16[5]) +\r
-                                       (actual_v[0 + dvp] * d16[6]) +\r
-                                       (actual_v[15 + dvp] * d16[7]) +\r
-                                       (actual_v[14 + dvp] * d16[8]) +\r
-                                       (actual_v[13 + dvp] * d16[9]) +\r
-                                       (actual_v[12 + dvp] * d16[10]) +\r
-                                       (actual_v[11 + dvp] * d16[11]) +\r
-                                       (actual_v[10 + dvp] * d16[12]) +\r
-                                       (actual_v[9 + dvp] * d16[13]) +\r
-                                       (actual_v[8 + dvp] * d16[14]) +\r
-                                       (actual_v[7 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[6 + dvp] * d16[i][0]) +\r
+                                       (actual_v[5 + dvp] * d16[i][1]) +\r
+                                       (actual_v[4 + dvp] * d16[i][2]) +\r
+                                       (actual_v[3 + dvp] * d16[i][3]) +\r
+                                       (actual_v[2 + dvp] * d16[i][4]) +\r
+                                       (actual_v[1 + dvp] * d16[i][5]) +\r
+                                       (actual_v[0 + dvp] * d16[i][6]) +\r
+                                       (actual_v[15 + dvp] * d16[i][7]) +\r
+                                       (actual_v[14 + dvp] * d16[i][8]) +\r
+                                       (actual_v[13 + dvp] * d16[i][9]) +\r
+                                       (actual_v[12 + dvp] * d16[i][10]) +\r
+                                       (actual_v[11 + dvp] * d16[i][11]) +\r
+                                       (actual_v[10 + dvp] * d16[i][12]) +\r
+                                       (actual_v[9 + dvp] * d16[i][13]) +\r
+                                       (actual_v[8 + dvp] * d16[i][14]) +\r
+                                       (actual_v[7 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1200,22 +1200,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[7 + dvp] * d16[0]) +\r
-                                       (actual_v[6 + dvp] * d16[1]) +\r
-                                       (actual_v[5 + dvp] * d16[2]) +\r
-                                       (actual_v[4 + dvp] * d16[3]) +\r
-                                       (actual_v[3 + dvp] * d16[4]) +\r
-                                       (actual_v[2 + dvp] * d16[5]) +\r
-                                       (actual_v[1 + dvp] * d16[6]) +\r
-                                       (actual_v[0 + dvp] * d16[7]) +\r
-                                       (actual_v[15 + dvp] * d16[8]) +\r
-                                       (actual_v[14 + dvp] * d16[9]) +\r
-                                       (actual_v[13 + dvp] * d16[10]) +\r
-                                       (actual_v[12 + dvp] * d16[11]) +\r
-                                       (actual_v[11 + dvp] * d16[12]) +\r
-                                       (actual_v[10 + dvp] * d16[13]) +\r
-                                       (actual_v[9 + dvp] * d16[14]) +\r
-                                       (actual_v[8 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[7 + dvp] * d16[i][0]) +\r
+                                       (actual_v[6 + dvp] * d16[i][1]) +\r
+                                       (actual_v[5 + dvp] * d16[i][2]) +\r
+                                       (actual_v[4 + dvp] * d16[i][3]) +\r
+                                       (actual_v[3 + dvp] * d16[i][4]) +\r
+                                       (actual_v[2 + dvp] * d16[i][5]) +\r
+                                       (actual_v[1 + dvp] * d16[i][6]) +\r
+                                       (actual_v[0 + dvp] * d16[i][7]) +\r
+                                       (actual_v[15 + dvp] * d16[i][8]) +\r
+                                       (actual_v[14 + dvp] * d16[i][9]) +\r
+                                       (actual_v[13 + dvp] * d16[i][10]) +\r
+                                       (actual_v[12 + dvp] * d16[i][11]) +\r
+                                       (actual_v[11 + dvp] * d16[i][12]) +\r
+                                       (actual_v[10 + dvp] * d16[i][13]) +\r
+                                       (actual_v[9 + dvp] * d16[i][14]) +\r
+                                       (actual_v[8 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1238,22 +1238,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[8 + dvp] * d16[0]) +\r
-                                       (actual_v[7 + dvp] * d16[1]) +\r
-                                       (actual_v[6 + dvp] * d16[2]) +\r
-                                       (actual_v[5 + dvp] * d16[3]) +\r
-                                       (actual_v[4 + dvp] * d16[4]) +\r
-                                       (actual_v[3 + dvp] * d16[5]) +\r
-                                       (actual_v[2 + dvp] * d16[6]) +\r
-                                       (actual_v[1 + dvp] * d16[7]) +\r
-                                       (actual_v[0 + dvp] * d16[8]) +\r
-                                       (actual_v[15 + dvp] * d16[9]) +\r
-                                       (actual_v[14 + dvp] * d16[10]) +\r
-                                       (actual_v[13 + dvp] * d16[11]) +\r
-                                       (actual_v[12 + dvp] * d16[12]) +\r
-                                       (actual_v[11 + dvp] * d16[13]) +\r
-                                       (actual_v[10 + dvp] * d16[14]) +\r
-                                       (actual_v[9 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[8 + dvp] * d16[i][0]) +\r
+                                       (actual_v[7 + dvp] * d16[i][1]) +\r
+                                       (actual_v[6 + dvp] * d16[i][2]) +\r
+                                       (actual_v[5 + dvp] * d16[i][3]) +\r
+                                       (actual_v[4 + dvp] * d16[i][4]) +\r
+                                       (actual_v[3 + dvp] * d16[i][5]) +\r
+                                       (actual_v[2 + dvp] * d16[i][6]) +\r
+                                       (actual_v[1 + dvp] * d16[i][7]) +\r
+                                       (actual_v[0 + dvp] * d16[i][8]) +\r
+                                       (actual_v[15 + dvp] * d16[i][9]) +\r
+                                       (actual_v[14 + dvp] * d16[i][10]) +\r
+                                       (actual_v[13 + dvp] * d16[i][11]) +\r
+                                       (actual_v[12 + dvp] * d16[i][12]) +\r
+                                       (actual_v[11 + dvp] * d16[i][13]) +\r
+                                       (actual_v[10 + dvp] * d16[i][14]) +\r
+                                       (actual_v[9 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1276,22 +1276,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[9 + dvp] * d16[0]) +\r
-                                       (actual_v[8 + dvp] * d16[1]) +\r
-                                       (actual_v[7 + dvp] * d16[2]) +\r
-                                       (actual_v[6 + dvp] * d16[3]) +\r
-                                       (actual_v[5 + dvp] * d16[4]) +\r
-                                       (actual_v[4 + dvp] * d16[5]) +\r
-                                       (actual_v[3 + dvp] * d16[6]) +\r
-                                       (actual_v[2 + dvp] * d16[7]) +\r
-                                       (actual_v[1 + dvp] * d16[8]) +\r
-                                       (actual_v[0 + dvp] * d16[9]) +\r
-                                       (actual_v[15 + dvp] * d16[10]) +\r
-                                       (actual_v[14 + dvp] * d16[11]) +\r
-                                       (actual_v[13 + dvp] * d16[12]) +\r
-                                       (actual_v[12 + dvp] * d16[13]) +\r
-                                       (actual_v[11 + dvp] * d16[14]) +\r
-                                       (actual_v[10 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[9 + dvp] * d16[i][0]) +\r
+                                       (actual_v[8 + dvp] * d16[i][1]) +\r
+                                       (actual_v[7 + dvp] * d16[i][2]) +\r
+                                       (actual_v[6 + dvp] * d16[i][3]) +\r
+                                       (actual_v[5 + dvp] * d16[i][4]) +\r
+                                       (actual_v[4 + dvp] * d16[i][5]) +\r
+                                       (actual_v[3 + dvp] * d16[i][6]) +\r
+                                       (actual_v[2 + dvp] * d16[i][7]) +\r
+                                       (actual_v[1 + dvp] * d16[i][8]) +\r
+                                       (actual_v[0 + dvp] * d16[i][9]) +\r
+                                       (actual_v[15 + dvp] * d16[i][10]) +\r
+                                       (actual_v[14 + dvp] * d16[i][11]) +\r
+                                       (actual_v[13 + dvp] * d16[i][12]) +\r
+                                       (actual_v[12 + dvp] * d16[i][13]) +\r
+                                       (actual_v[11 + dvp] * d16[i][14]) +\r
+                                       (actual_v[10 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1313,25 +1313,25 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((vp[10 + dvp] * dp[0]) +\r
-                                       (vp[9 + dvp] * dp[1]) +\r
-                                       (vp[8 + dvp] * dp[2]) +\r
-                                       (vp[7 + dvp] * dp[3]) +\r
-                                       (vp[6 + dvp] * dp[4]) +\r
-                                       (vp[5 + dvp] * dp[5]) +\r
-                                       (vp[4 + dvp] * dp[6]) +\r
-                                       (vp[3 + dvp] * dp[7]) +\r
-                                       (vp[2 + dvp] * dp[8]) +\r
-                                       (vp[1 + dvp] * dp[9]) +\r
-                                       (vp[0 + dvp] * dp[10]) +\r
-                                       (vp[15 + dvp] * dp[11]) +\r
-                                       (vp[14 + dvp] * dp[12]) +\r
-                                       (vp[13 + dvp] * dp[13]) +\r
-                                       (vp[12 + dvp] * dp[14]) +\r
-                                       (vp[11 + dvp] * dp[15])\r
+                               pcm_sample = (float)(((actual_v[10 + dvp] * d16[i][0]) +\r
+                                       (actual_v[9 + dvp] * d16[i][1]) +\r
+                                       (actual_v[8 + dvp] * d16[i][2]) +\r
+                                       (actual_v[7 + dvp] * d16[i][3]) +\r
+                                       (actual_v[6 + dvp] * d16[i][4]) +\r
+                                       (actual_v[5 + dvp] * d16[i][5]) +\r
+                                       (actual_v[4 + dvp] * d16[i][6]) +\r
+                                       (actual_v[3 + dvp] * d16[i][7]) +\r
+                                       (actual_v[2 + dvp] * d16[i][8]) +\r
+                                       (actual_v[1 + dvp] * d16[i][9]) +\r
+                                       (actual_v[0 + dvp] * d16[i][10]) +\r
+                                       (actual_v[15 + dvp] * d16[i][11]) +\r
+                                       (actual_v[14 + dvp] * d16[i][12]) +\r
+                                       (actual_v[13 + dvp] * d16[i][13]) +\r
+                                       (actual_v[12 + dvp] * d16[i][14]) +\r
+                                       (actual_v[11 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
-            tmpOut[i] = pcm_sample;\r
+            _tmpOut[i] = pcm_sample;\r
                        \r
                        dvp += 16;\r
                        } // for\r
@@ -1351,25 +1351,25 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[11 + dvp] * d16[0]) +\r
-                                       (actual_v[10 + dvp] * d16[1]) +\r
-                                       (actual_v[9 + dvp] * d16[2]) +\r
-                                       (actual_v[8 + dvp] * d16[3]) +\r
-                                       (actual_v[7 + dvp] * d16[4]) +\r
-                                       (actual_v[6 + dvp] * d16[5]) +\r
-                                       (actual_v[5 + dvp] * d16[6]) +\r
-                                       (actual_v[4 + dvp] * d16[7]) +\r
-                                       (actual_v[3 + dvp] * d16[8]) +\r
-                                       (actual_v[2 + dvp] * d16[9]) +\r
-                                       (actual_v[1 + dvp] * d16[10]) +\r
-                                       (actual_v[0 + dvp] * d16[11]) +\r
-                                       (actual_v[15 + dvp] * d16[12]) +\r
-                                       (actual_v[14 + dvp] * d16[13]) +\r
-                                       (actual_v[13 + dvp] * d16[14]) +\r
-                                       (actual_v[12 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[11 + dvp] * d16[i][0]) +\r
+                                       (actual_v[10 + dvp] * d16[i][1]) +\r
+                                       (actual_v[9 + dvp] * d16[i][2]) +\r
+                                       (actual_v[8 + dvp] * d16[i][3]) +\r
+                                       (actual_v[7 + dvp] * d16[i][4]) +\r
+                                       (actual_v[6 + dvp] * d16[i][5]) +\r
+                                       (actual_v[5 + dvp] * d16[i][6]) +\r
+                                       (actual_v[4 + dvp] * d16[i][7]) +\r
+                                       (actual_v[3 + dvp] * d16[i][8]) +\r
+                                       (actual_v[2 + dvp] * d16[i][9]) +\r
+                                       (actual_v[1 + dvp] * d16[i][10]) +\r
+                                       (actual_v[0 + dvp] * d16[i][11]) +\r
+                                       (actual_v[15 + dvp] * d16[i][12]) +\r
+                                       (actual_v[14 + dvp] * d16[i][13]) +\r
+                                       (actual_v[13 + dvp] * d16[i][14]) +\r
+                                       (actual_v[12 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
-            tmpOut[i] = pcm_sample;\r
+            _tmpOut[i] = pcm_sample;\r
                        \r
                        dvp += 16;\r
                        } // for\r
@@ -1388,22 +1388,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[12 + dvp] * d16[0]) +\r
-                                       (actual_v[11 + dvp] * d16[1]) +\r
-                                       (actual_v[10 + dvp] * d16[2]) +\r
-                                       (actual_v[9 + dvp] * d16[3]) +\r
-                                       (actual_v[8 + dvp] * d16[4]) +\r
-                                       (actual_v[7 + dvp] * d16[5]) +\r
-                                       (actual_v[6 + dvp] * d16[6]) +\r
-                                       (actual_v[5 + dvp] * d16[7]) +\r
-                                       (actual_v[4 + dvp] * d16[8]) +\r
-                                       (actual_v[3 + dvp] * d16[9]) +\r
-                                       (actual_v[2 + dvp] * d16[10]) +\r
-                                       (actual_v[1 + dvp] * d16[11]) +\r
-                                       (actual_v[0 + dvp] * d16[12]) +\r
-                                       (actual_v[15 + dvp] * d16[13]) +\r
-                                       (actual_v[14 + dvp] * d16[14]) +\r
-                                       (actual_v[13 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[12 + dvp] * d16[i][0]) +\r
+                                       (actual_v[11 + dvp] * d16[i][1]) +\r
+                                       (actual_v[10 + dvp] * d16[i][2]) +\r
+                                       (actual_v[9 + dvp] * d16[i][3]) +\r
+                                       (actual_v[8 + dvp] * d16[i][4]) +\r
+                                       (actual_v[7 + dvp] * d16[i][5]) +\r
+                                       (actual_v[6 + dvp] * d16[i][6]) +\r
+                                       (actual_v[5 + dvp] * d16[i][7]) +\r
+                                       (actual_v[4 + dvp] * d16[i][8]) +\r
+                                       (actual_v[3 + dvp] * d16[i][9]) +\r
+                                       (actual_v[2 + dvp] * d16[i][10]) +\r
+                                       (actual_v[1 + dvp] * d16[i][11]) +\r
+                                       (actual_v[0 + dvp] * d16[i][12]) +\r
+                                       (actual_v[15 + dvp] * d16[i][13]) +\r
+                                       (actual_v[14 + dvp] * d16[i][14]) +\r
+                                       (actual_v[13 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1426,22 +1426,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[13 + dvp] * d16[0]) +\r
-                                       (actual_v[12 + dvp] * d16[1]) +\r
-                                       (actual_v[11 + dvp] * d16[2]) +\r
-                                       (actual_v[10 + dvp] * d16[3]) +\r
-                                       (actual_v[9 + dvp] * d16[4]) +\r
-                                       (actual_v[8 + dvp] * d16[5]) +\r
-                                       (actual_v[7 + dvp] * d16[6]) +\r
-                                       (actual_v[6 + dvp] * d16[7]) +\r
-                                       (actual_v[5 + dvp] * d16[8]) +\r
-                                       (actual_v[4 + dvp] * d16[9]) +\r
-                                       (actual_v[3 + dvp] * d16[10]) +\r
-                                       (actual_v[2 + dvp] * d16[11]) +\r
-                                       (actual_v[1 + dvp] * d16[12]) +\r
-                                       (actual_v[0 + dvp] * d16[13]) +\r
-                                       (actual_v[15 + dvp] * d16[14]) +\r
-                                       (actual_v[14 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[13 + dvp] * d16[i][0]) +\r
+                                       (actual_v[12 + dvp] * d16[i][1]) +\r
+                                       (actual_v[11 + dvp] * d16[i][2]) +\r
+                                       (actual_v[10 + dvp] * d16[i][3]) +\r
+                                       (actual_v[9 + dvp] * d16[i][4]) +\r
+                                       (actual_v[8 + dvp] * d16[i][5]) +\r
+                                       (actual_v[7 + dvp] * d16[i][6]) +\r
+                                       (actual_v[6 + dvp] * d16[i][7]) +\r
+                                       (actual_v[5 + dvp] * d16[i][8]) +\r
+                                       (actual_v[4 + dvp] * d16[i][9]) +\r
+                                       (actual_v[3 + dvp] * d16[i][10]) +\r
+                                       (actual_v[2 + dvp] * d16[i][11]) +\r
+                                       (actual_v[1 + dvp] * d16[i][12]) +\r
+                                       (actual_v[0 + dvp] * d16[i][13]) +\r
+                                       (actual_v[15 + dvp] * d16[i][14]) +\r
+                                       (actual_v[14 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1464,22 +1464,22 @@ final class SynthesisFilter
                            //final float[] dp = d16[i];\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 \r
-                               pcm_sample = (float)(((actual_v[14 + dvp] * d16[0]) +\r
-                                       (actual_v[13 + dvp] * d16[1]) +\r
-                                       (actual_v[12 + dvp] * d16[2]) +\r
-                                       (actual_v[11 + dvp] * d16[3]) +\r
-                                       (actual_v[10 + dvp] * d16[4]) +\r
-                                       (actual_v[9 + dvp] * d16[5]) +\r
-                                       (actual_v[8 + dvp] * d16[6]) +\r
-                                       (actual_v[7 + dvp] * d16[7]) +\r
-                                       (actual_v[6 + dvp] * d16[8]) +\r
-                                       (actual_v[5 + dvp] * d16[9]) +\r
-                                       (actual_v[4 + dvp] * d16[10]) +\r
-                                       (actual_v[3 + dvp] * d16[11]) +\r
-                                       (actual_v[2 + dvp] * d16[12]) +\r
-                                       (actual_v[1 + dvp] * d16[13]) +\r
-                                       (actual_v[0 + dvp] * d16[14]) +\r
-                                       (actual_v[15 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[14 + dvp] * d16[i][0]) +\r
+                                       (actual_v[13 + dvp] * d16[i][1]) +\r
+                                       (actual_v[12 + dvp] * d16[i][2]) +\r
+                                       (actual_v[11 + dvp] * d16[i][3]) +\r
+                                       (actual_v[10 + dvp] * d16[i][4]) +\r
+                                       (actual_v[9 + dvp] * d16[i][5]) +\r
+                                       (actual_v[8 + dvp] * d16[i][6]) +\r
+                                       (actual_v[7 + dvp] * d16[i][7]) +\r
+                                       (actual_v[6 + dvp] * d16[i][8]) +\r
+                                       (actual_v[5 + dvp] * d16[i][9]) +\r
+                                       (actual_v[4 + dvp] * d16[i][10]) +\r
+                                       (actual_v[3 + dvp] * d16[i][11]) +\r
+                                       (actual_v[2 + dvp] * d16[i][12]) +\r
+                                       (actual_v[1 + dvp] * d16[i][13]) +\r
+                                       (actual_v[0 + dvp] * d16[i][14]) +\r
+                                       (actual_v[15 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;\r
@@ -1501,22 +1501,22 @@ final class SynthesisFilter
                        {\r
                                @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
                                //final float dp[] = d16[i];\r
-                               pcm_sample = (float)(((vp[15 + dvp] * d16[0]) +\r
-                                       (actual_v[14 + dvp] * d16[1]) +\r
-                                       (actual_v[13 + dvp] * d16[2]) +\r
-                                       (actual_v[12 + dvp] * d16[3]) +\r
-                                       (actual_v[11 + dvp] * d16[4]) +\r
-                                       (actual_v[10 + dvp] * d16[5]) +\r
-                                       (actual_v[9 + dvp] * d16[6]) +\r
-                                       (actual_v[8 + dvp] * d16[7]) +\r
-                                       (actual_v[7 + dvp] * d16[8]) +\r
-                                       (actual_v[6 + dvp] * d16[9]) +\r
-                                       (actual_v[5 + dvp] * d16[10]) +\r
-                                       (actual_v[4 + dvp] * d16[11]) +\r
-                                       (actual_v[3 + dvp] * d16[12]) +\r
-                                       (actual_v[2 + dvp] * d16[13]) +\r
-                                       (actual_v[1 + dvp] * d16[14]) +\r
-                                       (actual_v[0 + dvp] * d16[15])\r
+                               pcm_sample = (float)(((actual_v[15 + dvp] * d16[i][0]) +\r
+                                       (actual_v[14 + dvp] * d16[i][1]) +\r
+                                       (actual_v[13 + dvp] * d16[i][2]) +\r
+                                       (actual_v[12 + dvp] * d16[i][3]) +\r
+                                       (actual_v[11 + dvp] * d16[i][4]) +\r
+                                       (actual_v[10 + dvp] * d16[i][5]) +\r
+                                       (actual_v[9 + dvp] * d16[i][6]) +\r
+                                       (actual_v[8 + dvp] * d16[i][7]) +\r
+                                       (actual_v[7 + dvp] * d16[i][8]) +\r
+                                       (actual_v[6 + dvp] * d16[i][9]) +\r
+                                       (actual_v[5 + dvp] * d16[i][10]) +\r
+                                       (actual_v[4 + dvp] * d16[i][11]) +\r
+                                       (actual_v[3 + dvp] * d16[i][12]) +\r
+                                       (actual_v[2 + dvp] * d16[i][13]) +\r
+                                       (actual_v[1 + dvp] * d16[i][14]) +\r
+                                       (actual_v[0 + dvp] * d16[i][15])\r
                                        ) * scalefactor);\r
 \r
             _tmpOut[i] = pcm_sample;                   \r
@@ -1692,11 +1692,102 @@ private void compute_pcm_samples(@LOC("GLOBAL") Obuffer buffer)
        {\r
                try\r
                {\r
-                       Class elemType = Float.TYPE;\r
-                       Object o = JavaLayerUtils.deserializeArrayResource("sfd.ser", elemType, 512);\r
-                       return (float[])o;\r
+//                     Class elemType = Float.TYPE;\r
+//                     Object o = JavaLayerUtils.deserializeArrayResource("sfd.ser", elemType, 512);\r
+//                  Object o = JavaLayerUtils.deserializeArrayResource("sfd.ser",  512);\r
+                 \r
+      float[] sfd =\r
+          { 0.0f, -4.42505E-4f, 0.003250122f, -0.007003784f, 0.031082153f, -0.07862854f,\r
+              0.10031128f, -0.57203674f, 1.144989f, 0.57203674f, 0.10031128f, 0.07862854f,\r
+              0.031082153f, 0.007003784f, 0.003250122f, 4.42505E-4f, -1.5259E-5f, -4.73022E-4f,\r
+              0.003326416f, -0.007919312f, 0.030517578f, -0.08418274f, 0.090927124f, -0.6002197f,\r
+              1.1442871f, 0.54382324f, 0.1088562f, 0.07305908f, 0.03147888f, 0.006118774f,\r
+              0.003173828f, 3.96729E-4f, -1.5259E-5f, -5.34058E-4f, 0.003387451f, -0.008865356f,\r
+              0.029785156f, -0.08970642f, 0.08068848f, -0.6282959f, 1.1422119f, 0.51560974f,\r
+              0.11657715f, 0.06752014f, 0.03173828f, 0.0052948f, 0.003082275f, 3.66211E-4f,\r
+              -1.5259E-5f, -5.79834E-4f, 0.003433228f, -0.009841919f, 0.028884888f, -0.09516907f,\r
+              0.06959534f, -0.6562195f, 1.1387634f, 0.48747253f, 0.12347412f, 0.06199646f,\r
+              0.031845093f, 0.004486084f, 0.002990723f, 3.20435E-4f, -1.5259E-5f, -6.2561E-4f,\r
+              0.003463745f, -0.010848999f, 0.027801514f, -0.10054016f, 0.057617188f, -0.6839142f,\r
+              1.1339264f, 0.45947266f, 0.12957764f, 0.056533813f, 0.031814575f, 0.003723145f,\r
+              0.00289917f, 2.89917E-4f, -1.5259E-5f, -6.86646E-4f, 0.003479004f, -0.011886597f,\r
+              0.026535034f, -0.1058197f, 0.044784546f, -0.71131897f, 1.1277466f, 0.43165588f,\r
+              0.1348877f, 0.051132202f, 0.031661987f, 0.003005981f, 0.002792358f, 2.59399E-4f,\r
+              -1.5259E-5f, -7.47681E-4f, 0.003479004f, -0.012939453f, 0.02508545f, -0.110946655f,\r
+              0.031082153f, -0.7383728f, 1.120224f, 0.40408325f, 0.13945007f, 0.045837402f,\r
+              0.03138733f, 0.002334595f, 0.002685547f, 2.44141E-4f, -3.0518E-5f, -8.08716E-4f,\r
+              0.003463745f, -0.014022827f, 0.023422241f, -0.11592102f, 0.01651001f, -0.7650299f,\r
+              1.1113739f, 0.37680054f, 0.14326477f, 0.040634155f, 0.03100586f, 0.001693726f,\r
+              0.002578735f, 2.13623E-4f, -3.0518E-5f, -8.8501E-4f, 0.003417969f, -0.01512146f,\r
+              0.021575928f, -0.12069702f, 0.001068115f, -0.791214f, 1.1012115f, 0.34986877f,\r
+              0.1463623f, 0.03555298f, 0.030532837f, 0.001098633f, 0.002456665f, 1.98364E-4f,\r
+              -3.0518E-5f, -9.61304E-4f, 0.003372192f, -0.016235352f, 0.01953125f, -0.1252594f,\r
+              -0.015228271f, -0.816864f, 1.0897827f, 0.32331848f, 0.1487732f, 0.03060913f,\r
+              0.029937744f, 5.49316E-4f, 0.002349854f, 1.67847E-4f, -3.0518E-5f, -0.001037598f,\r
+              0.00328064f, -0.017349243f, 0.01725769f, -0.12956238f, -0.03237915f, -0.84194946f,\r
+              1.0771179f, 0.2972107f, 0.15049744f, 0.025817871f, 0.029281616f, 3.0518E-5f,\r
+              0.002243042f, 1.52588E-4f, -4.5776E-5f, -0.001113892f, 0.003173828f, -0.018463135f,\r
+              0.014801025f, -0.1335907f, -0.050354004f, -0.8663635f, 1.0632172f, 0.2715912f,\r
+              0.15159607f, 0.0211792f, 0.028533936f, -4.42505E-4f, 0.002120972f, 1.37329E-4f,\r
+              -4.5776E-5f, -0.001205444f, 0.003051758f, -0.019577026f, 0.012115479f, -0.13729858f,\r
+              -0.06916809f, -0.89009094f, 1.0481567f, 0.24650574f, 0.15206909f, 0.016708374f,\r
+              0.02772522f, -8.69751E-4f, 0.00201416f, 1.2207E-4f, -6.1035E-5f, -0.001296997f,\r
+              0.002883911f, -0.020690918f, 0.009231567f, -0.14067078f, -0.088775635f, -0.9130554f,\r
+              1.0319366f, 0.22198486f, 0.15196228f, 0.012420654f, 0.02684021f, -0.001266479f,\r
+              0.001907349f, 1.06812E-4f, -6.1035E-5f, -0.00138855f, 0.002700806f, -0.02178955f,\r
+              0.006134033f, -0.14367676f, -0.10916138f, -0.9351959f, 1.0146179f, 0.19805908f,\r
+              0.15130615f, 0.00831604f, 0.025909424f, -0.001617432f, 0.001785278f, 1.06812E-4f,\r
+              -7.6294E-5f, -0.001480103f, 0.002487183f, -0.022857666f, 0.002822876f, -0.1462555f,\r
+              -0.13031006f, -0.95648193f, 0.99624634f, 0.17478943f, 0.15011597f, 0.004394531f,\r
+              0.024932861f, -0.001937866f, 0.001693726f, 9.1553E-5f, -7.6294E-5f, -0.001586914f,\r
+              0.002227783f, -0.023910522f, -6.86646E-4f, -0.14842224f, -0.15220642f, -0.9768524f,\r
+              0.9768524f, 0.15220642f, 0.14842224f, 6.86646E-4f, 0.023910522f, -0.002227783f,\r
+              0.001586914f, 7.6294E-5f, -9.1553E-5f, -0.001693726f, 0.001937866f, -0.024932861f,\r
+              -0.004394531f, -0.15011597f, -0.17478943f, -0.99624634f, 0.95648193f, 0.13031006f,\r
+              0.1462555f, -0.002822876f, 0.022857666f, -0.002487183f, 0.001480103f, 7.6294E-5f,\r
+              -1.06812E-4f, -0.001785278f, 0.001617432f, -0.025909424f, -0.00831604f, -0.15130615f,\r
+              -0.19805908f, -1.0146179f, 0.9351959f, 0.10916138f, 0.14367676f, -0.006134033f,\r
+              0.02178955f, -0.002700806f, 0.00138855f, 6.1035E-5f, -1.06812E-4f, -0.001907349f,\r
+              0.001266479f, -0.02684021f, -0.012420654f, -0.15196228f, -0.22198486f, -1.0319366f,\r
+              0.9130554f, 0.088775635f, 0.14067078f, -0.009231567f, 0.020690918f, -0.002883911f,\r
+              0.001296997f, 6.1035E-5f, -1.2207E-4f, -0.00201416f, 8.69751E-4f, -0.02772522f,\r
+              -0.016708374f, -0.15206909f, -0.24650574f, -1.0481567f, 0.89009094f, 0.06916809f,\r
+              0.13729858f, -0.012115479f, 0.019577026f, -0.003051758f, 0.001205444f, 4.5776E-5f,\r
+              -1.37329E-4f, -0.002120972f, 4.42505E-4f, -0.028533936f, -0.0211792f, -0.15159607f,\r
+              -0.2715912f, -1.0632172f, 0.8663635f, 0.050354004f, 0.1335907f, -0.014801025f,\r
+              0.018463135f, -0.003173828f, 0.001113892f, 4.5776E-5f, -1.52588E-4f, -0.002243042f,\r
+              -3.0518E-5f, -0.029281616f, -0.025817871f, -0.15049744f, -0.2972107f, -1.0771179f,\r
+              0.84194946f, 0.03237915f, 0.12956238f, -0.01725769f, 0.017349243f, -0.00328064f,\r
+              0.001037598f, 3.0518E-5f, -1.67847E-4f, -0.002349854f, -5.49316E-4f, -0.029937744f,\r
+              -0.03060913f, -0.1487732f, -0.32331848f, -1.0897827f, 0.816864f, 0.015228271f,\r
+              0.1252594f, -0.01953125f, 0.016235352f, -0.003372192f, 9.61304E-4f, 3.0518E-5f,\r
+              -1.98364E-4f, -0.002456665f, -0.001098633f, -0.030532837f, -0.03555298f, -0.1463623f,\r
+              -0.34986877f, -1.1012115f, 0.791214f, -0.001068115f, 0.12069702f, -0.021575928f,\r
+              0.01512146f, -0.003417969f, 8.8501E-4f, 3.0518E-5f, -2.13623E-4f, -0.002578735f,\r
+              -0.001693726f, -0.03100586f, -0.040634155f, -0.14326477f, -0.37680054f, -1.1113739f,\r
+              0.7650299f, -0.01651001f, 0.11592102f, -0.023422241f, 0.014022827f, -0.003463745f,\r
+              8.08716E-4f, 3.0518E-5f, -2.44141E-4f, -0.002685547f, -0.002334595f, -0.03138733f,\r
+              -0.045837402f, -0.13945007f, -0.40408325f, -1.120224f, 0.7383728f, -0.031082153f,\r
+              0.110946655f, -0.02508545f, 0.012939453f, -0.003479004f, 7.47681E-4f, 1.5259E-5f,\r
+              -2.59399E-4f, -0.002792358f, -0.003005981f, -0.031661987f, -0.051132202f,\r
+              -0.1348877f, -0.43165588f, -1.1277466f, 0.71131897f, -0.044784546f, 0.1058197f,\r
+              -0.026535034f, 0.011886597f, -0.003479004f, 6.86646E-4f, 1.5259E-5f, -2.89917E-4f,\r
+              -0.00289917f, -0.003723145f, -0.031814575f, -0.056533813f, -0.12957764f,\r
+              -0.45947266f, -1.1339264f, 0.6839142f, -0.057617188f, 0.10054016f, -0.027801514f,\r
+              0.010848999f, -0.003463745f, 6.2561E-4f, 1.5259E-5f, -3.20435E-4f, -0.002990723f,\r
+              -0.004486084f, -0.031845093f, -0.06199646f, -0.12347412f, -0.48747253f, -1.1387634f,\r
+              0.6562195f, -0.06959534f, 0.09516907f, -0.028884888f, 0.009841919f, -0.003433228f,\r
+              5.79834E-4f, 1.5259E-5f, -3.66211E-4f, -0.003082275f, -0.0052948f, -0.03173828f,\r
+              -0.06752014f, -0.11657715f, -0.51560974f, -1.1422119f, 0.6282959f, -0.08068848f,\r
+              0.08970642f, -0.029785156f, 0.008865356f, -0.003387451f, 5.34058E-4f, 1.5259E-5f,\r
+              -3.96729E-4f, -0.003173828f, -0.006118774f, -0.03147888f, -0.07305908f, -0.1088562f,\r
+              -0.54382324f, -1.1442871f, 0.6002197f, -0.090927124f, 0.08418274f, -0.030517578f,\r
+              0.007919312f, -0.003326416f, 4.73022E-4f, 1.5259E-5f };\r
+      \r
+      return sfd;\r
                }\r
-               catch (IOException ex)\r
+//             catch (IOException ex)\r
+               catch (Exception ex)\r
                {\r
                        throw new ExceptionInInitializerError(ex);\r
                }               \r