Replace Listview with GridView.

Integrate ART benchmarks.
Add button for hide/show display with result.
Add custom adapter to Gridview for better control.

Change-Id: I794b8eea77efac43caa5fbd52a3ac9c01598b6d7
Signed-off-by: Ivaylo Asenov <ivaylo.asenov@linaro.org>

75 files changed, 19088 insertions, 94 deletions

diff --git a/BenchmarkFramework/Readme.txt b/BenchmarkFramework/Readme.txt
index 93b356e..216aabb 100644
--- a/BenchmarkFramework/Readme.txt
+++ b/BenchmarkFramework/Readme.txt
@@ -5,7 +5,7 @@ This file includes a little info about "benchmarkframework" application.
 1) The main target of the application is to run different benchmark tests integrated inside the app and written on (JAVA/C/C++)
 
 
-2) There are 6 tests integrated for now:
+2) There are 15 tests integrated for now:
 
 - "MemSpeed"			// This benchmark is integrated as *so library and will be remove if not needed. Source code: http://www.roylongbottom.org.uk/android%20benchmarks.htm#anchor17
 
@@ -28,7 +28,17 @@ This file includes a little info about "benchmarkframework" application.
 				// Version: Iozone3_465
 
 - "Bonnie++"			// This benchmark is integrated as executable file related to task: https://projects.linaro.org/browse/LMG-1420
-				// Source code: "ssh://git@git.linaro.org/people/satish.patel/android-bonnie.git"			
+				// Source code: "ssh://git@git.linaro.org/people/satish.patel/android-bonnie.git"
+
+
+
+- "Algorithm(ART)"		// Source code: https://android-git.linaro.org/gitweb/linaro/art-testing.git
+- "BMsGame(ART)"	
+- "Caffeine(ART)"
+- "Jit-out(ART)"
+- "Math(ART)"
+- "Micro(ART)"
+- "Stanford(ART)"			
 
 
 3)Functionality:
@@ -45,6 +55,7 @@ This file includes a little info about "benchmarkframework" application.
 	3.6) Long press on results textview (area bellow buttons) shows listview with all saved files. Pressing on a file open file in HTMLViewer. Long press on a file allow file deletion
 	3.7) There is repeat test indicator in the main activity (red textview with digit inside)
 	3.8) Posibitily of canceling running tests
+	3.9) [HIDE/SHOW DISPLAY] button hide/show display with results
 
 
 4)Shell script: There is shell script in "BenchmarkFramework/shellscript" which allows benchmark application to be run using adb shell properties. 
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/AccessFannkuch.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/AccessFannkuch.java
new file mode 100644
index 0000000..7f85a73
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/AccessFannkuch.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/access-fannkuch.js
+ *
+ * Description:     Algorithm that performs array permutations.
+ * Main Focus:      Array operations.
+ *
+ */
+
+/* The Great Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy */
+
+// http://benchmarksgame.alioth.debian.org/license.html  (BSD 3-clause license)
+// See NOTICE file for the license
+
+package art_benchmarks.algorithm;
+
+import java.lang.Integer;
+import java.lang.System;
+
+public class AccessFannkuch {
+  private static final int ACCESS_FANNKUCH_EXPECTED = 22;
+
+  private int fannkuch(int n) {
+    int check = 0;
+    int[] perm = new int[n];
+    int[] perm1 = new int[n];
+    int[] count = new int[n];
+    int[] maxPerm = new int[n];
+    int maxFlipsCount = 0;
+    final int m = n - 1;
+
+    for (int i = 0; i < n; i++) {
+      perm1[i] = i;
+    }
+    int r = n;
+
+    while (true) {
+      // Write-out the first 30 permutations.
+      if (check < 30) {
+        String s = "";
+        for (int i = 0; i < n; i++) {
+          s += Integer.toString((perm1[i] + 1));
+        }
+        check++;
+      }
+
+      while (r != 1) {
+        count[r - 1] = r;
+        r--;
+      }
+
+      if (!(perm1[0] == 0 || perm1[m] == m)) {
+        for (int i = 0; i < n; i++) {
+          perm[i] = perm1[i];
+        }
+
+        int flipsCount = 0;
+        int k;
+
+        while (!((k = perm[0]) == 0)) {
+          int k2 = ( k + 1) >> 1;
+          for (int i = 0; i < k2; i++) {
+            int temp = perm[i];
+            perm[i] = perm[k - i];
+            perm[k - i] = temp;
+          }
+          flipsCount++;
+        }
+
+        if (flipsCount > maxFlipsCount) {
+          maxFlipsCount = flipsCount;
+          for (int i = 0; i < n; i++) {
+            maxPerm[i] = perm1[i];
+          }
+        }
+      }
+
+      while (true) {
+        if (r == n) {
+          return maxFlipsCount;
+        }
+        int perm0 = perm1[0];
+        int i = 0;
+        while (i < r) {
+          int j = i + 1;
+          perm1[i] = perm1[j];
+          i = j;
+        }
+        perm1[r] = perm0;
+
+        count[r] = count[r] - 1;
+        if (count[r] > 0) {
+          break;
+        }
+        r++;
+      }
+    }
+  }
+
+  public void timeAccessFannkuch(int iters) {
+    for (int i = 0; i < iters; i++) {
+      fannkuch(8);
+    }
+  }
+
+  public boolean verify() {
+    return fannkuch(8) == ACCESS_FANNKUCH_EXPECTED;
+  }
+
+  public static void main(String[] args) {
+    AccessFannkuch obj = new AccessFannkuch();
+    final long before = System.currentTimeMillis();
+    obj.timeAccessFannkuch(109);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/algorithm/AccessFankuch: " + (after - before));
+  }
+}
+
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/BitopsNSieve.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/BitopsNSieve.java
new file mode 100644
index 0000000..961d127
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/BitopsNSieve.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/bitops-nsieve-bits.js
+ *
+ * Description:     Bitops prime number sieve, used for finding prime numbers.
+ * Main Focus:      Bitwise operations.
+ *
+ */
+
+// The Great Computer Language Shootout
+//  http://shootout.alioth.debian.org/
+//
+//  Contributed by Ian Osgood
+
+// http://benchmarksgame.alioth.debian.org/license.html  (BSD 3-clause license)
+// See NOTICE file for the license
+
+package art_benchmarks.algorithm;
+
+import java.lang.Integer;
+import java.lang.System;
+
+public class BitopsNSieve {
+  private static final int BITOPS_NSIEVE_EXPECTED = -1431657430;
+
+  // As per the original, this function is not used.
+  private String pad(int n, int width) {
+    String s = Integer.toString(n);
+    while (s.length() < width) {
+      s = ' ' + s;
+    }
+    return s;
+  }
+
+  private void primes(int[] isPrime, int n) {
+    // As per the original, this variable can be optimised out.
+    int count = 0;
+    final int m = 10000 << n;
+    final int size = m + 31 >> 5;
+
+    for (int i = 0; i < size; i++) {
+      isPrime[i] = 0xffffffff;
+    }
+
+    for (int i = 2; i < m; i++) {
+      if ((isPrime[i >> 5] & 1 << (i & 31)) != 0) {
+        for (int j = i + 1; j < m; j += i) {
+          isPrime[j >> 5] &= ~ (1 << (j & 31));
+        }
+        count++;
+      }
+    }
+  }
+
+  private int[] sieve() {
+    int[] isPrime = null;
+    // As per the original, this loop will have just one iteration.
+    for (int i = 4; i <= 4; i++) {
+      isPrime = new int[(10000 << i) + 31 >> 5];
+      primes(isPrime, i);
+    }
+    return isPrime;
+  }
+
+  public void timeBitopsNSieve(int iters) {
+    for (int i = 0; i < iters; i++) {
+      sieve();
+    }
+  }
+
+  public boolean verify() {
+    int output = 0;
+    int[] result = sieve();
+
+    for (int i = 0; i < result.length; i++) {
+      output += result[i];
+    }
+    return output == BITOPS_NSIEVE_EXPECTED;
+  }
+
+  public static void main(String[] argv) {
+    BitopsNSieve obj = new BitopsNSieve();
+    final long before = System.currentTimeMillis();
+    obj.timeBitopsNSieve(189);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/algorithm/BitopsNSieve: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/CryptoMD5.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/CryptoMD5.java
new file mode 100644
index 0000000..3c21d90
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/CryptoMD5.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/crypto-md5.js
+ *
+ * Description:       Encrypts a text fragment using the MD5 message-digest
+ *                    algorithm, producing a 128-bit hash value.
+ * Main Focus:        Bit operations.
+ */
+
+/*
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+/*
+ * Copyright (c) 1998 - 2009, Paul Johnston & Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of the author nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific
+ * prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package art_benchmarks.algorithm;
+
+import java.lang.System;
+
+public class CryptoMD5 {
+  private static String TEXT;
+  private static final String TEXT_FRAGMENT =
+      "Rebellious subjects, enemies to peace,\n" +
+      "Profaners of this neighbour-stained steel,--\n" +
+      "Will they not hear? What, ho! you men, you beasts,\n" +
+      "That quench the fire of your pernicious rage\n" +
+      "With purple fountains issuing from your veins,\n" +
+      "On pain of torture, from those bloody hands\n" +
+      "Throw your mistemper'd weapons to the ground,\n" +
+      "And hear the sentence of your moved prince.\n" +
+      "Three civil brawls, bred of an airy word,\n" +
+      "By thee, old Capulet, and Montague,\n" +
+      "Have thrice disturb'd the quiet of our streets,\n" +
+      "And made Verona's ancient citizens\n" +
+      "Cast by their grave beseeming ornaments,\n" +
+      "To wield old partisans, in hands as old,\n" +
+      "Canker'd with peace, to part your canker'd hate:\n" +
+      "If ever you disturb our streets again,\n" +
+      "Your lives shall pay the forfeit of the peace.\n" +
+      "For this time, all the rest depart away:\n" +
+      "You Capulet; shall go along with me:\n" +
+      "And, Montague, come you this afternoon,\n" +
+      "To know our further pleasure in this case,\n" +
+      "To old Free-town, our common judgment-place.\n" +
+      "Once more, on pain of death, all men depart.";
+
+  private static final String MD5_EXPECTED =
+      "a831e91e0f70eddcb70dc61c6f82f6cd";
+
+  // bits per input character. 8 - ASCII; 16 - Unicode
+  private static final int CHRSZ = 8;
+  private static final int MASK = (1 << CHRSZ) - 1;
+
+  // to convert binary values into a hex string digest
+  private static final boolean HEX_UPPER_CASE = false;
+  private static final String HEX_CHARS =
+      HEX_UPPER_CASE ? "0123456789ABCDEF" : "0123456789abcdef";
+
+  static {
+    TEXT = TEXT_FRAGMENT;
+
+    for (int i = 0; i < 4; ++i) {
+      TEXT += TEXT;
+    }
+  }
+
+  /* Bitwise rotate a 32-bit number to the left. */
+  private int bitRotateLeft(int num, int cnt) {
+    return (num << cnt) | (num >>> (32 - cnt));
+  }
+
+  /*
+   * Convert a string to an array of little-endian words
+   * If CHRSZ is ASCII, characters >255 have their hi-byte silently ignored.
+   */
+  private int[] str2binl(String str, int padding) {
+    final int len = str.length() / 4;
+    int paddedLen = len;
+    final int rem = paddedLen % padding;
+
+    if (padding != 0 && rem != 0) {
+      paddedLen += padding - rem;
+    }
+
+    int[] bin = new int[paddedLen];
+
+    for (int i = 0; i < str.length() * CHRSZ; i += CHRSZ) {
+      bin[i >> 5] |= (str.charAt(i / CHRSZ) & MASK) << (i % 32);
+    }
+
+    return bin;
+  }
+
+  /* Default padding of 16 as in the original Javascript implementation. */
+  private int[] str2binl(String str) {
+    return str2binl(str, 16);
+  }
+
+  /* Convert an array of little-endian words to a hex string. */
+  private String binl2hex(int[] bin) {
+    String str = "";
+
+    for (int i = 0; i < bin.length * 4; i++) {
+      str += HEX_CHARS.charAt((bin[i >> 2] >> ((i % 4) * 8 + 4)) & 0xF);
+      str += HEX_CHARS.charAt((bin[i >> 2] >> ((i % 4) * 8)) & 0xF);
+    }
+
+    return str;
+  }
+
+  private int md5Common(int q, int a, int b, int x, int s, int t) {
+    return bitRotateLeft(a + q + x + t, s) + b;
+  }
+
+  private int md5FF(int a, int b, int c, int d, int x, int s, int t) {
+    return md5Common((b & c) | ((~b) & d), a, b, x, s, t);
+  }
+
+  private int md5GG(int a, int b, int c, int d, int x, int s, int t) {
+    return md5Common((b & d) | (c & (~d)), a, b, x, s, t);
+  }
+
+  private int md5HH(int a, int b, int c, int d, int x, int s, int t) {
+    return md5Common(b ^ c ^ d, a, b, x, s, t);
+  }
+
+  private int md5II(int a, int b, int c, int d, int x, int s, int t) {
+    return md5Common(c ^ (b | (~d)), a, b, x, s, t);
+  }
+
+  private int[] coreMD5(int[] x, int len) {
+    /* append padding */
+    x[len >> 5] |= 0x80 << ((len) % 32);
+    x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+    int a =  1732584193;
+    int b = -271733879;
+    int c = -1732584194;
+    int d =  271733878;
+
+    for (int i = 0; i < x.length; i += 16) {
+      final int olda = a;
+      final int oldb = b;
+      final int oldc = c;
+      final int oldd = d;
+
+      a = md5FF(a, b, c, d, x[i + 0], 7 , -680876936);
+      d = md5FF(d, a, b, c, x[i + 1], 12, -389564586);
+      c = md5FF(c, d, a, b, x[i + 2], 17,  606105819);
+      b = md5FF(b, c, d, a, x[i + 3], 22, -1044525330);
+      a = md5FF(a, b, c, d, x[i + 4], 7 , -176418897);
+      d = md5FF(d, a, b, c, x[i + 5], 12,  1200080426);
+      c = md5FF(c, d, a, b, x[i + 6], 17, -1473231341);
+      b = md5FF(b, c, d, a, x[i + 7], 22, -45705983);
+      a = md5FF(a, b, c, d, x[i + 8], 7 ,  1770035416);
+      d = md5FF(d, a, b, c, x[i + 9], 12, -1958414417);
+      c = md5FF(c, d, a, b, x[i + 10], 17, -42063);
+      b = md5FF(b, c, d, a, x[i + 11], 22, -1990404162);
+      a = md5FF(a, b, c, d, x[i + 12], 7 ,  1804603682);
+      d = md5FF(d, a, b, c, x[i + 13], 12, -40341101);
+      c = md5FF(c, d, a, b, x[i + 14], 17, -1502002290);
+      b = md5FF(b, c, d, a, x[i + 15], 22,  1236535329);
+
+      a = md5GG(a, b, c, d, x[i + 1], 5 , -165796510);
+      d = md5GG(d, a, b, c, x[i + 6], 9 , -1069501632);
+      c = md5GG(c, d, a, b, x[i + 11], 14,  643717713);
+      b = md5GG(b, c, d, a, x[i + 0], 20, -373897302);
+      a = md5GG(a, b, c, d, x[i + 5], 5 , -701558691);
+      d = md5GG(d, a, b, c, x[i + 10], 9 ,  38016083);
+      c = md5GG(c, d, a, b, x[i + 15], 14, -660478335);
+      b = md5GG(b, c, d, a, x[i + 4], 20, -405537848);
+      a = md5GG(a, b, c, d, x[i + 9], 5 ,  568446438);
+      d = md5GG(d, a, b, c, x[i + 14], 9 , -1019803690);
+      c = md5GG(c, d, a, b, x[i + 3], 14, -187363961);
+      b = md5GG(b, c, d, a, x[i + 8], 20,  1163531501);
+      a = md5GG(a, b, c, d, x[i + 13], 5 , -1444681467);
+      d = md5GG(d, a, b, c, x[i + 2], 9 , -51403784);
+      c = md5GG(c, d, a, b, x[i + 7], 14,  1735328473);
+      b = md5GG(b, c, d, a, x[i + 12], 20, -1926607734);
+
+      a = md5HH(a, b, c, d, x[i + 5], 4 , -378558);
+      d = md5HH(d, a, b, c, x[i + 8], 11, -2022574463);
+      c = md5HH(c, d, a, b, x[i + 11], 16,  1839030562);
+      b = md5HH(b, c, d, a, x[i + 14], 23, -35309556);
+      a = md5HH(a, b, c, d, x[i + 1], 4 , -1530992060);
+      d = md5HH(d, a, b, c, x[i + 4], 11,  1272893353);
+      c = md5HH(c, d, a, b, x[i + 7], 16, -155497632);
+      b = md5HH(b, c, d, a, x[i + 10], 23, -1094730640);
+      a = md5HH(a, b, c, d, x[i + 13], 4 ,  681279174);
+      d = md5HH(d, a, b, c, x[i + 0], 11, -358537222);
+      c = md5HH(c, d, a, b, x[i + 3], 16, -722521979);
+      b = md5HH(b, c, d, a, x[i + 6], 23,  76029189);
+      a = md5HH(a, b, c, d, x[i + 9], 4 , -640364487);
+      d = md5HH(d, a, b, c, x[i + 12], 11, -421815835);
+      c = md5HH(c, d, a, b, x[i + 15], 16,  530742520);
+      b = md5HH(b, c, d, a, x[i + 2], 23, -995338651);
+
+      a = md5II(a, b, c, d, x[i + 0], 6 , -198630844);
+      d = md5II(d, a, b, c, x[i + 7], 10,  1126891415);
+      c = md5II(c, d, a, b, x[i + 14], 15, -1416354905);
+      b = md5II(b, c, d, a, x[i + 5], 21, -57434055);
+      a = md5II(a, b, c, d, x[i + 12], 6 ,  1700485571);
+      d = md5II(d, a, b, c, x[i + 3], 10, -1894986606);
+      c = md5II(c, d, a, b, x[i + 10], 15, -1051523);
+      b = md5II(b, c, d, a, x[i + 1], 21, -2054922799);
+      a = md5II(a, b, c, d, x[i + 8], 6 ,  1873313359);
+      d = md5II(d, a, b, c, x[i + 15], 10, -30611744);
+      c = md5II(c, d, a, b, x[i + 6], 15, -1560198380);
+      b = md5II(b, c, d, a, x[i + 13], 21,  1309151649);
+      a = md5II(a, b, c, d, x[i + 4], 6 , -145523070);
+      d = md5II(d, a, b, c, x[i + 11], 10, -1120210379);
+      c = md5II(c, d, a, b, x[i + 2], 15,  718787259);
+      b = md5II(b, c, d, a, x[i + 9], 21, -343485551);
+
+      a = a + olda;
+      b = b + oldb;
+      c = c + oldc;
+      d = d + oldd;
+    }
+    return new int[] {a, b, c, d};
+  }
+
+  public String hexMD5(String stringData) {
+    int[] bin = str2binl(stringData);
+    int[] md5 = coreMD5(bin, stringData.length() * CHRSZ);
+    String hex = binl2hex(md5);
+    return hex;
+  }
+
+  public void timeHexMD5(int iters) {
+    for (int i = 0; i < iters; i++) {
+      hexMD5(TEXT);
+    }
+  }
+
+  public boolean verify() {
+    String md5Output = hexMD5(TEXT);
+    return md5Output.equals(MD5_EXPECTED);
+  }
+
+  public static void main(String[] argv) {
+    CryptoMD5 obj = new CryptoMD5();
+    final long before = System.currentTimeMillis();
+    obj.timeHexMD5(2305);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/algorithm/CryptoMD5: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/CryptoSHA1.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/CryptoSHA1.java
new file mode 100644
index 0000000..3a24f09
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/CryptoSHA1.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/crypto-sha1.js
+ *
+ * Description:       Encrypts a text fragment using the SHA1 Secure Hash
+ *                    Algorithm, producing a 160-bit hash value.
+ * Main Focus:        Bit operations.
+ *
+ */
+
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+/*
+ * Copyright (c) 1998 - 2009, Paul Johnston & Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of the author nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific
+ * prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package art_benchmarks.algorithm;
+
+import java.lang.System;
+
+public class CryptoSHA1 {
+  private static String TEXT;
+  private static final String TEXT_FRAGMENT =
+      "Two households, both alike in dignity,\n" +
+      "In fair Verona, where we lay our scene,\n" +
+      "From ancient grudge break to new mutiny,\n" +
+      "Where civil blood makes civil hands unclean.\n" +
+      "From forth the fatal loins of these two foes\n" +
+      "A pair of star-cross'd lovers take their life;\n" +
+      "Whole misadventured piteous overthrows\n" +
+      "Do with their death bury their parents' strife.\n" +
+      "The fearful passage of their death-mark'd love,\n" +
+      "And the continuance of their parents' rage,\n" +
+      "Which, but their children's end, nought could remove,\n" +
+      "Is now the two hours' traffic of our stage;\n" +
+      "The which if you with patient ears attend,\n" +
+      "What here shall miss, our toil shall strive to mend.";
+
+  private static final String SHA1_EXPECTED =
+      "2524d264def74cce2498bf112bedf00e6c0b796d";
+
+  // bits per input character. 8 - ASCII; 16 - Unicode
+  private static final int CHRSZ = 8;
+  private static final int MASK = (1 << CHRSZ) - 1;
+
+  // to convert binary values into a hex string digest
+  private static final boolean HEX_UPPER_CASE = false;
+  private static final String HEX_CHARS =
+      HEX_UPPER_CASE ? "0123456789ABCDEF" : "0123456789abcdef";
+
+  static {
+    TEXT = TEXT_FRAGMENT;
+
+    for (int i = 0; i < 4; ++i) {
+      TEXT += TEXT;
+    }
+  }
+
+  /*
+   * Convert a string to an array of little-endian words
+   * If CHRSZ is ASCII, characters >255 have their hi-byte silently ignored.
+   */
+  private int[] str2binb(String str, int padding) {
+    final int len = str.length() / 4;
+    int paddedLen = len;
+    final int rem = paddedLen % padding;
+
+    if (padding != 0 && rem != 0) {
+      paddedLen += padding - rem;
+    }
+
+    int[] bin = new int[paddedLen];
+
+    for (int i = 0; i < str.length() * CHRSZ; i += CHRSZ) {
+      bin[i >> 5] |= (str.charAt(i / CHRSZ) & MASK) << (32 - CHRSZ - i % 32);
+    }
+
+    return bin;
+  }
+
+  /* Default padding of 16 as in the original Javascript implementation. */
+  private int[] str2binb(String str) {
+    return str2binb(str, 16);
+  }
+
+  /* Convert an array of little-endian words to a hex string. */
+  private String binb2hex(int[] bin) {
+    String str = "";
+
+    for (int i = 0; i < bin.length * 4; i++) {
+      str += HEX_CHARS.charAt((bin[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xF);
+      str += HEX_CHARS.charAt((bin[i >> 2] >> ((3 - i % 4) * 8)) & 0xF);
+    }
+
+    return str;
+  }
+
+  /*
+   * Bitwise rotate a 32-bit number to the left
+   * TODO: Name
+   */
+  private int bitRotateLeft(int num, int cnt) {
+    return (num << cnt) | (num >>> (32 - cnt));
+  }
+
+  /*
+   * Perform the appropriate triplet combination function for the current
+   * iteration
+   */
+  private int sha1FT(int t, int b, int c, int d) {
+    if (t < 20) {
+      return (b & c) | ((~b) & d);
+    } else if (t < 40) {
+      return b ^ c ^ d;
+    } else if (t < 60) {
+      return (b & c) | (b & d) | (c & d);
+    } else {
+      return b ^ c ^ d;
+    }
+  }
+
+  /*
+   * Determine the appropriate additive constant for the current iteration
+   */
+  private int sha1KT(int t) {
+    return (t < 20) ? 1518500249 : ((t < 40) ? 1859775393 :
+        ((t < 60) ? -1894007588 : -899497514));
+  }
+
+  private int[] coreSHA1(int[] x, int len) {
+    /* append padding */
+    x[len >> 5] |= 0x80 << (24 - len % 32);
+    x[(((len + 64) >> 9) << 4) + 15] = len;
+
+    int[] w = new int[80];
+    int a =  1732584193;
+    int b = -271733879;
+    int c = -1732584194;
+    int d =  271733878;
+    int e = -1009589776;
+
+    for (int i = 0; i < x.length; i += 16) {
+      final int olda = a;
+      final int oldb = b;
+      final int oldc = c;
+      final int oldd = d;
+      final int olde = e;
+
+      for (int j = 0; j < 80; j++) {
+        if (j < 16) {
+          w[j] = x[i + j];
+        } else {
+          w[j] = bitRotateLeft(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
+        }
+        int t = bitRotateLeft(a, 5) + sha1FT(j, b, c, d) + e + w[j] + sha1KT(j);
+
+        e = d;
+        d = c;
+        c = bitRotateLeft(b, 30);
+        b = a;
+        a = t;
+      }
+      a = a + olda;
+      b = b + oldb;
+      c = c + oldc;
+      d = d + oldd;
+      e = e + olde;
+    }
+    return new int[] {a, b, c, d, e};
+  }
+
+  public String hexSHA1(String stringData) {
+    int[] bin = str2binb(stringData);
+    int[] sha1 = coreSHA1(bin, stringData.length() * CHRSZ);
+    String hex = binb2hex(sha1);
+    return hex;
+  }
+
+  public void timeHexSHA1(int iters) {
+    for (int i = 0; i < iters; i++) {
+      hexSHA1(TEXT);
+    }
+  }
+
+  public boolean verify() {
+    String sha1Output = hexSHA1(TEXT);
+    return sha1Output.equals(SHA1_EXPECTED);
+  }
+
+  public static void main(String[] argv) {
+    CryptoSHA1 obj = new CryptoSHA1();
+    final long before = System.currentTimeMillis();
+    obj.timeHexSHA1(1600);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/algorithm/CryptoSHA1: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/DeltaBlue.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/DeltaBlue.java
new file mode 100644
index 0000000..a4a5a99
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/DeltaBlue.java
@@ -0,0 +1,1070 @@
+/*
+ * CL_SUN_COPYRIGHT_JVM_BEGIN
+ *   If you or the company you represent has a separate agreement with both
+ *   CableLabs and Sun concerning the use of this code, your rights and
+ *   obligations with respect to this code shall be as set forth therein. No
+ *   license is granted hereunder for any other purpose.
+ * CL_SUN_COPYRIGHT_JVM_END
+*/
+
+// CHECKSTYLE.OFF: .*
+/*
+ * @(#)DeltaBlue.java	1.6 06/10/10
+ *
+ * Copyright  1990-2006 Sun Microsystems, Inc. All Rights Reserved.  
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER  
+ *   
+ * This program is free software; you can redistribute it and/or  
+ * modify it under the terms of the GNU General Public License version  
+ * 2 only, as published by the Free Software Foundation.   
+ *   
+ * This program is distributed in the hope that it will be useful, but  
+ * WITHOUT ANY WARRANTY; without even the implied warranty of  
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  
+ * General Public License version 2 for more details (a copy is  
+ * included at /legal/license.txt).   
+ *   
+ * You should have received a copy of the GNU General Public License  
+ * version 2 along with this work; if not, write to the Free Software  
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  
+ * 02110-1301 USA   
+ *   
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa  
+ * Clara, CA 95054 or visit www.sun.com if you need additional  
+ * information or have any questions. 
+ *
+ */
+/*
+
+  This is a Java implemention of the DeltaBlue algorithm described in:
+    "The DeltaBlue Algorithm: An Incremental Constraint Hierarchy Solver"
+    by Bjorn N. Freeman-Benson and John Maloney
+    January 1990 Communications of the ACM,
+    also available as University of Washington TR 89-08-06.
+
+  This implementation by Mario Wolczko, Sun Microsystems, Sep 1996,
+  based on the Smalltalk implementation by John Maloney.
+
+*/
+
+/*
+ * The original file is available at:
+ * https://github.com/xxgreg/deltablue/blob/master/DeltaBlue.java
+ *
+ * Modifications:
+ * (1) Added timeDeltaBlue() method for running with different iterations.
+ * (2) Added verifyDeltaBlue() method for verifying the benchmark.
+ * (3) Changed main() method.
+ * (4) On test failure, change from 'exit(1)' to print to stdout.
+ */
+
+//package COM.sun.labs.kanban.DeltaBlue;
+package art_benchmarks.algorithm;
+
+import java.util.ArrayList;
+
+//import Benchmark;
+
+
+
+/* 
+   Strengths are used to measure the relative importance of constraints.
+   New strengths may be inserted in the strength hierarchy without
+   disrupting current constraints.  Strengths cannot be created outside
+   this class, so pointer comparison can be used for value comparison.
+ */
+
+class Strength {
+
+  private int strengthValue;
+  private String name;
+
+  private Strength(int strengthValue, String name)
+  {
+    this.strengthValue= strengthValue;
+    this.name= name;
+  }
+
+  public static boolean stronger(Strength s1, Strength s2)
+  {
+    return s1.strengthValue < s2.strengthValue;
+  }
+
+  public static boolean weaker(Strength s1, Strength s2)
+  {
+    return s1.strengthValue > s2.strengthValue;
+  }
+
+  public static Strength weakestOf(Strength s1, Strength s2)
+  {
+    return weaker(s1, s2) ? s1 : s2;
+  }
+
+  public static Strength strongest(Strength s1, Strength s2)
+  {
+    return stronger(s1, s2) ? s1 : s2;
+  }
+
+  // for iteration
+  public Strength nextWeaker()
+  {
+    switch (strengthValue) {
+      case 0: return weakest;
+      case 1: return weakDefault;
+      case 2: return normal;
+      case 3: return strongDefault;
+      case 4: return preferred;
+      case 5: return strongPreferred;
+
+      case 6: 
+      default:
+              System.err.println("Invalid call to nextStrength()!");
+              System.exit(1);
+              return null;
+    }
+  }
+
+  // Strength constants
+  public final static Strength required       = new Strength(0, "required");
+  public final static Strength strongPreferred= new Strength(1, "strongPreferred");
+  public final static Strength preferred      = new Strength(2, "preferred");
+  public final static Strength strongDefault  = new Strength(3, "strongDefault");
+  public final static Strength normal	      = new Strength(4, "normal");
+  public final static Strength weakDefault    = new Strength(5, "weakDefault");
+  public final static Strength weakest	      = new Strength(6, "weakest");
+
+  public void print()
+  {
+    System.out.print("strength[" + Integer.toString(strengthValue) + "]");
+  }
+}
+
+
+
+
+//------------------------------ variables ------------------------------
+
+// I represent a constrained variable. In addition to my value, I
+// maintain the structure of the constraint graph, the current
+// dataflow graph, and various parameters of interest to the DeltaBlue
+// incremental constraint solver.
+
+class Variable {
+
+  public int value;               // my value; changed by constraints
+  public ArrayList<Constraint> constraints;      // normal constraints that reference me
+  public Constraint determinedBy; // the constraint that currently determines
+  // my value (or null if there isn't one)
+  public int mark;                // used by the planner to mark constraints
+  public Strength walkStrength;   // my walkabout strength
+  public boolean stay;            // true if I am a planning-time constant
+  public String	name;             // a symbolic name for reporting purposes
+
+
+  private Variable(String name, int initialValue, Strength walkStrength,
+      int nconstraints)
+  {
+    value= initialValue;
+    constraints= new ArrayList<Constraint>(nconstraints);
+    determinedBy= null;
+    mark= 0;
+    this.walkStrength= walkStrength;
+    stay= true;
+    this.name= name;
+  }
+
+  public Variable(String name, int value)
+  {
+    this(name, value, Strength.weakest, 2);
+  }
+
+  public Variable(String name)
+  {
+    this(name, 0, Strength.weakest, 2);
+  }
+
+  public void print()
+  {
+    System.out.print(name + "(");
+    walkStrength.print();
+    System.out.print("," + value + ")");
+  }
+
+  // Add the given constraint to the set of all constraints that refer to me.
+  public void addConstraint(Constraint c)
+  {
+    constraints.add(c);
+  }
+
+  // Remove all traces of c from this variable.
+  public void removeConstraint(Constraint c)
+  {
+    constraints.remove(c);
+    if (determinedBy == c) determinedBy= null;
+  }
+
+  // Attempt to assign the given value to me using the given strength.
+  public void setValue(int value, Strength strength)
+  {
+    EditConstraint e= new EditConstraint(this, strength);
+    if (e.isSatisfied()) {
+      this.value= value;
+      DeltaBlue.planner.propagateFrom(this);
+    }
+    e.destroyConstraint();
+  }
+
+}
+
+
+
+
+//------------------------ constraints ------------------------------------
+
+// I am an abstract class representing a system-maintainable
+// relationship (or "constraint") between a set of variables. I supply
+// a strength instance variable; concrete subclasses provide a means
+// of storing the constrained variables and other information required
+// to represent a constraint.
+
+abstract class Constraint {
+
+  public Strength strength; // the strength of this constraint
+
+  protected Constraint() {} // this has to be here because of
+  // Java's constructor idiocy.
+
+  protected Constraint(Strength strength)
+  {
+    this.strength= strength;
+  }
+
+  // Answer true if this constraint is satisfied in the current solution.
+  public abstract boolean isSatisfied();
+
+  // Record the fact that I am unsatisfied.
+  public abstract void markUnsatisfied();
+
+  // Normal constraints are not input constraints. An input constraint
+  // is one that depends on external state, such as the mouse, the
+  // keyboard, a clock, or some arbitrary piece of imperative code.
+  public boolean isInput() { return false; }
+
+  // Activate this constraint and attempt to satisfy it.
+  protected void addConstraint()
+  {
+    addToGraph();
+    DeltaBlue.planner.incrementalAdd(this);
+  }
+
+  // Deactivate this constraint, remove it from the constraint graph,
+  // possibly causing other constraints to be satisfied, and destroy
+  // it.
+  public void destroyConstraint()
+  {
+    if (isSatisfied()) DeltaBlue.planner.incrementalRemove(this);
+    removeFromGraph();
+  }
+
+  // Add myself to the constraint graph.
+  public abstract void addToGraph();
+
+  // Remove myself from the constraint graph.
+  public abstract void removeFromGraph();
+
+  // Decide if I can be satisfied and record that decision. The output
+  // of the choosen method must not have the given mark and must have
+  // a walkabout strength less than that of this constraint.
+  protected abstract void chooseMethod(int mark);
+
+  // Set the mark of all input from the given mark.
+  protected abstract void markInputs(int mark);
+
+  // Assume that I am satisfied. Answer true if all my current inputs
+  // are known. A variable is known if either a) it is 'stay' (i.e. it
+  // is a constant at plan execution time), b) it has the given mark
+  // (indicating that it has been computed by a constraint appearing
+  // earlier in the plan), or c) it is not determined by any
+  // constraint.
+  public abstract boolean inputsKnown(int mark);
+
+  // Answer my current output variable. Raise an error if I am not
+  // currently satisfied.
+  public abstract Variable output();
+
+  // Attempt to find a way to enforce this constraint. If successful,
+  // record the solution, perhaps modifying the current dataflow
+  // graph. Answer the constraint that this constraint overrides, if
+  // there is one, or nil, if there isn't.
+  // Assume: I am not already satisfied.
+  //
+  public Constraint satisfy(int mark)
+  {
+    chooseMethod(mark);
+    if (!isSatisfied()) {
+      if (strength == Strength.required) {
+        DeltaBlue.error("Could not satisfy a required constraint");
+      }
+      return null;
+    }
+    // constraint can be satisfied
+    // mark inputs to allow cycle detection in addPropagate
+    markInputs(mark);
+    Variable out= output();
+    Constraint overridden= out.determinedBy;
+    if (overridden != null) overridden.markUnsatisfied();
+    out.determinedBy= this;
+    if (!DeltaBlue.planner.addPropagate(this, mark)) {
+      System.out.println("Cycle encountered");
+      return null;
+    }
+    out.mark= mark;
+    return overridden;
+  }
+
+  // Enforce this constraint. Assume that it is satisfied.
+  public abstract void execute();
+
+  // Calculate the walkabout strength, the stay flag, and, if it is
+  // 'stay', the value for the current output of this
+  // constraint. Assume this constraint is satisfied.
+  public abstract void recalculate();
+
+  protected abstract void printInputs();
+
+  protected void printOutput() { output().print(); }
+
+  public void print()
+  {
+    int i, outIndex;
+
+    if (!isSatisfied()) {
+      System.out.print("Unsatisfied");
+    } else {
+      System.out.print("Satisfied(");
+      printInputs();
+      System.out.print(" -> ");
+      printOutput();
+      System.out.print(")");
+    }
+    System.out.print("\n");
+  }
+
+}
+
+
+
+//-------------unary constraints-------------------------------------------
+
+// I am an abstract superclass for constraints having a single
+// possible output variable.
+//
+abstract class UnaryConstraint extends Constraint {
+
+  protected Variable myOutput; // possible output variable
+  protected boolean satisfied; // true if I am currently satisfied
+
+  protected UnaryConstraint(Variable v, Strength strength)
+  {
+    super(strength);
+    myOutput= v;
+    satisfied= false;
+    addConstraint();
+  }
+
+  // Answer true if this constraint is satisfied in the current solution.
+  public boolean isSatisfied() { return satisfied; }
+
+  // Record the fact that I am unsatisfied.
+  public void markUnsatisfied() { satisfied= false; }
+
+  // Answer my current output variable.
+  public Variable output() { return myOutput; }
+
+  // Add myself to the constraint graph.
+  public void addToGraph()
+  {
+    myOutput.addConstraint(this);
+    satisfied= false;
+  }
+
+  // Remove myself from the constraint graph.
+  public void removeFromGraph()
+  {
+    if (myOutput != null) myOutput.removeConstraint(this);
+    satisfied= false;
+  }
+
+  // Decide if I can be satisfied and record that decision.
+  protected void chooseMethod(int mark)
+  {
+    satisfied=    myOutput.mark != mark
+      && Strength.stronger(strength, myOutput.walkStrength);
+  }
+
+  protected void markInputs(int mark) {}   // I have no inputs
+
+  public boolean inputsKnown(int mark) { return true; }
+
+  // Calculate the walkabout strength, the stay flag, and, if it is
+  // 'stay', the value for the current output of this
+  // constraint. Assume this constraint is satisfied."
+  public void recalculate()
+  {
+    myOutput.walkStrength= strength;
+    myOutput.stay= !isInput();
+    if (myOutput.stay) execute(); // stay optimization
+  }
+
+  protected void printInputs() {} // I have no inputs
+
+}
+
+
+// I am a unary input constraint used to mark a variable that the
+// client wishes to change.
+//
+class EditConstraint extends UnaryConstraint {
+
+  public EditConstraint(Variable v, Strength str) { super(v, str); }
+
+  // I indicate that a variable is to be changed by imperative code.
+  public boolean isInput() { return true; }
+
+  public void execute() {} // Edit constraints do nothing.
+
+}
+
+// I mark variables that should, with some level of preference, stay
+// the same. I have one method with zero inputs and one output, which
+// does nothing. Planners may exploit the fact that, if I am
+// satisfied, my output will not change during plan execution. This is
+// called "stay optimization".
+//
+class StayConstraint extends UnaryConstraint {
+
+  // Install a stay constraint with the given strength on the given variable.
+  public StayConstraint(Variable v, Strength str) { super(v, str); }
+
+  public void execute() {} // Stay constraints do nothing.
+
+}
+
+
+
+
+//-------------binary constraints-------------------------------------------
+
+
+// I am an abstract superclass for constraints having two possible
+// output variables.
+//
+abstract class BinaryConstraint extends Constraint {
+
+  protected Variable v1, v2; // possible output variables
+  protected byte direction; // one of the following...
+  protected static byte backward= -1;    // v1 is output
+  protected static byte nodirection= 0;  // not satisfied
+  protected static byte forward= 1;      // v2 is output
+
+  protected BinaryConstraint() {} // this has to be here because of
+  // Java's constructor idiocy.
+
+  protected BinaryConstraint(Variable var1, Variable var2, Strength strength) {
+    super(strength);
+    v1= var1;
+    v2= var2;
+    direction= nodirection;
+    addConstraint();
+  }
+
+  // Answer true if this constraint is satisfied in the current solution.
+  public boolean isSatisfied() { return direction != nodirection; }
+
+  // Add myself to the constraint graph.
+  public void addToGraph()
+  {
+    v1.addConstraint(this);
+    v2.addConstraint(this);
+    direction= nodirection;
+  }
+
+  // Remove myself from the constraint graph.
+  public void removeFromGraph()
+  {
+    if (v1 != null) v1.removeConstraint(this);
+    if (v2 != null) v2.removeConstraint(this);
+    direction= nodirection;
+  }
+
+  // Decide if I can be satisfied and which way I should flow based on
+  // the relative strength of the variables I relate, and record that
+  // decision.
+  //
+  protected void chooseMethod(int mark)
+  {
+    if (v1.mark == mark) 
+      direction=
+        v2.mark != mark && Strength.stronger(strength, v2.walkStrength)
+        ? forward : nodirection;
+
+    if (v2.mark == mark) 
+      direction=
+        v1.mark != mark && Strength.stronger(strength, v1.walkStrength)
+        ? backward : nodirection;
+
+    // If we get here, neither variable is marked, so we have a choice.
+    if (Strength.weaker(v1.walkStrength, v2.walkStrength))
+      direction=
+        Strength.stronger(strength, v1.walkStrength) ? backward : nodirection;
+    else
+      direction=
+        Strength.stronger(strength, v2.walkStrength) ? forward : nodirection;
+  }
+
+  // Record the fact that I am unsatisfied.
+  public void markUnsatisfied() { direction= nodirection; }
+
+  // Mark the input variable with the given mark.
+  protected void markInputs(int mark)
+  {
+    input().mark= mark;
+  }
+
+  public boolean inputsKnown(int mark)
+  {
+    Variable i= input();
+    return i.mark == mark || i.stay || i.determinedBy == null;
+  }
+
+  // Answer my current output variable.
+  public Variable output() { return direction==forward ? v2 : v1; }
+
+  // Answer my current input variable
+  public Variable input() { return direction==forward ? v1 : v2; }
+
+  // Calculate the walkabout strength, the stay flag, and, if it is
+  // 'stay', the value for the current output of this
+  // constraint. Assume this constraint is satisfied.
+  //
+  public void recalculate()
+  {
+    Variable in= input(), out= output();
+    out.walkStrength= Strength.weakestOf(strength, in.walkStrength);
+    out.stay= in.stay;
+    if (out.stay) execute();
+  }
+
+  protected void printInputs()
+  {
+    input().print();
+  }
+
+}
+
+
+// I constrain two variables to have the same value: "v1 = v2".
+//
+class EqualityConstraint extends BinaryConstraint {
+
+  // Install a constraint with the given strength equating the given variables.
+  public EqualityConstraint(Variable var1, Variable var2, Strength strength)
+  {
+    super(var1, var2, strength);
+  }
+
+  // Enforce this constraint. Assume that it is satisfied.
+  public void execute() {
+    output().value= input().value;
+  }
+
+}
+
+
+// I relate two variables by the linear scaling relationship: "v2 =
+// (v1 * scale) + offset". Either v1 or v2 may be changed to maintain
+// this relationship but the scale factor and offset are considered
+// read-only.
+//
+class ScaleConstraint extends BinaryConstraint {
+
+  protected Variable scale; // scale factor input variable
+  protected Variable offset; // offset input variable
+
+  // Install a scale constraint with the given strength on the given variables.
+  public ScaleConstraint(Variable src, Variable scale, Variable offset,
+      Variable dest, Strength strength)
+  {
+    // Curse this wretched language for insisting that constructor invocation
+    // must be the first thing in a method...
+    // ..because of that, we must copy the code from the inherited
+    // constructors.
+    this.strength= strength;
+    v1= src;
+    v2= dest;
+    direction= nodirection;
+    this.scale= scale;
+    this.offset= offset;
+    addConstraint();
+  }
+
+  // Add myself to the constraint graph.
+  public void addToGraph()
+  {
+    super.addToGraph();
+    scale.addConstraint(this);
+    offset.addConstraint(this);
+  }
+
+  // Remove myself from the constraint graph.
+  public void removeFromGraph()
+  {
+    super.removeFromGraph();
+    if (scale != null) scale.removeConstraint(this);
+    if (offset != null) offset.removeConstraint(this);
+  }
+
+  // Mark the inputs from the given mark.
+  protected void markInputs(int mark)
+  {
+    super.markInputs(mark);
+    scale.mark= offset.mark= mark;
+  }
+
+  // Enforce this constraint. Assume that it is satisfied.
+  public void execute()
+  {
+    if (direction == forward) 
+      v2.value= v1.value * scale.value + offset.value;
+    else
+      v1.value= (v2.value - offset.value) / scale.value;
+  }
+
+  // Calculate the walkabout strength, the stay flag, and, if it is
+  // 'stay', the value for the current output of this
+  // constraint. Assume this constraint is satisfied.
+  public void recalculate()
+  {
+    Variable in= input(), out= output();
+    out.walkStrength= Strength.weakestOf(strength, in.walkStrength);
+    out.stay= in.stay && scale.stay && offset.stay;
+    if (out.stay) execute(); // stay optimization
+  }
+}
+
+
+// ------------------------------------------------------------
+
+
+// A Plan is an ordered list of constraints to be executed in sequence
+// to resatisfy all currently satisfiable constraints in the face of
+// one or more changing inputs.
+
+class Plan {
+
+  private ArrayList<Constraint> v;
+
+  public Plan() { v= new ArrayList<Constraint>(); }
+
+  public void addConstraint(Constraint c) { v.add(c); }
+
+  public int size() { return v.size(); }
+
+  public Constraint constraintAt(int index) {
+    return v.get(index); }
+
+  public void execute()
+  {
+    for (int i= 0; i < size(); ++i) {
+      Constraint c= constraintAt(i);
+      c.execute();
+    }
+  }
+
+}
+
+
+// ------------------------------------------------------------
+
+// The DeltaBlue planner
+
+class Planner {
+
+  int currentMark= 0;
+
+  // Select a previously unused mark value.
+  private int newMark() { return ++currentMark; }
+
+  public Planner()
+  {
+    currentMark= 0;
+  }
+
+  // Attempt to satisfy the given constraint and, if successful,
+  // incrementally update the dataflow graph.  Details: If satifying
+  // the constraint is successful, it may override a weaker constraint
+  // on its output. The algorithm attempts to resatisfy that
+  // constraint using some other method. This process is repeated
+  // until either a) it reaches a variable that was not previously
+  // determined by any constraint or b) it reaches a constraint that
+  // is too weak to be satisfied using any of its methods. The
+  // variables of constraints that have been processed are marked with
+  // a unique mark value so that we know where we've been. This allows
+  // the algorithm to avoid getting into an infinite loop even if the
+  // constraint graph has an inadvertent cycle.
+  //
+  public void incrementalAdd(Constraint c)
+  {
+    int mark= newMark();
+    Constraint overridden= c.satisfy(mark);
+    while (overridden != null) {
+      overridden= overridden.satisfy(mark);
+    }
+  }
+
+
+  // Entry point for retracting a constraint. Remove the given
+  // constraint and incrementally update the dataflow graph.
+  // Details: Retracting the given constraint may allow some currently
+  // unsatisfiable downstream constraint to be satisfied. We therefore collect
+  // a list of unsatisfied downstream constraints and attempt to
+  // satisfy each one in turn. This list is traversed by constraint
+  // strength, strongest first, as a heuristic for avoiding
+  // unnecessarily adding and then overriding weak constraints.
+  // Assume: c is satisfied.
+  //
+  public void incrementalRemove(Constraint c)
+  {
+    Variable out= c.output();
+    c.markUnsatisfied();
+    c.removeFromGraph();
+    ArrayList<Constraint> unsatisfied= removePropagateFrom(out);
+    Strength strength= Strength.required;
+    do {
+      for (int i= 0; i < unsatisfied.size(); ++i) {
+        Constraint u= unsatisfied.get(i);
+        if (u.strength == strength)
+          incrementalAdd(u);
+      }
+      strength= strength.nextWeaker();
+    } while (strength != Strength.weakest);
+  }
+
+  // Recompute the walkabout strengths and stay flags of all variables
+  // downstream of the given constraint and recompute the actual
+  // values of all variables whose stay flag is true. If a cycle is
+  // detected, remove the given constraint and answer
+  // false. Otherwise, answer true.
+  // Details: Cycles are detected when a marked variable is
+  // encountered downstream of the given constraint. The sender is
+  // assumed to have marked the inputs of the given constraint with
+  // the given mark. Thus, encountering a marked node downstream of
+  // the output constraint means that there is a path from the
+  // constraint's output to one of its inputs.
+  //
+  public boolean addPropagate(Constraint c, int mark)
+  {
+    ArrayList<Constraint> todo= new ArrayList<Constraint>();
+    todo.add(c);
+    while (!todo.isEmpty()) {
+      Constraint d= todo.get(0);
+      todo.remove(0);
+      if (d.output().mark == mark) {
+        incrementalRemove(c);
+        return false;
+      }
+      d.recalculate();
+      addConstraintsConsumingTo(d.output(), todo);
+    }
+    return true;
+  }
+
+
+  // The given variable has changed. Propagate new values downstream.
+  public void propagateFrom(Variable v)
+  {
+    ArrayList<Constraint> todo= new ArrayList<Constraint>();
+    addConstraintsConsumingTo(v, todo);
+    while (!todo.isEmpty()) {
+      Constraint c= todo.get(0);
+      todo.remove(0);
+      c.execute();
+      addConstraintsConsumingTo(c.output(), todo);
+    }
+  }
+
+  // Update the walkabout strengths and stay flags of all variables
+  // downstream of the given constraint. Answer a collection of
+  // unsatisfied constraints sorted in order of decreasing strength.
+  //
+  protected ArrayList<Constraint> removePropagateFrom(Variable out)
+  {
+    out.determinedBy= null;
+    out.walkStrength= Strength.weakest;
+    out.stay= true;
+    ArrayList<Constraint> unsatisfied= new ArrayList<Constraint>();
+    ArrayList<Variable> todo= new ArrayList<Variable>();
+    todo.add(out);
+    while (!todo.isEmpty()) {
+      Variable v= todo.get(0);
+      todo.remove(0);
+      for (int i= 0; i < v.constraints.size(); ++i) {
+        Constraint c= v.constraints.get(i);
+        if (!c.isSatisfied())
+          unsatisfied.add(c);
+      }
+      Constraint determiningC= v.determinedBy;
+      for (int i= 0; i < v.constraints.size(); ++i) {
+        Constraint nextC= v.constraints.get(i);
+        if (nextC != determiningC && nextC.isSatisfied()) {
+          nextC.recalculate();
+          todo.add(nextC.output());
+        }
+      }
+    }
+    return unsatisfied;
+  }
+
+  // Extract a plan for resatisfaction starting from the outputs of
+  // the given constraints, usually a set of input constraints.
+  //
+  protected Plan extractPlanFromConstraints(ArrayList<Constraint> constraints)
+  {
+    ArrayList<Constraint> sources= new ArrayList<Constraint>();
+    for (int i= 0; i < constraints.size(); ++i) {
+      Constraint c= constraints.get(i);
+      if (c.isInput() && c.isSatisfied())
+        sources.add(c);
+    }
+    return makePlan(sources);
+  }
+
+  // Extract a plan for resatisfaction starting from the given source
+  // constraints, usually a set of input constraints. This method
+  // assumes that stay optimization is desired; the plan will contain
+  // only constraints whose output variables are not stay. Constraints
+  // that do no computation, such as stay and edit constraints, are
+  // not included in the plan.
+  // Details: The outputs of a constraint are marked when it is added
+  // to the plan under construction. A constraint may be appended to
+  // the plan when all its input variables are known. A variable is
+  // known if either a) the variable is marked (indicating that has
+  // been computed by a constraint appearing earlier in the plan), b)
+  // the variable is 'stay' (i.e. it is a constant at plan execution
+  // time), or c) the variable is not determined by any
+  // constraint. The last provision is for past states of history
+  // variables, which are not stay but which are also not computed by
+  // any constraint.
+  // Assume: sources are all satisfied.
+  //
+  protected Plan makePlan(ArrayList<Constraint> sources)
+  {
+    int mark= newMark();
+    Plan plan= new Plan();
+    ArrayList<Constraint> todo= sources;
+    while (!todo.isEmpty()) {
+      Constraint c= todo.get(0);
+      todo.remove(0);
+      if (c.output().mark != mark && c.inputsKnown(mark)) {
+        // not in plan already and eligible for inclusion
+        plan.addConstraint(c);
+        c.output().mark= mark;
+        addConstraintsConsumingTo(c.output(), todo);
+      }
+    }
+    return plan;
+  }
+
+  protected void addConstraintsConsumingTo(Variable v, ArrayList<Constraint> coll)
+  {
+    Constraint determiningC= v.determinedBy;
+    ArrayList<Constraint> cc= v.constraints;
+    for (int i= 0; i < cc.size(); ++i) {
+      Constraint c= cc.get(i);
+      if (c != determiningC && c.isSatisfied())
+        coll.add(c);
+    }
+  }
+
+}
+
+//------------------------------------------------------------
+
+public class DeltaBlue /* implements Benchmark */ {
+
+  private long total_ms;
+  public long getRunTime() { return total_ms; }
+
+  public static Planner planner;
+
+  public static void main_(String[] args) {
+    (new DeltaBlue()).inst_main(args);
+  }
+
+  public void inst_main(String args[])
+  {
+    int iterations= 1000;
+    String options = "";
+
+    if (args != null && args.length > 0)
+      iterations = Integer.parseInt(args[0]);
+
+    if (args != null && args.length > 1)
+      options = args[1];
+
+    long startTime= System.currentTimeMillis();
+    for (int j= 0; j < iterations; ++j) {
+      chainTest(100);
+      projectionTest(100);
+    }
+    long endTime= System.currentTimeMillis();
+    total_ms= endTime - startTime;
+    System.out.println("DeltaBlue\tJava\t" + options + "\t" + iterations + "x\t" + ((double)total_ms / iterations) + " ms");
+  }
+
+
+
+  //  This is the standard DeltaBlue benchmark. A long chain of
+  //  equality constraints is constructed with a stay constraint on
+  //  one end. An edit constraint is then added to the opposite end
+  //  and the time is measured for adding and removing this
+  //  constraint, and extracting and executing a constraint
+  //  satisfaction plan. There are two cases. In case 1, the added
+  //  constraint is stronger than the stay constraint and values must
+  //  propagate down the entire length of the chain. In case 2, the
+  //  added constraint is weaker than the stay constraint so it cannot
+  //  be accomodated. The cost in this case is, of course, very
+  //  low. Typical situations lie somewhere between these two
+  //  extremes.
+  //
+  private boolean chainTest(int n)
+  {
+    planner= new Planner();
+
+    Variable prev= null, first= null, last= null;
+
+    // Build chain of n equality constraints
+    for (int i= 0; i <= n; i++) {
+      String name= "v" + Integer.toString(i);
+      Variable v= new Variable(name);
+      if (prev != null)
+        new EqualityConstraint(prev, v, Strength.required);
+      if (i == 0) first= v;
+      if (i == n) last= v;
+      prev= v;
+    }
+
+    new StayConstraint(last, Strength.strongDefault);
+    Constraint editC= new EditConstraint(first, Strength.preferred);
+    ArrayList<Constraint> editV= new ArrayList<Constraint>();
+    editV.add(editC);
+    Plan plan= planner.extractPlanFromConstraints(editV);
+    for (int i= 0; i < 100; i++) {
+      first.value= i;
+      plan.execute();
+      if (last.value != i)
+        return false;
+    }
+    editC.destroyConstraint();
+    return true;
+  }
+
+
+  // This test constructs a two sets of variables related to each
+  // other by a simple linear transformation (scale and offset). The
+  // time is measured to change a variable on either side of the
+  // mapping and to change the scale and offset factors.
+  //
+  private boolean projectionTest(int n)
+  {
+    planner= new Planner();
+
+    Variable scale= new Variable("scale", 10);
+    Variable offset= new Variable("offset", 1000);
+    Variable src= null, dst= null;
+
+    ArrayList<Variable> dests= new ArrayList<Variable>();
+
+    for (int i= 0; i < n; ++i) {
+      src= new Variable("src" + Integer.toString(i), i);
+      dst= new Variable("dst" + Integer.toString(i), i);
+      dests.add(dst);
+      new StayConstraint(src, Strength.normal);
+      new ScaleConstraint(src, scale, offset, dst, Strength.required);
+    }
+
+    change(src, 17);
+    if (dst.value != 1170) return false;
+
+    change(dst, 1050);
+    if (src.value != 5) return false;
+
+    change(scale, 5);
+    for (int i= 0; i < n - 1; ++i) {
+      if ((dests.get(i)).value != i * 5 + 1000)
+        return false;
+    }
+
+    change(offset, 2000);
+    for (int i= 0; i < n - 1; ++i) {
+      if ((dests.get(i)).value != i * 5 + 2000)
+        return false;
+    }
+    return true;
+  }
+
+  private void change(Variable var, int newValue)
+  {
+    EditConstraint editC= new EditConstraint(var, Strength.preferred);
+    ArrayList<Constraint> editV= new ArrayList<Constraint>();
+    editV.add(editC);
+    Plan plan= planner.extractPlanFromConstraints(editV);
+    for (int i= 0; i < 10; i++) {
+      var.value= newValue;
+      plan.execute();
+    }
+    editC.destroyConstraint();
+  }
+
+  public static void error(String s)
+  {
+    System.err.println(s);
+    System.exit(1);
+  }
+
+  // CHECKSTYLE.ON: .*
+  public void timeDeltaBlue(int iterations) {
+    for (int iter = 0; iter < iterations; iter++) {
+      chainTest(100);
+      projectionTest(100);
+    }
+  }
+
+  public boolean verifyDeltaBlue() {
+    if (!chainTest(100)) {
+      System.out.println("ERROR: Chain test failed");
+      return false;
+    }
+    if (!projectionTest(100)) {
+      System.out.println("ERROR: Projection test failed");
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    DeltaBlue obj = new DeltaBlue();
+
+    long before = System.currentTimeMillis();
+    obj.timeDeltaBlue(300);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/algorithm/DeltaBlue: " + (after - before));
+    if (!obj.verifyDeltaBlue()) {
+      rc++;
+    }
+    System.exit(rc);
+  }
+}
+
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Dhrystone.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Dhrystone.java
new file mode 100644
index 0000000..dc96aa3
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Dhrystone.java
@@ -0,0 +1,485 @@
+/*
+ * Copyright (C) 2016 Linaro Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package art_benchmarks.algorithm;
+
+class Record {
+  Record ptrComp;
+  int discr;
+  int enumComp;
+  int intComp;
+  StringBuilder strComp;
+  int enumComp2;
+  char ch1Comp;
+  char ch2Comp;
+}
+
+class Pointer<T> {
+  T ref;
+}
+
+public class Dhrystone {
+  Record ptrGlob;
+  Record nextPtrGlob;
+  int intGlob;
+  boolean boolGlob;
+  char ch1Glob;
+  char ch2Glob;
+  int []arr1Glob;
+  int [][]arr2Glob;
+  int numOfRuns;
+
+  public static final int Ident_1 = 0;
+  public static final int Ident_2 = 1;
+  public static final int Ident_3 = 2;
+  public static final int Ident_4 = 3;
+  public static final int Ident_5 = 4;
+  private static final int loop_size = 500000;
+
+  public Dhrystone() {
+    ptrGlob = new Record();
+    nextPtrGlob = new Record();
+
+    ptrGlob.ptrComp = nextPtrGlob;
+    ptrGlob.discr = Ident_1;
+    ptrGlob.enumComp = Ident_3;
+    ptrGlob.intComp = 40;
+    ptrGlob.strComp = new StringBuilder(30);
+
+    nextPtrGlob.strComp = new StringBuilder(30);
+
+    arr1Glob = new int[50];
+    arr2Glob = new int[50][50];
+    arr2Glob[8][7] = 10;
+  }
+
+
+
+  public void timeDhrystone(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      old_main();
+    }
+  }
+
+  public void old_main() {
+    int runIndex;
+    int int1Loc;
+    int int2Loc;
+    int int3Loc = 0;
+    Pointer<Integer> intRef = new Pointer<Integer>();
+    String str1Loc = "DHRYSTONE PROGRAM, 1'ST STRING";
+    StringBuilder str2Loc = new StringBuilder(30);
+
+    int enumLoc = 0;
+    char chIndex;
+
+    /* We should re-init the parameters on every test */
+    ptrGlob.ptrComp = nextPtrGlob;
+    ptrGlob.discr = Ident_1;
+    ptrGlob.enumComp = Ident_3;
+    ptrGlob.intComp = 40;
+    ptrGlob.strComp.setLength(0);
+    ptrGlob.strComp.append("DHRYSTONE PROGRAM, SOME STRING");
+    arr2Glob[8][7] = 10;
+    numOfRuns = loop_size;
+
+    for (runIndex = 1; runIndex <= loop_size; runIndex++) {
+      proc5();
+      proc4();
+
+      int1Loc = 2;
+      int2Loc = 3;
+      str2Loc.setLength(0);
+      str2Loc.append("DHRYSTONE PROGRAM, 2'ND STRING");
+      enumLoc = Ident_2;
+
+      /* boolGlob == 1 */
+      boolGlob = !func2(str1Loc, str2Loc.toString());
+
+      while (int1Loc < int2Loc) {  /* loop body executed once */
+        /* int3Loc == 7 */
+        int3Loc = 5 * int1Loc - int2Loc;
+
+        /* int3Loc == 7 */
+        intRef.ref = int3Loc;
+        proc7(int1Loc, int2Loc, intRef);
+        int3Loc = intRef.ref;
+
+        int1Loc += 1;
+      }
+
+      /* int1Loc == 3, int2Loc == 3, int3Loc == 7 */
+      proc8(arr1Glob, arr2Glob, int1Loc, int3Loc);
+
+      /* intGlob == 5 */
+      proc1(ptrGlob);
+
+      for (chIndex = 'A'; chIndex <= ch2Glob; ++chIndex) {
+        /* loop body executed twice */
+        if (enumLoc == func1(chIndex, 'C')) {
+          /* then, not executed */
+          intRef.ref = enumLoc;
+          proc6(Ident_1, intRef);
+          enumLoc = intRef.ref;
+
+          str2Loc.setLength(0);
+          str2Loc.append("DHRYSTONE PROGRAM, 3'RD STRING");
+          int2Loc = runIndex;
+          intGlob = runIndex;
+        }
+      }
+
+      /* int1Loc == 3, int2Loc == 3, int3Loc == 7 */
+      int2Loc = int2Loc * int1Loc;
+      int1Loc = int2Loc / int3Loc;
+      int2Loc = 7 * (int2Loc - int3Loc) - int1Loc;
+      /* int1Loc == 1, int2Loc == 13, int3Loc == 7 */
+
+      intRef.ref = int1Loc;
+      proc2(intRef);
+      int1Loc = intRef.ref;
+
+      /* int1Loc == 5 */
+    }
+  }
+
+  public boolean verifyDhrystone() {
+    String str = "DHRYSTONE PROGRAM, SOME STRING";
+
+    timeDhrystone(1);
+
+    if (intGlob != 5) {
+      System.out.println("ERROR: intGlob should be 5, but found " + intGlob);
+      return false;
+    }
+
+    if (boolGlob != true) {
+      System.out.println("ERROR: boolGlob should be true, but found " + boolGlob);
+      return false;
+    }
+
+    if (ch1Glob != 'A') {
+      System.out.println("ERROR: ch1Glob should be 'A', but found " + ch1Glob);
+      return false;
+    }
+
+    if (ch2Glob != 'B') {
+      System.out.println("ERROR: ch2Glob should be 'B', but found " + ch2Glob);
+      return false;
+    }
+
+    if (arr1Glob[8] != 7) {
+      System.out.println("ERROR: arr1Glob[8] should be 7, but found " + arr1Glob[8]);
+      return false;
+    }
+
+    if (arr2Glob[8][7] != (numOfRuns + 10)) {
+      System.out.println("ERROR: arr2Glob[8][7] should be " + (numOfRuns + 10) +
+                         ", but found " + arr2Glob[8][7]);
+      return false;
+    }
+
+    if (ptrGlob.discr != 0) {
+      System.out.println("ERROR: ptrGlob.discr should be 0, but found " + ptrGlob.discr);
+      return false;
+    }
+
+    if (ptrGlob.enumComp != 2) {
+      System.out.println("ERROR: ptrGlob.enumComp should be 2, but found " + ptrGlob.enumComp);
+      return false;
+    }
+
+    if (ptrGlob.intComp != 17) {
+      System.out.println("ERROR: ptrGlob.intComp should be 17, but found " + ptrGlob.intComp);
+      return false;
+    }
+
+    if (ptrGlob.strComp.toString().compareTo(str) != 0) {
+      System.out.println("ERROR: ptrGlob.strComp should be " + str + ", but found " +
+                          ptrGlob.strComp);
+      return false;
+    }
+
+    if (nextPtrGlob.discr != 0) {
+      System.out.println("ERROR: nextPtrGlob.discr should be 0, but found " +
+                          nextPtrGlob.discr);
+      return false;
+    }
+
+    if (nextPtrGlob.enumComp != 1) {
+      System.out.println("ERROR: nextPtrGlob.enumComp should be 1, but found " +
+                         nextPtrGlob.enumComp);
+      return false;
+    }
+
+    if (nextPtrGlob.intComp != 18) {
+      System.out.println("ERROR: nextPtrGlob.intComp should be 18, but found " +
+                          nextPtrGlob.intComp);
+      return false;
+    }
+
+    if (nextPtrGlob.strComp.toString().compareTo(str) != 0) {
+      System.out.println("ERROR: nextPtrGlob.strComp should be " + str + ", but found " +
+                         nextPtrGlob.strComp);
+      return false;
+    }
+
+    return true;
+  }
+
+  /* executed once */
+  public void proc1(Record ptrValPar) {
+    /* == ptrGlob_Next */
+    /* Local variable, initialized with ptrValPar->ptrComp,    */
+    /* corresponds to "rename" in Ada, "with" in Pascal        */
+    Record nextRecord = ptrValPar.ptrComp;
+
+    ptrValPar.ptrComp.ptrComp = ptrGlob.ptrComp;
+    ptrValPar.ptrComp.discr = ptrGlob.discr;
+    ptrValPar.ptrComp.enumComp = ptrGlob.enumComp;
+    ptrValPar.ptrComp.intComp = ptrGlob.intComp;
+    ptrValPar.ptrComp.strComp.setLength(0);
+    ptrValPar.ptrComp.strComp.append(ptrGlob.strComp.toString());
+    ptrValPar.ptrComp.enumComp2 = ptrGlob.enumComp2;
+    ptrValPar.ptrComp.ch1Comp = ptrGlob.ch1Comp;
+    ptrValPar.ptrComp.ch2Comp = ptrGlob.ch2Comp;
+    ptrValPar.intComp = 5;
+
+    nextRecord.intComp = ptrValPar.intComp;
+    nextRecord.ptrComp = ptrValPar.ptrComp;
+
+    proc3(nextRecord.ptrComp);
+
+    if (nextRecord.discr == Ident_1) {
+      /* then, executed */
+      nextRecord.intComp = 6;
+
+      Pointer<Integer> intRef = new Pointer<Integer>();
+
+      intRef.ref = nextRecord.enumComp;
+      proc6(ptrValPar.enumComp, intRef);
+      nextRecord.enumComp = intRef.ref;
+
+      nextRecord.ptrComp = ptrGlob.ptrComp;
+
+      intRef.ref = nextRecord.intComp;
+      proc7(nextRecord.intComp, 10, intRef);
+      nextRecord.intComp = intRef.ref;
+    }
+    else { /* not executed */
+      ptrValPar = ptrValPar.ptrComp;
+    }
+  }
+
+  /* executed once */
+  /* intParRef == 1, becomes 4 */
+  public void proc2(Pointer<Integer> intParRef) {
+    int intLoc;
+    int enumLoc = 0;
+
+    intLoc = intParRef.ref + 10;
+    do { /* executed once */
+      if (ch1Glob == 'A') {
+        /* then, executed */
+        intLoc -= 1;
+        intParRef.ref = intLoc - intGlob;
+        enumLoc = Ident_1;
+      }
+    }
+    while (enumLoc != Ident_1);
+  }
+
+  /* executed once */
+  /* ptrRefPar becomes ptrGlob */
+  public void proc3(Record ptrRefPar) {
+    if (ptrGlob != null) {
+      /* then, executed */
+      ptrRefPar = ptrGlob.ptrComp;
+    }
+
+    Pointer<Integer> intRef = new Pointer<Integer>();
+    intRef.ref = ptrGlob.intComp;
+    proc7(10, intGlob, intRef);
+    ptrGlob.intComp = intRef.ref;
+  }
+
+  public void proc4() {
+    Boolean boolLoc;
+    boolLoc = ch1Glob == 'A';
+    boolGlob = boolLoc | boolGlob;
+    ch2Glob = 'B';
+  }
+
+  public void proc5() {
+    ch1Glob = 'A';
+    boolGlob = false;
+  }
+
+  /* executed once */
+  /* enumValPar == Ident_3, enumRefPar becomes Ident_2 */
+  public void proc6(int enumValPar, Pointer<Integer> enumRefPar) {
+    enumRefPar.ref = enumValPar;
+    if (!func3(enumValPar)) {
+      /* then, not executed */
+      enumRefPar.ref = Ident_4;
+    }
+
+    switch (enumValPar) {
+      case Ident_1:
+        enumRefPar.ref = Ident_1;
+        break;
+      case Ident_2:
+        if (intGlob > 100) {
+          /* then */
+          enumRefPar.ref = Ident_1;
+        }
+        else {
+          enumRefPar.ref = Ident_4;
+        }
+        break;
+      case Ident_3: /* executed */
+        enumRefPar.ref = Ident_2;
+        break;
+      case Ident_4:
+        break;
+      case Ident_5:
+        enumRefPar.ref = Ident_3;
+        break;
+      default:
+        break;
+    }
+  }
+
+  /* executed three times                                */
+  /* first call:      int1ParVal == 2, int2ParVal == 3,  */
+  /*                  intParRef becomes 7                */
+  /* second call:     int1ParVal == 10, int2ParVal == 5, */
+  /*                  intParRef becomes 17               */
+  /* third call:      int1ParVal == 6, int2ParVal == 10, */
+  /*                  intParRef becomes 18               */
+  public void proc7(int int1ParVal, int int2ParVal, Pointer<Integer> intParRef) {
+    int intLoc;
+
+    intLoc = int1ParVal + 2;
+    intParRef.ref = int2ParVal + intLoc;
+  }
+
+  /* executed once      */
+  /* Int_Par_Val_1 == 3 */
+  /* Int_Par_Val_2 == 7 */
+  public void proc8(int []arr1ParRef, int [][]arr2ParRef, int int1ParVal, int int2ParVal) {
+    int intIndex;
+    int intLoc;
+
+    intLoc = int1ParVal + 5;
+    arr1ParRef[intLoc] = int2ParVal;
+    arr1ParRef[intLoc + 1] = arr1ParRef[intLoc];
+    arr1ParRef[intLoc + 30] = intLoc;
+
+    for (intIndex = intLoc; intIndex <= intLoc + 1; ++intIndex) {
+      arr2ParRef[intLoc][intIndex] = intLoc;
+    }
+
+    arr2ParRef[intLoc][intLoc - 1] += 1;
+    arr2ParRef[intLoc + 20][intLoc] = arr1ParRef[intLoc];
+    intGlob = 5;
+  }
+
+  public int func1(char ch1ParVal, char ch2ParVal) {
+    char ch1Loc;
+    char ch2Loc;
+
+    ch1Loc = ch1ParVal;
+    ch2Loc = ch1Loc;
+    if (ch2Loc != ch2ParVal) {
+      /* then, executed */
+      return Ident_1;
+    }
+    else { /* not executed */
+      ch1Glob = ch1Loc;
+      return Ident_2;
+    }
+  }
+
+  /* executed once */
+  /* str1ParRef == "DHRYSTONE PROGRAM, 1'ST STRING" */
+  /* str2ParRef == "DHRYSTONE PROGRAM, 2'ND STRING" */
+  public boolean func2(String str1ParRef, String str2ParRef) {
+    int intLoc;
+    char chLoc = 0;
+
+    intLoc = 2;
+    while (intLoc <= 2) /* loop body executed once */
+      if (func1(str1ParRef.charAt(intLoc), str2ParRef.charAt(intLoc + 1)) == Ident_1) {
+        /* then, executed */
+        chLoc = 'A';
+        intLoc += 1;
+      }
+
+    if (chLoc >= 'W' && chLoc < 'Z') {
+      /* then, not executed */
+      intLoc = 7;
+    }
+
+    if (chLoc == 'R') {
+      /* then, not executed */
+      return true;
+    }
+    else { /* executed */
+      if (str1ParRef.compareTo(str2ParRef) > 0) {
+        /* then, not executed */
+        intLoc += 7;
+        intGlob = intLoc;
+        return true;
+      }
+      else { /* executed */
+        return false;
+      }
+    }
+  }
+
+  /* executed once         */
+  /* enumParVal == Ident_3 */
+  public boolean func3(int enumParVal) {
+    int enumLoc;
+
+    enumLoc = enumParVal;
+    if (enumLoc == Ident_3) {
+      /* then, executed */
+      return true;
+    }
+    else { /* not executed */
+      return false;
+    }
+  }
+
+  public static void main(String []argv) {
+    int rc = 0;
+    Dhrystone obj = new Dhrystone();
+
+    long before = System.currentTimeMillis();
+    obj.timeDhrystone(1);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/algorithm/Dhrystone: " + (after - before));
+
+    if (!obj.verifyDhrystone()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Linpack.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Linpack.java
new file mode 100644
index 0000000..6f4e32f
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Linpack.java
@@ -0,0 +1,719 @@
+/*
+
+Modified 3/23/2016 by Tim Zhang tim.zhang@linaro.org
+Modifications performed:
+ - Added runLinpack() method for running the linpack without computing the float rate.
+ - Added timeLinpack() method for running with different iterations.
+ - Updated main() method.
+
+Modified 3/3/97 by David M. Doolin (dmd) doolin@cs.utk.edu
+Fixed error in matgen() method. Added some comments.
+
+Modified 1/22/97 by Paul McMahan mcmahan@cs.utk.edu
+Added more MacOS options to form.
+
+Optimized by Jonathan Hardwick (jch@cs.cmu.edu), 3/28/96
+Compare to Linkpack.java.
+Optimizations performed:
+ - added "final" modifier to performance-critical methods.
+ - changed lines of the form "a[i] = a[i] + x" to "a[i] += x".
+ - minimized array references using common subexpression elimination.
+ - eliminated unused variables.
+ - undid an unrolled loop.
+ - added temporary 1D arrays to hold frequently-used columns of 2D arrays.
+ - wrote my own abs() method
+See http://www.cs.cmu.edu/~jch/java/linpack.html for more details.
+
+
+Ported to Java by Reed Wade  (wade@cs.utk.edu) 2/96
+built using JDK 1.0 on solaris
+using "javac -O Linpack.java"
+
+
+Translated to C by Bonnie Toy 5/88
+  (modified on 2/25/94  to fix a problem with daxpy  for
+   unequal increments or equal increments not equal to 1.
+     Jack Dongarra)
+
+*/
+
+// CHECKSTYLE.OFF: .*
+package art_benchmarks.algorithm;
+
+
+public class Linpack {
+
+  public static void main_(String[] args)
+  {
+    Linpack l = new Linpack();
+    l.run_benchmark();
+  }
+
+  final double abs (double d) {
+    return (d >= 0) ? d : -d;
+  }
+
+  double second_orig = -1;
+
+  double second()
+  {
+    if (second_orig==-1) {
+      second_orig = System.currentTimeMillis();
+    }
+    return (System.currentTimeMillis() - second_orig)/1000;
+  }
+
+  public void run_benchmark() 
+  {
+    double mflops_result = 0.0;
+    double residn_result = 0.0;
+    double time_result = 0.0;
+    double eps_result = 0.0;
+
+    double a[][] = new double[200][201];
+    double b[] = new double[200];
+    double x[] = new double[200];
+    double cray,ops,total,norma,normx;
+    double resid,time;
+    double kf;
+    int n,i,ntimes,info,lda,ldaa,kflops;
+    int ipvt[] = new int[200];
+    
+    //double mflops_result;
+    //double residn_result;
+    //double time_result;
+    //double eps_result;
+
+    lda = 201;
+    ldaa = 200;
+    cray = .056;
+    n = 100;
+    
+    ops = (2.0e0*(n*n*n))/3.0 + 2.0*(n*n);
+    
+    norma = matgen(a,lda,n,b);
+    time = second();
+    info = dgefa(a,lda,n,ipvt);
+    dgesl(a,lda,n,ipvt,b,0);
+    total = second() - time;
+    
+    for (i = 0; i < n; i++) {
+      x[i] = b[i];
+    }
+    norma = matgen(a,lda,n,b);
+    for (i = 0; i < n; i++) {
+      b[i] = -b[i];
+    }
+    dmxpy(n,b,n,lda,x,a);
+    resid = 0.0;
+    normx = 0.0;
+    for (i = 0; i < n; i++) {
+      resid = (resid > abs(b[i])) ? resid : abs(b[i]);
+      normx = (normx > abs(x[i])) ? normx : abs(x[i]);
+    }
+    
+    eps_result = epslon((double)1.0);
+/*
+
+    residn_result = resid/( n*norma*normx*eps_result );
+    time_result = total;
+    mflops_result = ops/(1.0e6*total);
+
+    return ("Mflops/s: " + mflops_result +
+	    "  Time: " + time_result + " secs" +
+	    "  Norm Res: " + residn_result +
+	    "  Precision: " + eps_result);
+*/
+	residn_result = resid/( n*norma*normx*eps_result );
+	residn_result += 0.005; // for rounding
+	residn_result = (int)(residn_result*100);
+	residn_result /= 100;
+
+	time_result = total;
+	time_result += 0.005; // for rounding
+	time_result = (int)(time_result*100);
+	time_result /= 100;
+
+	mflops_result = ops/(1.0e6*total);
+	mflops_result += 0.0005; // for rounding
+	mflops_result = (int)(mflops_result*1000);
+	mflops_result /= 1000;
+
+    System.out.println("Mflops/s: " + mflops_result +
+	    "  Time: " + time_result + " secs" +
+	    "  Norm Res: " + residn_result +
+	    "  Precision: " + eps_result);
+  }
+  
+
+  
+  final double matgen (double a[][], int lda, int n, double b[])
+  {
+    double norma;
+    int init, i, j;
+    
+    init = 1325;
+    norma = 0.0;
+/*  Next two for() statements switched.  Solver wants
+matrix in column order. --dmd 3/3/97
+*/
+      for (i = 0; i < n; i++) {
+    for (j = 0; j < n; j++) {
+	init = 3125*init % 65536;
+	a[j][i] = (init - 32768.0)/16384.0;
+	norma = (a[j][i] > norma) ? a[j][i] : norma;
+      }
+    }
+    for (i = 0; i < n; i++) {
+      b[i] = 0.0;
+    }
+    for (j = 0; j < n; j++) {
+      for (i = 0; i < n; i++) {
+	b[i] += a[j][i];
+      }
+    }
+    
+    return norma;
+  }
+  
+
+  
+  /*
+    dgefa factors a double precision matrix by gaussian elimination.
+    
+    dgefa is usually called by dgeco, but it can be called
+    directly with a saving in time if  rcond  is not needed.
+    (time for dgeco) = (1 + 9/n)*(time for dgefa) .
+    
+    on entry
+    
+    a       double precision[n][lda]
+    the matrix to be factored.
+    
+    lda     integer
+    the leading dimension of the array  a .
+    
+    n       integer
+    the order of the matrix  a .
+    
+    on return
+    
+    a       an upper triangular matrix and the multipliers
+    which were used to obtain it.
+    the factorization can be written  a = l*u  where
+    l  is a product of permutation and unit lower
+    triangular matrices and  u  is upper triangular.
+    
+    ipvt    integer[n]
+    an integer vector of pivot indices.
+    
+    info    integer
+    = 0  normal value.
+    = k  if  u[k][k] .eq. 0.0 .  this is not an error
+    condition for this subroutine, but it does
+    indicate that dgesl or dgedi will divide by zero
+    if called.  use  rcond  in dgeco for a reliable
+    indication of singularity.
+    
+    linpack. this version dated 08/14/78.
+    cleve moler, university of new mexico, argonne national lab.
+    
+    functions
+    
+    blas daxpy,dscal,idamax
+  */
+  final int dgefa( double a[][], int lda, int n, int ipvt[])
+  {
+    double[] col_k, col_j;
+    double t;
+    int j,k,kp1,l,nm1;
+    int info;
+    
+    // gaussian elimination with partial pivoting
+    
+    info = 0;
+    nm1 = n - 1;
+    if (nm1 >=  0) {
+      for (k = 0; k < nm1; k++) {
+	col_k = a[k];
+	kp1 = k + 1;
+	
+	// find l = pivot index
+	
+	l = idamax(n-k,col_k,k,1) + k;
+	ipvt[k] = l;
+	
+	// zero pivot implies this column already triangularized
+	
+	if (col_k[l] != 0) {
+	  
+	  // interchange if necessary
+	  
+	  if (l != k) {
+	    t = col_k[l];
+	    col_k[l] = col_k[k];
+	    col_k[k] = t;
+	  }
+	  
+	  // compute multipliers
+	  
+	  t = -1.0/col_k[k];
+	  dscal(n-(kp1),t,col_k,kp1,1);
+	  
+	  // row elimination with column indexing
+	  
+	  for (j = kp1; j < n; j++) {
+	    col_j = a[j];
+	    t = col_j[l];
+	    if (l != k) {
+	      col_j[l] = col_j[k];
+	      col_j[k] = t;
+	    }
+	    daxpy(n-(kp1),t,col_k,kp1,1,
+		  col_j,kp1,1);
+	  }
+	}
+	else {
+	  info = k;
+	}
+      }
+    }
+    ipvt[n-1] = n-1;
+    if (a[(n-1)][(n-1)] == 0) info = n-1;
+    
+    return info;
+  }
+
+  
+  
+  /*
+    dgesl solves the double precision system
+    a * x = b  or  trans(a) * x = b
+    using the factors computed by dgeco or dgefa.
+  
+    on entry
+  
+    a       double precision[n][lda]
+    the output from dgeco or dgefa.
+  
+    lda     integer
+    the leading dimension of the array  a .
+    
+    n       integer
+    the order of the matrix  a .
+  
+    ipvt    integer[n]
+    the pivot vector from dgeco or dgefa.
+
+    b       double precision[n]
+    the right hand side vector.
+    
+    job     integer
+    = 0         to solve  a*x = b ,
+    = nonzero   to solve  trans(a)*x = b  where
+    trans(a)  is the transpose.
+    
+    on return
+    
+    b       the solution vector  x .
+    
+    error condition
+    
+    a division by zero will occur if the input factor contains a
+    zero on the diagonal.  technically this indicates singularity
+    but it is often caused by improper arguments or improper
+    setting of lda .  it will not occur if the subroutines are
+    called correctly and if dgeco has set rcond .gt. 0.0
+    or dgefa has set info .eq. 0 .
+    
+    to compute  inverse(a) * c  where  c  is a matrix
+    with  p  columns
+    dgeco(a,lda,n,ipvt,rcond,z)
+    if (!rcond is too small){
+    for (j=0,j<p,j++)
+    dgesl(a,lda,n,ipvt,c[j][0],0);
+    }
+    
+    linpack. this version dated 08/14/78 .
+    cleve moler, university of new mexico, argonne national lab.
+    
+    functions
+    
+    blas daxpy,ddot
+  */
+  final void dgesl( double a[][], int lda, int n, int ipvt[], double b[], int job)
+  {
+    double t;
+    int k,kb,l,nm1,kp1;
+
+    nm1 = n - 1;
+    if (job == 0) {
+
+      // job = 0 , solve  a * x = b.  first solve  l*y = b
+
+      if (nm1 >= 1) {
+	for (k = 0; k < nm1; k++) {
+	  l = ipvt[k];
+	  t = b[l];
+	  if (l != k){
+	    b[l] = b[k];
+	    b[k] = t;
+	  }
+	  kp1 = k + 1;
+	  daxpy(n-(kp1),t,a[k],kp1,1,b,kp1,1);
+	}
+      }
+
+      // now solve  u*x = y
+
+      for (kb = 0; kb < n; kb++) {
+	k = n - (kb + 1);
+	b[k] /= a[k][k];
+	t = -b[k];
+	daxpy(k,t,a[k],0,1,b,0,1);
+      }
+    }
+    else {
+
+      // job = nonzero, solve  trans(a) * x = b.  first solve  trans(u)*y = b
+
+      for (k = 0; k < n; k++) {
+	t = ddot(k,a[k],0,1,b,0,1);
+	b[k] = (b[k] - t)/a[k][k];
+      }
+
+      // now solve trans(l)*x = y 
+
+      if (nm1 >= 1) {
+	for (kb = 1; kb < nm1; kb++) {
+	  k = n - (kb+1);
+	  kp1 = k + 1;
+	  b[k] += ddot(n-(kp1),a[k],kp1,1,b,kp1,1);
+	  l = ipvt[k];
+	  if (l != k) {
+	    t = b[l];
+	    b[l] = b[k];
+	    b[k] = t;
+	  }
+	}
+      }
+    }
+  }
+
+
+
+  /*
+    constant times a vector plus a vector.
+    jack dongarra, linpack, 3/11/78.
+  */
+  final void daxpy( int n, double da, double dx[], int dx_off, int incx,
+	      double dy[], int dy_off, int incy)
+  {
+    int i,ix,iy;
+
+    if ((n > 0) && (da != 0)) {
+      if (incx != 1 || incy != 1) {
+
+	// code for unequal increments or equal increments not equal to 1
+
+	ix = 0;
+	iy = 0;
+	if (incx < 0) ix = (-n+1)*incx;
+	if (incy < 0) iy = (-n+1)*incy;
+	for (i = 0;i < n; i++) {
+	  dy[iy +dy_off] += da*dx[ix +dx_off];
+	  ix += incx;
+	  iy += incy;
+	}
+	return;
+      } else {
+
+	// code for both increments equal to 1
+
+	for (i=0; i < n; i++)
+	  dy[i +dy_off] += da*dx[i +dx_off];
+      }
+    }
+  }
+
+
+
+  /*
+    forms the dot product of two vectors.
+    jack dongarra, linpack, 3/11/78.
+  */
+  final double ddot( int n, double dx[], int dx_off, int incx, double dy[],
+	       int dy_off, int incy)
+  {
+    double dtemp;
+    int i,ix,iy;
+
+    dtemp = 0;
+
+    if (n > 0) {
+      
+      if (incx != 1 || incy != 1) {
+
+	// code for unequal increments or equal increments not equal to 1
+
+	ix = 0;
+	iy = 0;
+	if (incx < 0) ix = (-n+1)*incx;
+	if (incy < 0) iy = (-n+1)*incy;
+	for (i = 0;i < n; i++) {
+	  dtemp += dx[ix +dx_off]*dy[iy +dy_off];
+	  ix += incx;
+	  iy += incy;
+	}
+      } else {
+
+	// code for both increments equal to 1
+	
+	for (i=0;i < n; i++)
+	  dtemp += dx[i +dx_off]*dy[i +dy_off];
+      }
+    }
+    return(dtemp);
+  }
+
+  
+  
+  /*
+    scales a vector by a constant.
+    jack dongarra, linpack, 3/11/78.
+  */
+  final void dscal( int n, double da, double dx[], int dx_off, int incx)
+  {
+    int i,nincx;
+
+    if (n > 0) {
+      if (incx != 1) {
+
+	// code for increment not equal to 1
+
+	nincx = n*incx;
+	for (i = 0; i < nincx; i += incx)
+	  dx[i +dx_off] *= da;
+      } else {
+
+	// code for increment equal to 1
+
+	for (i = 0; i < n; i++)
+	  dx[i +dx_off] *= da;
+      }
+    }
+  }
+
+  
+  
+  /*
+    finds the index of element having max. absolute value.
+    jack dongarra, linpack, 3/11/78.
+  */
+  final int idamax( int n, double dx[], int dx_off, int incx)
+  {
+    double dmax, dtemp;
+    int i, ix, itemp=0;
+
+    if (n < 1) {
+      itemp = -1;
+    } else if (n ==1) {
+      itemp = 0;
+    } else if (incx != 1) {
+
+      // code for increment not equal to 1
+
+      dmax = abs(dx[0 +dx_off]);
+      ix = 1 + incx;
+      for (i = 1; i < n; i++) {
+	dtemp = abs(dx[ix + dx_off]);
+	if (dtemp > dmax)  {
+	  itemp = i;
+	  dmax = dtemp;
+	}
+	ix += incx;
+      }
+    } else {
+
+      // code for increment equal to 1
+
+      itemp = 0;
+      dmax = abs(dx[0 +dx_off]);
+      for (i = 1; i < n; i++) {
+	dtemp = abs(dx[i + dx_off]);
+	if (dtemp > dmax) {
+	  itemp = i;
+	  dmax = dtemp;
+	}
+      }
+    }
+    return (itemp);
+  }
+
+
+  
+  /*
+    estimate unit roundoff in quantities of size x.
+    
+    this program should function properly on all systems
+    satisfying the following two assumptions,
+    1.  the base used in representing dfloating point
+    numbers is not a power of three.
+    2.  the quantity  a  in statement 10 is represented to
+    the accuracy used in dfloating point variables
+    that are stored in memory.
+    the statement number 10 and the go to 10 are intended to
+    force optimizing compilers to generate code satisfying
+    assumption 2.
+    under these assumptions, it should be true that,
+    a  is not exactly equal to four-thirds,
+    b  has a zero for its last bit or digit,
+    c  is not exactly equal to one,
+    eps  measures the separation of 1.0 from
+    the next larger dfloating point number.
+    the developers of eispack would appreciate being informed
+    about any systems where these assumptions do not hold.
+    
+    *****************************************************************
+    this routine is one of the auxiliary routines used by eispack iii
+    to avoid machine dependencies.
+    *****************************************************************
+  
+    this version dated 4/6/83.
+  */
+  final double epslon (double x)
+  {
+    double a,b,c,eps;
+
+    a = 4.0e0/3.0e0;
+    eps = 0;
+    while (eps == 0) {
+      b = a - 1.0;
+      c = b + b + b;
+      eps = abs(c-1.0);
+    }
+    return(eps*abs(x));
+  }
+
+  
+
+  /*
+    purpose:
+    multiply matrix m times vector x and add the result to vector y.
+    
+    parameters:
+    
+    n1 integer, number of elements in vector y, and number of rows in
+    matrix m
+    
+    y double [n1], vector of length n1 to which is added
+    the product m*x
+    
+    n2 integer, number of elements in vector x, and number of columns
+    in matrix m
+    
+    ldm integer, leading dimension of array m
+    
+    x double [n2], vector of length n2
+    
+    m double [ldm][n2], matrix of n1 rows and n2 columns
+  */
+  final void dmxpy ( int n1, double y[], int n2, int ldm, double x[], double m[][])
+  {
+    int j,i;
+
+    // cleanup odd vector
+    for (j = 0; j < n2; j++) {
+      for (i = 0; i < n1; i++) {
+	y[i] += x[j]*m[j][i];
+      }
+    }
+  }
+
+  // CHECKSTYLE.ON: .*
+  /*
+    This function derived from run_benchmark() function in the original file.
+    Modifications:
+    - Keep the code that is used to timing.
+    - Ignore the computing of Linpack result in Mflops/s.
+  */
+  public void runLinpack() {
+    double [][]a = new double[200][201];
+    double []b = new double[200];
+    double norma;
+    int n;
+    int info;
+    int lda;
+    int []ipvt = new int[200];
+
+    lda = 201;
+    n = 100;
+
+    norma = matgen(a,lda,n,b);
+    info = dgefa(a,lda,n,ipvt);
+    dgesl(a,lda,n,ipvt,b,0);
+  }
+
+  public void timeLinpack(int iterations) {
+    for (int iter = 0; iter < iterations; iter++) {
+      runLinpack();
+    }
+  }
+
+  public boolean verifyLinpack() {
+    // A copy of `runLinpack.
+    double [][]a = new double[200][201];
+    double []b = new double[200];
+    double norma;
+    int n;
+    int info;
+    int lda;
+    int []ipvt = new int[200];
+
+    lda = 201;
+    n = 100;
+
+    norma = matgen(a,lda,n,b);
+    info = dgefa(a,lda,n,ipvt);
+    dgesl(a,lda,n,ipvt,b,0);
+
+    // Verifying code: sum the values in the arrays.
+    double found = norma + info;
+    for (int i = 0; i < 200; i++) {
+      for (int j = 0; j < 201; j++) {
+        found += a[i][j];
+      }
+    }
+
+    for (int i = 0; i < 200; i++) {
+      found += b[i];
+    }
+
+    for (int i = 0; i < 200; i++) {
+      found += ipvt[i];
+    }
+
+    double expected = 7430.571892474999;
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Linpack obj = new Linpack();
+
+    long before = System.currentTimeMillis();
+    obj.timeLinpack(200);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Linpack: " + (after - before));
+
+    if (!obj.verifyLinpack()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/NSieve.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/NSieve.java
new file mode 100644
index 0000000..939e3c6
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/NSieve.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/access-nsieve.js
+ *
+ */
+
+// The Great Computer Language Shootout
+//  http://shootout.alioth.debian.org/
+//
+//  modified by Isaac Gouy
+
+// http://benchmarksgame.alioth.debian.org/license.html  (BSD 3-clause license)
+// See NOTICE file for license.
+
+package art_benchmarks.algorithm;
+
+import java.lang.System;
+
+
+public class NSieve {
+  /* Expected result for the standard benchmark setup */
+  private static final int EXPECTED = 14302;
+  /* Number of repeats (internal, not benchmark iterations) */
+  private static final int NUM_SIEVES = 4;
+  /* Array of flags - big enough for all standard test scenarios */
+  private static boolean[] flags = new boolean[80001];
+  private static int[] results = new int[NUM_SIEVES];
+
+  private int nsieve(int m) {
+    for (int i = 2; i <= m; i++) {
+      flags[i] = true;
+    }
+
+    int count = 0;
+    for (int i = 2; i <= m; i++) {
+      if (flags[i]) {
+        for (int k = i + i; k <= m; k += i) {
+          flags[k] = false;
+        }
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Find prime numbers in three sizes of pool, four times over
+   * Repeat over number of iterations set by framework
+   **/
+  public void timeNSieveAccess(int iterations) {
+    for (int iter = 0; iter < iterations; iter++) {
+      for (int i = 0; i < NUM_SIEVES; i++) {
+        int sum = 0;
+        for (int o = 1; o <= 3; o++) {
+          int m = (1 << o) * 10000;
+          sum += nsieve(m);
+        }
+        results[i] = sum;
+      }
+    }
+  }
+
+  /**
+   * Called by the framework to assert the benchmarks have done the right thing.
+   **/
+  public boolean verify() {
+    for (int i = 0; i < NUM_SIEVES; i++) {
+      if (results[i] != EXPECTED) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * *NOT* called by the framework by default, provided for direct use only.
+   **/
+  public static void main(String[] args) {
+    NSieve obj = new NSieve();
+    long before = System.currentTimeMillis();
+
+    obj.timeNSieveAccess(100);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/NSieve.NSieveAccess: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Richards.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Richards.java
new file mode 100644
index 0000000..7f29e32
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Richards.java
@@ -0,0 +1,660 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+/*
+ * The original file is available at:
+ * https://gwt.googlesource.com/gwt-benchmarks/+/master/benchmarks/src/main/
+ *         java/com/google/gwt/benchmark/benchmarks/octane/client/richards/gwt/
+ *
+ * Modifications:
+ * (1) Squashed java files into a single java file.
+ * (1) Added timeRichards() method for running with different iterations.
+ * (2) Added verifyRichards() method for verifying the benchmark.
+ * (3) Changed main() method.
+ * (4) Changed arrays from using GWT library classes (JavaScriptArray,
+ *     CollectionFactory, etc) into standard java arrays.
+ */
+
+package art_benchmarks.algorithm;
+
+// CHECKSTYLE.OFF: .*
+class DeviceTask implements Task {
+
+  private Scheduler scheduler;
+  private Packet v1;
+  /**
+   * A task that suspends itself after each time it has been run to simulate
+   * waiting for data from an external device.
+   * @param {Scheduler} scheduler the scheduler that manages this task
+   * @constructor
+   */
+  @SuppressWarnings("javadoc")
+  public DeviceTask(Scheduler scheduler) {
+    this.scheduler = scheduler;
+    this.v1 = null;
+  }
+
+  @Override
+  public TaskControlBlock run(Packet packet) {
+    if (packet == null) {
+      if (this.v1 == null) return this.scheduler.suspendCurrent();
+      Packet v = this.v1;
+      this.v1 = null;
+      return this.scheduler.queue(v);
+    } else {
+      this.v1 = packet;
+      return this.scheduler.holdCurrent();
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "DeviceTask";
+  }
+}
+
+class HandlerTask implements Task{
+
+  private Scheduler scheduler;
+  private Packet v1;
+  private Packet v2;
+
+  /**
+   * A task that manipulates work packets and then suspends itself.
+   * @param {Scheduler} scheduler the scheduler that manages this task
+   * @constructor
+   */
+  @SuppressWarnings("javadoc")
+  public HandlerTask(Scheduler scheduler) {
+    this.scheduler = scheduler;
+    this.v1 = null;
+    this.v2 = null;
+  }
+
+  @Override
+  public TaskControlBlock run(Packet packet) {
+    if (packet != null) {
+      if (packet.kind == Scheduler.KIND_WORK) {
+        this.v1 = packet.addTo(this.v1);
+      } else {
+        this.v2 = packet.addTo(this.v2);
+      }
+    }
+    if (this.v1 != null) {
+      int count = this.v1.a1;
+      Packet v;
+      if (count < Packet.DATA_SIZE) {
+        if (this.v2 != null) {
+          v = this.v2;
+          this.v2 = this.v2.link;
+          v.a1 = this.v1.a2[count];
+          this.v1.a1 = count + 1;
+          return this.scheduler.queue(v);
+        }
+      } else {
+        v = this.v1;
+        this.v1 = this.v1.link;
+        return this.scheduler.queue(v);
+      }
+    }
+    return this.scheduler.suspendCurrent();
+  }
+
+  @Override
+  public String toString() {
+    return "HandlerTask";
+  }
+}
+
+class IdleTask implements Task {
+
+  private Scheduler scheduler;
+  private int v1;
+  private int count;
+  /**
+   * An idle task doesn't do any work itself but cycles control between the two
+   * device tasks.
+   * @param {Scheduler} scheduler the scheduler that manages this task
+   * @param {int} v1 a seed value that controls how the device tasks are scheduled
+   * @param {int} count the number of times this task should be scheduled
+   * @constructor
+   */
+  @SuppressWarnings("javadoc")
+  public IdleTask(Scheduler scheduler, int v1, int count) {
+    this.scheduler = scheduler;
+    this.v1 = v1;
+    this.count = count;
+  }
+
+  @Override
+  public TaskControlBlock run(Packet packet) {
+    this.count--;
+    if (this.count == 0) return this.scheduler.holdCurrent();
+    if ((this.v1 & 1) == 0) {
+      this.v1 = this.v1 >> 1;
+      return this.scheduler.release(Scheduler.ID_DEVICE_A);
+    } else {
+      this.v1 = (this.v1 >> 1) ^ 0xD008;
+      return this.scheduler.release(Scheduler.ID_DEVICE_B);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "IdleTask";
+  }
+}
+
+class Packet {
+
+  public static final int DATA_SIZE = 4;
+
+  public Packet link;
+
+  public int id;
+
+  public int a1;
+
+  public int[] a2;
+
+  public int kind;
+
+  /**
+   * A simple package of data that is manipulated by the tasks. The exact layout of the payload data
+   * carried by a packet is not importaint, and neither is the nature of the work performed on
+   * packets by the tasks.
+   *
+   * Besides carrying data, packets form linked lists and are hence used both as data and
+   * worklists.
+   *
+   * @param {Packet} link the tail of the linked list of packets
+   * @param {int} id an ID for this packet
+   * @param {int} kind the type of this packet
+   * @constructor
+   */
+  @SuppressWarnings("javadoc")
+  public Packet(Packet link, int id, int kind) {
+    this.link = link;
+    this.id = id;
+    this.kind = kind;
+    this.a1 = 0;
+    this.a2 = new int[DATA_SIZE];
+  }
+
+  /**
+   * Add this packet to the end of a worklist, and return the worklist.
+   *
+   * @param {Packet} queue the worklist to add this packet to
+   */
+  @SuppressWarnings("javadoc")
+  public Packet addTo(Packet queue) {
+    this.link = null;
+    if (queue == null)
+      return this;
+    Packet peek;
+    Packet next = queue;
+    while ((peek = next.link) != null)
+      next = peek;
+    next.link = this;
+    return queue;
+  }
+
+  @Override
+  public String toString() {
+    return "Packet";
+  }
+
+}
+
+/**
+ * A scheduler can be used to schedule a set of tasks based on their relative priorities. Scheduling
+ * is done by maintaining a list of task control blocks which holds tasks and the data queue they
+ * are processing.
+ *
+ * @constructor
+ */
+class Scheduler {
+
+  public static final int ID_IDLE = 0;
+  public static final int ID_WORKER = 1;
+  public static final int ID_HANDLER_A = 2;
+  public static final int ID_HANDLER_B = 3;
+  public static final int ID_DEVICE_A = 4;
+  public static final int ID_DEVICE_B = 5;
+  public static final int NUMBER_OF_IDS = 6;
+
+  public static final int KIND_DEVICE = 0;
+  public static final int KIND_WORK = 1;
+
+  public int queueCount;
+  public int holdCount;
+  private TaskControlBlock list;
+  private TaskControlBlock currentTcb;
+  private int currentId;
+  private TaskControlBlock[] blocks;
+
+  public Scheduler() {
+    this.queueCount = 0;
+    this.holdCount = 0;
+    this.blocks = new TaskControlBlock[NUMBER_OF_IDS];
+    this.list = null;
+    this.currentTcb = null;
+    this.currentId = -1;
+  }
+
+  /**
+   * Add an idle task to this scheduler.
+   * @param {int} id the identity of the task
+   * @param {int} priority the task's priority
+   * @param {Packet} queue the queue of work to be processed by the task
+   * @param {int} count the number of times to schedule the task
+   */
+  @SuppressWarnings("javadoc")
+  public void addIdleTask(int id, int priority, Packet queue, int count) {
+    this.addRunningTask(id, priority, queue, new IdleTask(this, 1, count));
+  }
+
+  /**
+   * Add a work task to this scheduler.
+   * @param {int} id the identity of the task
+   * @param {int} priority the task's priority
+   * @param {Packet} queue the queue of work to be processed by the task
+   */
+  @SuppressWarnings("javadoc")
+  public void addWorkerTask(int id, int priority, Packet queue) {
+    this.addTask(id, priority, queue, new WorkerTask(this, ID_HANDLER_A, 0));
+  }
+
+  /**
+   * Add a handler task to this scheduler.
+   * @param {int} id the identity of the task
+   * @param {int} priority the task's priority
+   * @param {Packet} queue the queue of work to be processed by the task
+   */
+  @SuppressWarnings("javadoc")
+  public void addHandlerTask(int id, int priority, Packet queue) {
+    this.addTask(id, priority, queue, new HandlerTask(this));
+  }
+
+  /**
+   * Add a handler task to this scheduler.
+   * @param {int} id the identity of the task
+   * @param {int} priority the task's priority
+   * @param {Packet} queue the queue of work to be processed by the task
+   */
+  @SuppressWarnings("javadoc")
+  public void addDeviceTask(int id, int priority, Packet queue) {
+    this.addTask(id, priority, queue, new DeviceTask(this));
+  }
+
+  /**
+   * Add the specified task and mark it as running.
+   * @param {int} id the identity of the task
+   * @param {int} priority the task's priority
+   * @param {Packet} queue the queue of work to be processed by the task
+   * @param {Task} task the task to add
+   */
+  @SuppressWarnings("javadoc")
+  public void addRunningTask(int id, int priority, Packet queue, Task task) {
+    this.addTask(id, priority, queue, task);
+    this.currentTcb.setRunning();
+  }
+
+  /**
+   * Add the specified task to this scheduler.
+   * @param {int} id the identity of the task
+   * @param {int} priority the task's priority
+   * @param {Packet} queue the queue of work to be processed by the task
+   * @param {Task} task the task to add
+   */
+  @SuppressWarnings("javadoc")
+  private void addTask(int id, int priority, Packet queue, Task task) {
+    this.currentTcb = new TaskControlBlock(this.list, id, priority, queue, task);
+    this.list = this.currentTcb;
+    this.blocks[id] = this.currentTcb;
+  }
+
+  /**
+   * Execute the tasks managed by this scheduler.
+   */
+  public void schedule() {
+    this.currentTcb = this.list;
+    while (this.currentTcb != null) {
+      if (this.currentTcb.isHeldOrSuspended()) {
+        this.currentTcb = this.currentTcb.link;
+      } else {
+        this.currentId = this.currentTcb.id;
+        this.currentTcb = this.currentTcb.run();
+      }
+    }
+  }
+
+  /**
+   * Release a task that is currently blocked and return the next block to run.
+   * @param {int} id the id of the task to suspend
+   */
+  @SuppressWarnings("javadoc")
+  public TaskControlBlock release(int id) {
+    TaskControlBlock tcb = this.blocks[id];
+    if (tcb == null) return tcb;
+    tcb.markAsNotHeld();
+    if (tcb.priority > this.currentTcb.priority) {
+      return tcb;
+    } else {
+      return this.currentTcb;
+    }
+  }
+
+  /**
+   * Block the currently executing task and return the next task control block
+   * to run.  The blocked task will not be made runnable until it is explicitly
+   * released, even if new work is added to it.
+   */
+  public TaskControlBlock holdCurrent() {
+    this.holdCount++;
+    this.currentTcb.markAsHeld();
+    return this.currentTcb.link;
+  }
+
+  /**
+   * Suspend the currently executing task and return the next task control block
+   * to run.  If new work is added to the suspended task it will be made runnable.
+   */
+  public TaskControlBlock suspendCurrent() {
+    this.currentTcb.markAsSuspended();
+    return this.currentTcb;
+  }
+
+  /**
+   * Add the specified packet to the end of the worklist used by the task
+   * associated with the packet and make the task runnable if it is currently
+   * suspended.
+   * @param {Packet} packet the packet to add
+   */
+  @SuppressWarnings("javadoc")
+  public TaskControlBlock queue(Packet packet) {
+    TaskControlBlock t = this.blocks[packet.id];
+    if (t == null) return t;
+    this.queueCount++;
+    packet.link = null;
+    packet.id = this.currentId;
+    return t.checkPriorityAdd(this.currentTcb, packet);
+  }
+
+}
+
+class TaskControlBlock implements Task {
+
+  public TaskControlBlock link;
+
+  public int id;
+
+  public int priority;
+
+  private Packet queue;
+
+  private Task task;
+
+  private int state;
+
+  /**
+   * A task control block manages a task and the queue of work packages associated
+   * with it.
+   * @param {TaskControlBlock} link the preceding block in the linked block list
+   * @param {int} id the id of this block
+   * @param {int} priority the priority of this block
+   * @param {Packet} queue the queue of packages to be processed by the task
+   * @param {Task} task the task
+   * @constructor
+   */
+  @SuppressWarnings("javadoc")
+  public TaskControlBlock(TaskControlBlock link, int id, int priority, Packet queue, Task task) {
+    this.link = link;
+    this.id = id;
+    this.priority = priority;
+    this.queue = queue;
+    this.task = task;
+    if (queue == null) {
+      this.state = STATE_SUSPENDED;
+    } else {
+      this.state = STATE_SUSPENDED_RUNNABLE;
+    }
+  }
+
+  /**
+   * The task is running and is currently scheduled.
+   */
+  public static final int  STATE_RUNNING = 0;
+
+  /**
+   * The task has packets left to process.
+   */
+  public static final int STATE_RUNNABLE = 1;
+
+  /**
+   * The task is not currently running.  The task is not blocked as such and may
+  * be started by the scheduler.
+   */
+  public static final int STATE_SUSPENDED = 2;
+
+  /**
+   * The task is blocked and cannot be run until it is explicitly released.
+   */
+  public static final int STATE_HELD = 4;
+
+  public static final int STATE_SUSPENDED_RUNNABLE = STATE_SUSPENDED | STATE_RUNNABLE;
+  public static final int STATE_NOT_HELD = ~STATE_HELD;
+
+  public void setRunning() {
+    this.state = STATE_RUNNING;
+  }
+
+  public void markAsNotHeld () {
+    this.state = this.state & STATE_NOT_HELD;
+  }
+
+  public void markAsHeld() {
+    this.state = this.state | STATE_HELD;
+  }
+
+  public boolean isHeldOrSuspended() {
+    return (this.state & STATE_HELD) != 0 || (this.state == STATE_SUSPENDED);
+  }
+
+  public void markAsSuspended() {
+    this.state = this.state | STATE_SUSPENDED;
+  }
+
+  public void markAsRunnable() {
+    this.state = this.state | STATE_RUNNABLE;
+  }
+
+  /**
+   * Runs this task, if it is ready to be run, and returns the next task to run.
+   */
+  public TaskControlBlock run() {
+    Packet packet;
+    if (this.state == STATE_SUSPENDED_RUNNABLE) {
+      packet = this.queue;
+      this.queue = packet.link;
+      if (this.queue == null) {
+        this.state = STATE_RUNNING;
+      } else {
+        this.state = STATE_RUNNABLE;
+      }
+    } else {
+      packet = null;
+    }
+    return this.task.run(packet);
+  }
+
+  /**
+   * Adds a packet to the worklist of this block's task, marks this as runnable if
+   * necessary, and returns the next runnable object to run (the one
+   * with the highest priority).
+   */
+  public TaskControlBlock checkPriorityAdd(TaskControlBlock task, Packet packet) {
+    if (this.queue == null) {
+      this.queue = packet;
+      this.markAsRunnable();
+      if (this.priority > task.priority) return this;
+    } else {
+      this.queue = packet.addTo(this.queue);
+    }
+    return task;
+  }
+
+  @Override
+  public String toString() {
+    return "tcb { " + this.task + "@" + this.state + " }";
+  }
+
+  @Override
+  public TaskControlBlock run(Packet packet) {
+    return run();
+  }
+}
+
+interface Task {
+  TaskControlBlock run(Packet packet);
+}
+
+class WorkerTask implements Task {
+
+  private Scheduler scheduler;
+  private int v1;
+  private int v2;
+  /**
+   * A task that manipulates work packets.
+   * @param {Scheduler} scheduler the scheduler that manages this task
+   * @param {int} v1 a seed used to specify how work packets are manipulated
+   * @param {int} v2 another seed used to specify how work packets are manipulated
+   * @constructor
+   */
+  @SuppressWarnings("javadoc")
+  public WorkerTask(Scheduler scheduler, int v1, int v2) {
+    this.scheduler = scheduler;
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+
+  @Override
+  public TaskControlBlock run(Packet packet) {
+    if (packet == null) {
+      return this.scheduler.suspendCurrent();
+    } else {
+      if (this.v1 == Scheduler.ID_HANDLER_A) {
+        this.v1 = Scheduler.ID_HANDLER_B;
+      } else {
+        this.v1 = Scheduler.ID_HANDLER_A;
+      }
+      packet.id = this.v1;
+      packet.a1 = 0;
+      for (int i = 0; i < Packet.DATA_SIZE; i++) {
+        this.v2++;
+        if (this.v2 > 26) this.v2 = 1;
+        packet.a2[i] = this.v2;
+      }
+      return this.scheduler.queue(packet);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "WorkerTask";
+  }
+}
+
+/**
+ * This is the Java port of the JavaScript implementation of Richards benchmark from
+ * http://www.cl.cam.ac.uk/~mr10/Bench.html
+ *
+ * This benchmark (written in JavaScript) is part of the V8 benchmark suite.
+ */
+public class Richards {
+  /**
+   * The Richards benchmark simulates the task dispatcher of an
+   * operating system.
+   **/
+  public boolean runRichards() {
+    Scheduler scheduler = new Scheduler();
+    scheduler.addIdleTask(Scheduler.ID_IDLE, 0, null, COUNT);
+
+    Packet queue = new Packet(null, Scheduler.ID_WORKER, Scheduler.KIND_WORK);
+    queue = new Packet(queue,  Scheduler.ID_WORKER, Scheduler.KIND_WORK);
+    scheduler.addWorkerTask(Scheduler.ID_WORKER, 1000, queue);
+
+    queue = new Packet(null, Scheduler.ID_DEVICE_A, Scheduler.KIND_DEVICE);
+    queue = new Packet(queue,  Scheduler.ID_DEVICE_A, Scheduler.KIND_DEVICE);
+    queue = new Packet(queue,  Scheduler.ID_DEVICE_A, Scheduler.KIND_DEVICE);
+    scheduler.addHandlerTask(Scheduler.ID_HANDLER_A, 2000, queue);
+
+    queue = new Packet(null, Scheduler.ID_DEVICE_B, Scheduler.KIND_DEVICE);
+    queue = new Packet(queue,  Scheduler.ID_DEVICE_B, Scheduler.KIND_DEVICE);
+    queue = new Packet(queue,  Scheduler.ID_DEVICE_B, Scheduler.KIND_DEVICE);
+    scheduler.addHandlerTask(Scheduler.ID_HANDLER_B, 3000, queue);
+
+    scheduler.addDeviceTask(Scheduler.ID_DEVICE_A, 4000, null);
+
+    scheduler.addDeviceTask(Scheduler.ID_DEVICE_B, 5000, null);
+
+    scheduler.schedule();
+
+    if (scheduler.queueCount != EXPECTED_QUEUE_COUNT ||
+        scheduler.holdCount != EXPECTED_HOLD_COUNT) {
+      String msg =
+          "Error during execution: queueCount = " + scheduler.queueCount +
+          ", holdCount = " + scheduler.holdCount + ".";
+      System.out.println(msg);
+      return false;
+    }
+    return true;
+  }
+
+  public static final int COUNT = 1000;
+  /**
+   * These two constants specify how many times a packet is queued and
+   * how many times a task is put on hold in a correct run of richards.
+   * They don't have any meaning a such but are characteristic of a
+   * correct run so if the actual queue or hold count is different from
+   * the expected there must be a bug in the implementation.
+   **/
+  public static final int EXPECTED_QUEUE_COUNT = 2322;
+  public static final int EXPECTED_HOLD_COUNT = 928;
+
+  // CHECKSTYLE.ON: .*
+  public void timeRichards(int iterations) {
+    for (int iter = 0; iter < iterations; iter++) {
+      runRichards();
+    }
+  }
+
+  public boolean verifyRichards() {
+    if (!runRichards()) {
+      System.out.println("Run Richards failed");
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) {
+    Richards obj = new Richards();
+    long before = System.currentTimeMillis();
+    obj.timeRichards(1200);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Richards: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Sort.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Sort.java
new file mode 100644
index 0000000..d0b5cdc
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/algorithm/Sort.java
@@ -0,0 +1,492 @@
+/*
+ *    Copyright 2015 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description: Implementation of various sort algorithms.
+ *
+ * Main Focus:  array accesses, array copies, branching.
+ *
+ * TODO: Add more sorting algorithms.
+ */
+
+package art_benchmarks.algorithm;
+
+import java.lang.System;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Sort {
+  public ArrayList<int[]> systemSortArraysToVerify = new ArrayList<int[]>();
+  public ArrayList<int[]> bubbleSortArraysToVerify = new ArrayList<int[]>();
+  public ArrayList<int[]> insertionSortArraysToVerify = new ArrayList<int[]>();
+  public ArrayList<int[]> mergeSortArraysToVerify = new ArrayList<int[]>();
+
+  void initArray(int[] array) {
+    int copyBase;
+    int copySize;
+    for (copyBase = 0; copyBase < array.length; copyBase += copySize) {
+      copySize = Math.min(referenceInputArray.length, array.length - copyBase);
+      System.arraycopy(referenceInputArray, 0, array, copyBase, copySize);
+    }
+  }
+
+  boolean arraysEqual(int[] array_1, int[] array_2) {
+    int length = Math.min(array_1.length, array_2.length);
+    for (int i = 0; i < length; i++) {
+      if (array_1[i] != array_2[i]) {
+        System.out.println("ERROR: Arrays differ at index " + i + ": " +
+            array_1[i] + " != " + array_2[i]);
+        return false;
+      }
+    }
+    if (array_1.length != array_2.length) {
+      System.out.println("ERROR: Arrays have different lengths: " +
+          array_1.length + " != " + array_2.length);
+      return false;
+    }
+    return true;
+  }
+
+  boolean isArraySorted(int[] array) {
+    for (int i = 0; i < array.length - 1; ++i) {
+      if (array[i] > array[i + 1]) {
+        System.out.println("ERROR: The array is not sorted at index " + i + ": " +
+            array[i] + " > " + array[i + 1]);
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /* Bubble sort */
+
+  void bubbleSort(int[] array) {
+    for (int i = 0; i < array.length; ++i) {
+      for (int j = 0; j < array.length - i - 1; ++j) {
+        if (array[j] > array[j + 1]) {
+          int temp = array[j];
+          array[j] = array[j + 1];
+          array[j + 1] = temp;
+        }
+      }
+    }
+  }
+
+  public void benchBubbleSort(int arraySize, int iterations) {
+    int[] array = new int[arraySize];
+    bubbleSortArraysToVerify.add(array);
+    for (int iter = 0; iter < iterations; ++iter) {
+      initArray(array);
+      bubbleSort(array);
+    }
+  }
+
+  public boolean verifyBubbleSort() {
+    for (int[] array : bubbleSortArraysToVerify) {
+      int[] ref = new int[array.length];
+      initArray(ref);
+      Arrays.sort(ref);
+      if (!isArraySorted(array) || !arraysEqual(ref, array)) {
+        return false;
+      }
+    }
+    bubbleSortArraysToVerify.clear();
+    return true;
+  }
+
+
+  /* Insertion sort */
+
+  void insertionSort(int[] array) {
+    for (int k = 1; k < array.length; ++k) {
+      int i;
+      int key = array[k];
+      for (i = k; i > 0 && array[i - 1] > key; --i) {
+        array[i] = array[i - 1];
+      }
+      array[i] = key;
+    }
+  }
+
+  public void benchInsertionSort(int arraySize, int iterations) {
+    int[] array = new int[arraySize];
+    insertionSortArraysToVerify.add(array);
+    for (int iter = 0; iter < iterations; ++iter) {
+      initArray(array);
+      insertionSort(array);
+    }
+  }
+
+  public boolean verifyInsertionSort() {
+    for (int[] array : insertionSortArraysToVerify) {
+      int[] ref = new int[array.length];
+      initArray(ref);
+      Arrays.sort(ref);
+      if (!isArraySorted(array) || !arraysEqual(ref, array)) {
+        return false;
+      }
+    }
+    insertionSortArraysToVerify.clear();
+    return true;
+  }
+
+
+  /* Merge sort */
+
+  void mergeSort(int[] array, int[] scratch) {
+    mergeSort(array, 0, array.length, scratch);
+  }
+
+  void mergeSort(int[] array, int index, int size, int[] scratch) {
+    if (size <= 1) {
+      return;
+    }
+
+    int index_1 = index;
+    int size_1 = size / 2;
+    int index_2 = index + size_1;
+    int size_2 = size - size_1;
+    mergeSort(array, index_1, size_1, scratch);
+    mergeSort(array, index_2, size_2, scratch);
+    mergeArrays(array, index_1, size_1, index_2, size_2, scratch);
+  }
+
+  void mergeArrays(int[] array,
+                   int index_1, int size_1,
+                   int index_2, int size_2,
+                   int[] scratch) {
+    int end_1 = index_1 + size_1;
+    int end_2 = index_2 + size_2;
+    int i1 = index_1;
+    int i2 = index_2;
+    int j = 0;
+
+    while (i1 != end_1 && i2 != end_2) {
+      if (array[i1] < array[i2]) {
+        scratch[j] = array[i1];
+        ++i1;
+      } else {
+        scratch[j] = array[i2];
+        ++i2;
+      }
+      ++j;
+    }
+
+    if (i1 != end_1) {
+      System.arraycopy(array, i1, scratch, j, end_1 - i1);
+    }
+
+    if (i2 != end_2) {
+      System.arraycopy(array, i2, scratch, j, end_2 - i2);
+    }
+
+    System.arraycopy(scratch, 0, array, index_1, size_1 + size_2);
+  }
+
+  public void benchMergeSort(int arraySize, int iterations) {
+    int[] array = new int[arraySize];
+    int[] scratch = new int[arraySize];
+    mergeSortArraysToVerify.add(array);
+    for (int iter = 0; iter < iterations; ++iter) {
+      initArray(array);
+      mergeSort(array, scratch);
+    }
+  }
+
+  public boolean verifyMergeSort() {
+    for (int[] array : mergeSortArraysToVerify) {
+      int[] ref = new int[array.length];
+      initArray(ref);
+      Arrays.sort(ref);
+      if (!isArraySorted(array) || !arraysEqual(ref, array)) {
+        return false;
+      }
+    }
+    mergeSortArraysToVerify.clear();
+    return true;
+  }
+
+
+  /* System sort */
+
+  void systemSort(int[] array) {
+    // This is wrapped in a helper to match the implementation for other sort
+    // algorithms.
+    Arrays.sort(array);
+  }
+
+  void benchSystemSort(int arraySize, int iterations) {
+    int[] array = new int[arraySize];
+    systemSortArraysToVerify.add(array);
+    for (int iter = 0; iter < iterations; ++iter) {
+      initArray(array);
+      systemSort(array);
+    }
+  }
+
+  public boolean verifySystemSort() {
+    for (int[] array : systemSortArraysToVerify) {
+      int[] ref = new int[array.length];
+      System.arraycopy(array, 0, ref, 0, array.length);
+      Arrays.sort(ref);
+      if (!isArraySorted(array) || !arraysEqual(ref, array)) {
+        return false;
+      }
+    }
+    systemSortArraysToVerify.clear();
+    return true;
+  }
+
+
+  // CHECKSTYLE.OFF: LeftCurly
+  // CHECKSTYLE.OFF: RightCurly
+  // CHECKSTYLE.OFF: EmptyLineSeparator
+  public void timeBubbleSort____16(int iterations) { benchBubbleSort(   16, iterations); }
+  public void timeBubbleSort___128(int iterations) { benchBubbleSort(  128, iterations); }
+  public void timeBubbleSort__2048(int iterations) { benchBubbleSort( 2048, iterations); }
+  public void timeInsertionSort____16(int iterations) { benchInsertionSort(   16, iterations); }
+  public void timeInsertionSort___128(int iterations) { benchInsertionSort(  128, iterations); }
+  public void timeInsertionSort__2048(int iterations) { benchInsertionSort( 2048, iterations); }
+  public void timeMergeSort____16(int iterations) { benchMergeSort(   16, iterations); }
+  public void timeMergeSort___128(int iterations) { benchMergeSort(  128, iterations); }
+  public void timeMergeSort__2048(int iterations) { benchMergeSort( 2048, iterations); }
+  public void timeSystemSort____16(int iterations) { benchSystemSort(   16, iterations); }
+  public void timeSystemSort___128(int iterations) { benchSystemSort(  128, iterations); }
+  public void timeSystemSort__2048(int iterations) { benchSystemSort( 2048, iterations); }
+  // CHECKSTYLE.ON: EmptyLineSeparator
+  // CHECKSTYLE.ON: RightCurly
+  // CHECKSTYLE.ON: LeftCurly
+
+
+  public static void main(String[] args) {
+    int rc = 0;
+    long b;               // before
+    long a;               // after
+    Sort o = new Sort();  // object
+
+    // The number of iterations run were calibrated so that each benchmark runs in about one second.
+
+    // CHECKSTYLE.OFF: LineLength
+    // CHECKSTYLE.OFF: OneStatementPerLine
+    b = System.currentTimeMillis(); o.timeBubbleSort____16(700000); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.BubbleSort____16: " + (a - b));
+    b = System.currentTimeMillis(); o.timeBubbleSort___128(15500); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.BubbleSort___128: " + (a - b));
+    b = System.currentTimeMillis(); o.timeBubbleSort__2048(60); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.BubbleSort__2048: " + (a - b));
+    if (!o.verifyBubbleSort()) {
+      rc++;
+    }
+
+    b = System.currentTimeMillis(); o.timeInsertionSort____16(1450000); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.InsertionSort____16: " + (a - b));
+    b = System.currentTimeMillis(); o.timeInsertionSort___128(40000); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.InsertionSort___128: " + (a - b));
+    b = System.currentTimeMillis(); o.timeInsertionSort__2048(170); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.InsertionSort__2048: " + (a - b));
+    if (!o.verifyInsertionSort()) {
+      rc++;
+    }
+
+    b = System.currentTimeMillis(); o.timeMergeSort____16(110000); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.MergeSort____16: " + (a - b));
+    b = System.currentTimeMillis(); o.timeMergeSort___128(12000); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.MergeSort___128: " + (a - b));
+    b = System.currentTimeMillis(); o.timeMergeSort__2048(600); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.MergeSort__2048: " + (a - b));
+    if (!o.verifyMergeSort()) {
+      rc++;
+    }
+
+    b = System.currentTimeMillis(); o.timeSystemSort____16(1200000); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.SystemSort____16: " + (a - b));
+    b = System.currentTimeMillis(); o.timeSystemSort___128(100000); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.SystemSort___128: " + (a - b));
+    b = System.currentTimeMillis(); o.timeSystemSort__2048(6250); a = System.currentTimeMillis();
+    System.out.println("art_benchmarks/algorithm/Sort.SystemSort__2048: " + (a - b));
+    if (!o.verifySystemSort()) {
+      rc++;
+    }
+    // CHECKSTYLE.ON: OneStatementPerLine
+    // CHECKSTYLE.ON: LineLength
+
+    System.exit(rc);
+  }
+
+  // Array of 2048 integers between 0 and 4096.
+  public int[] referenceInputArray = {
+    2334, 3368, 316, 762, 3183, 3200, 1037, 814, 238, 1882, 3382, 3682, 4034,
+    2655, 119, 1820, 1287, 896, 1871, 939, 1478, 3882, 327, 3368, 1764, 3712,
+    2363, 2823, 878, 3094, 1961, 3351, 1518, 2658, 2627, 3537, 4096, 1917, 1403,
+    183, 61, 1753, 2223, 3080, 2952, 1514, 1291, 1588, 4037, 960, 721, 3470,
+    574, 3277, 3068, 3190, 3257, 481, 2698, 2817, 1863, 3671, 2677, 3969, 1403,
+    3408, 3829, 2487, 136, 3810, 2247, 1402, 2680, 2255, 1532, 723, 1274, 655,
+    2389, 1820, 59, 10, 3981, 3605, 2735, 3959, 1914, 808, 3485, 507, 1345, 545,
+    1673, 1056, 4074, 1257, 1165, 1625, 3505, 1686, 3927, 3842, 3216, 276, 1930,
+    1578, 2915, 2400, 3401, 1150, 987, 3350, 2338, 2333, 1489, 3395, 2157, 3475,
+    2861, 4067, 2135, 2893, 1518, 3298, 1954, 3512, 2219, 576, 3776, 19, 3784,
+    3922, 1769, 1000, 2440, 3949, 1725, 55, 2194, 3764, 1178, 615, 1722, 152,
+    476, 2947, 2700, 2076, 1985, 1631, 1823, 1300, 62, 1389, 1821, 3313, 1350,
+    15, 3015, 3639, 2281, 4039, 2284, 3560, 4044, 764, 163, 3989, 152, 1347,
+    3069, 3801, 3256, 301, 71, 1419, 1781, 2832, 2671, 1977, 450, 472, 1834,
+    2478, 2735, 1940, 996, 1954, 269, 408, 246, 1995, 2937, 273, 766, 3012,
+    1215, 2538, 2222, 480, 157, 60, 3107, 33, 2551, 246, 482, 4000, 700, 90,
+    540, 3359, 1436, 344, 3751, 2657, 3406, 2072, 2245, 2896, 127, 2157, 249,
+    2185, 813, 336, 2757, 1456, 1, 2565, 3178, 2235, 2069, 759, 1932, 570, 1386,
+    2236, 3192, 3138, 2720, 3819, 1111, 3340, 360, 2998, 3344, 2350, 781, 3474,
+    1870, 2608, 2456, 3740, 1845, 2802, 1109, 2042, 1671, 1794, 3774, 3073,
+    2339, 3191, 374, 668, 1243, 3421, 1541, 3376, 2986, 2209, 167, 1652, 1908,
+    3567, 233, 2703, 3753, 3548, 3642, 3703, 3792, 16, 3612, 867, 2130, 1271,
+    318, 440, 1097, 350, 2211, 163, 1226, 3265, 3882, 3513, 3651, 316, 523,
+    1757, 1691, 718, 3637, 3634, 2677, 3938, 1781, 2890, 683, 2605, 1631, 2673,
+    2347, 274, 1726, 1084, 539, 1368, 1448, 225, 3042, 345, 310, 698, 2257,
+    3208, 2427, 330, 4091, 463, 2033, 107, 331, 1968, 1339, 3495, 2764, 3114,
+    1095, 2693, 3699, 963, 2466, 1517, 1088, 672, 1658, 1345, 2455, 2454, 223,
+    469, 3347, 2699, 1937, 2029, 2467, 1735, 2244, 3866, 1214, 1907, 2717, 47,
+    2301, 2051, 1156, 2391, 3241, 2644, 912, 2535, 1911, 1350, 854, 2909, 2001,
+    4063, 983, 2565, 3495, 1875, 1187, 4025, 1613, 3390, 1376, 3970, 2297, 1511,
+    305, 3331, 2630, 1867, 2989, 1718, 2037, 3504, 3628, 1133, 2705, 864, 3325,
+    1106, 2662, 2093, 2283, 753, 494, 3, 2892, 2687, 2244, 4044, 2087, 3200,
+    1712, 1879, 1197, 2820, 1473, 2045, 3757, 16, 421, 435, 2504, 1236, 1415,
+    3889, 1336, 1754, 2679, 2196, 3680, 3431, 385, 744, 3835, 1959, 3117, 2690,
+    2990, 3598, 2355, 1242, 2711, 2032, 2145, 3509, 2963, 567, 1549, 772, 1554,
+    249, 184, 228, 1631, 361, 1605, 2984, 2287, 571, 2158, 3658, 1401, 383,
+    2495, 777, 869, 3625, 952, 3691, 1831, 1350, 1856, 3872, 1960, 2243, 2234,
+    2970, 3468, 1180, 3416, 1551, 4088, 4043, 2043, 3889, 539, 1200, 2145, 2346,
+    1641, 1303, 2022, 1924, 1342, 3348, 723, 1766, 1170, 2377, 2732, 2995, 1649,
+    3766, 1760, 2390, 1193, 451, 2134, 2568, 486, 987, 548, 3733, 2687, 2357,
+    4060, 556, 586, 3663, 1410, 1502, 1637, 2670, 874, 2465, 3958, 3091, 1433,
+    471, 1251, 2567, 3695, 1768, 2569, 2546, 585, 1767, 1098, 962, 1900, 1943,
+    3367, 3878, 3247, 2893, 3627, 3429, 3668, 3800, 369, 4004, 3444, 2820, 1642,
+    2090, 1880, 3611, 1964, 1689, 1369, 679, 2033, 2832, 596, 2040, 3932, 856,
+    994, 2678, 2486, 737, 1402, 3979, 3183, 2082, 1323, 3093, 1853, 1704, 3546,
+    2967, 659, 2559, 400, 668, 3881, 1090, 3153, 1287, 1183, 2884, 2753, 1757,
+    2133, 2618, 1581, 2308, 2742, 3596, 3592, 3789, 2704, 2035, 1098, 494, 1896,
+    1581, 2384, 2679, 101, 401, 3097, 69, 3251, 1574, 3695, 1287, 3663, 2378,
+    1706, 2136, 2847, 2361, 1416, 1556, 2448, 2072, 3539, 1726, 75, 1927, 3933,
+    583, 2838, 1993, 2715, 1825, 2538, 3867, 3039, 3757, 1726, 2808, 141, 1378,
+    3750, 849, 1592, 342, 288, 97, 1647, 3110, 540, 1231, 3832, 2012, 3065, 393,
+    1695, 626, 2258, 2285, 3782, 1227, 3432, 2595, 1980, 225, 403, 912, 1871,
+    3255, 3456, 964, 1053, 1006, 1263, 792, 1377, 1573, 176, 2474, 34, 1257,
+    409, 717, 1901, 1119, 873, 3322, 2880, 3092, 2199, 797, 1574, 2379, 2541,
+    1689, 427, 2586, 2384, 945, 179, 1001, 2777, 2855, 1207, 3187, 210, 2436,
+    1862, 3120, 491, 1030, 1890, 3212, 3658, 2933, 2914, 681, 3592, 93, 2709,
+    3270, 112, 3239, 2541, 28, 2323, 3735, 39, 364, 86, 1055, 947, 3367, 3778,
+    636, 1269, 3045, 116, 296, 3843, 3650, 338, 3408, 145, 1020, 3632, 435,
+    4056, 554, 1456, 3931, 3549, 1028, 2169, 2176, 2798, 344, 3291, 3183, 2904,
+    2959, 1293, 3176, 557, 1705, 3583, 3297, 2395, 2157, 976, 399, 803, 228,
+    3382, 4035, 3951, 3188, 3822, 1158, 3386, 1849, 3777, 1398, 3793, 2749,
+    1691, 247, 278, 493, 3061, 3826, 153, 879, 1070, 2355, 1502, 3198, 999,
+    2047, 1762, 1753, 2470, 1331, 2190, 1708, 997, 2280, 1863, 1931, 2690, 4074,
+    3585, 2030, 3792, 958, 1425, 1707, 506, 2363, 1847, 2721, 3630, 362, 626,
+    1012, 784, 2069, 3268, 3060, 2717, 489, 1421, 1287, 3552, 540, 1486, 1306,
+    1736, 3397, 2930, 1499, 3337, 57, 2044, 718, 3081, 2252, 3348, 2806, 2335,
+    3172, 2126, 3998, 1304, 2460, 2553, 3548, 3457, 1967, 1844, 2973, 2288, 118,
+    810, 2469, 1371, 1522, 279, 1963, 1659, 57, 1260, 2275, 3243, 389, 3952,
+    465, 1557, 3294, 2064, 382, 1182, 484, 1698, 1170, 572, 4029, 1395, 3521,
+    1009, 3313, 4062, 2595, 2559, 2172, 72, 3685, 3803, 1498, 224, 3731, 2441,
+    3514, 2479, 1831, 96, 2615, 878, 2216, 352, 1741, 503, 1701, 327, 2966, 916,
+    3139, 2295, 3377, 1137, 1714, 3449, 722, 2728, 3608, 1427, 1876, 971, 3573,
+    1661, 1008, 2130, 2689, 821, 2946, 1070, 1511, 2574, 3153, 3913, 1552, 3496,
+    2448, 1220, 457, 2640, 118, 3010, 3361, 3749, 2266, 3770, 1788, 524, 1802,
+    3054, 2271, 3887, 3728, 1749, 2525, 1498, 3421, 35, 3185, 1150, 1452, 3468,
+    1289, 2541, 608, 2601, 269, 2097, 1466, 2073, 1542, 1544, 236, 1082, 2626,
+    1117, 1462, 2959, 3254, 1435, 1584, 2672, 1452, 1384, 814, 3983, 2447, 859,
+    2087, 3211, 2873, 1842, 2524, 4021, 2025, 1824, 342, 3795, 2637, 2490, 1376,
+    1647, 3405, 1709, 2148, 861, 305, 3486, 3263, 690, 1410, 341, 1405, 2148,
+    439, 3895, 3074, 425, 1108, 1518, 3874, 854, 797, 2417, 840, 3603, 1178,
+    3640, 3018, 2911, 675, 578, 657, 2937, 2478, 2216, 1596, 2886, 1540, 1016,
+    4, 1331, 2519, 1255, 1134, 2685, 2129, 3927, 3993, 1793, 3279, 817, 3844,
+    1372, 3043, 472, 1522, 3667, 3724, 1115, 104, 1084, 1218, 3029, 3767, 2870,
+    3170, 3925, 3452, 973, 3400, 928, 751, 2177, 2972, 62, 3708, 3216, 4081,
+    2573, 232, 532, 3128, 1400, 1855, 2601, 3443, 1938, 490, 2985, 8, 1906,
+    1517, 1040, 14, 817, 2736, 3031, 240, 546, 3833, 3585, 3193, 990, 1687,
+    3489, 3669, 1278, 1746, 3673, 3694, 2077, 743, 3534, 880, 2814, 3330, 3714,
+    4038, 3426, 2433, 3181, 2441, 2797, 3547, 274, 940, 1937, 2487, 1964, 1565,
+    2240, 2976, 784, 1994, 15, 3599, 2234, 2374, 2175, 3704, 301, 95, 3955,
+    2064, 896, 1528, 578, 220, 1574, 1072, 2192, 3048, 2556, 2502, 2240, 1915,
+    3715, 3794, 3072, 3282, 2572, 3300, 2035, 3078, 2902, 3887, 1721, 3263,
+    1009, 1915, 1247, 3648, 350, 3348, 1651, 1276, 3180, 2334, 2578, 3269, 1203,
+    1088, 436, 1827, 3548, 2587, 3299, 3949, 2846, 1692, 3043, 2627, 1653, 4062,
+    2388, 680, 3926, 166, 639, 1142, 2405, 1421, 3214, 2027, 1428, 2361, 3456,
+    2250, 3648, 2972, 533, 3470, 2157, 1847, 1317, 1708, 3781, 785, 2228, 250,
+    2563, 906, 1771, 1688, 1587, 3149, 1748, 2180, 3331, 3389, 2294, 423, 1041,
+    190, 982, 1994, 755, 2149, 3773, 1922, 3293, 3233, 300, 3402, 846, 1316,
+    2397, 2408, 2425, 2857, 3848, 1097, 3559, 3113, 52, 3200, 964, 815, 3382,
+    1242, 4034, 2382, 2853, 743, 3592, 3375, 685, 688, 933, 3038, 3825, 446,
+    2557, 3657, 2696, 3087, 1866, 4059, 1593, 1171, 164, 1016, 2375, 2373, 3580,
+    3586, 208, 2648, 2261, 1487, 1720, 559, 1116, 1666, 3735, 3944, 3875, 422,
+    3886, 1370, 3677, 3071, 1797, 2133, 2522, 804, 3164, 1138, 3442, 3937, 2909,
+    1765, 3507, 1010, 3145, 1803, 2101, 3072, 2252, 2533, 1617, 3981, 3593,
+    1446, 1508, 3070, 754, 3477, 2722, 2573, 2528, 110, 766, 1593, 3906, 1958,
+    3712, 2160, 3184, 2577, 821, 3929, 888, 2165, 322, 2508, 516, 4033, 3297,
+    3008, 3297, 2073, 757, 2210, 3969, 2033, 481, 3138, 3901, 3578, 1020, 2160,
+    237, 3190, 1360, 3553, 3310, 3969, 851, 1804, 1243, 1712, 2506, 3500, 3469,
+    720, 3664, 3137, 2173, 186, 2323, 2198, 2382, 3037, 2661, 3213, 664, 1068,
+    3244, 2435, 211, 3897, 1976, 1595, 619, 1676, 13, 3431, 2809, 2512, 518,
+    2794, 2701, 484, 916, 1572, 970, 786, 1077, 1854, 3864, 1771, 80, 587, 3045,
+    2171, 1159, 4085, 511, 370, 3259, 9, 1977, 3555, 961, 3788, 3926, 450, 135,
+    277, 515, 2208, 2922, 4063, 1879, 2394, 824, 1827, 824, 405, 1783, 483,
+    1718, 1169, 3737, 3441, 2808, 3326, 3481, 3182, 626, 1129, 3495, 3466, 3935,
+    83, 401, 3369, 336, 2954, 2355, 3485, 1562, 370, 413, 567, 2818, 3581, 859,
+    209, 3382, 2722, 2060, 1476, 855, 601, 3819, 3928, 2099, 3158, 538, 485,
+    837, 840, 3176, 3231, 1056, 1528, 3667, 3623, 2400, 790, 2658, 749, 3115,
+    254, 1333, 2409, 1334, 2894, 3703, 1644, 1779, 3676, 847, 3745, 1362, 255,
+    191, 3153, 2421, 1775, 2068, 2016, 1827, 3279, 852, 2295, 3979, 4038, 2588,
+    2132, 606, 496, 3576, 508, 1915, 1261, 1592, 970, 3458, 3183, 3879, 1933,
+    2426, 2477, 259, 1953, 2393, 4040, 1130, 2807, 2397, 326, 4044, 61, 2638,
+    332, 3219, 2094, 1448, 1416, 2597, 2607, 2340, 3921, 3573, 3556, 3557, 3603,
+    264, 1189, 2079, 995, 2188, 1437, 810, 3105, 1828, 498, 3495, 1253, 1165,
+    82, 1455, 1916, 2976, 99, 3774, 1784, 1471, 2874, 2121, 3058, 1307, 71,
+    1012, 3399, 582, 1713, 918, 1509, 3076, 3313, 1307, 3051, 3074, 2073, 1243,
+    825, 3574, 829, 3028, 3849, 2561, 1365, 461, 50, 100, 2088, 607, 651, 1400,
+    3572, 1565, 569, 270, 1392, 340, 3706, 2992, 450, 2113, 679, 1381, 3876,
+    243, 4013, 366, 1733, 1010, 1445, 1042, 789, 1600, 2786, 1595, 796, 3670,
+    987, 3824, 593, 3069, 4014, 2248, 866, 2830, 3896, 354, 2185, 2455, 2467,
+    2320, 2107, 1534, 2670, 1978, 2632, 1679, 38, 2260, 1374, 2619, 2966, 1638,
+    2447, 2289, 667, 361, 2647, 704, 2704, 3679, 2808, 1940, 1873, 1580, 1259,
+    2237, 723, 2154, 2284, 1848, 3076, 2250, 2498, 3334, 361, 3172, 3369, 3468,
+    539, 2594, 2385, 1715, 1254, 881, 3530, 2686, 3063, 2654, 145, 2218, 3711,
+    3392, 2429, 1275, 3471, 314, 1024, 3971, 1371, 1355, 3974, 3318, 1819, 2714,
+    1814, 2031, 555, 2791, 896, 380, 1662, 1377, 3602, 3447, 2729, 684, 2374,
+    391, 2868, 2601, 1545, 2449, 1651, 198, 1140, 302, 3546, 2249, 115, 755,
+    3324, 1374, 3705, 3587, 3735, 1642, 2067, 452, 3342, 3069, 1232, 698, 2784,
+    540, 570, 2657, 511, 1497, 992, 959, 1301, 1707, 2992, 2306, 4019, 1358,
+    809, 1967, 1468, 1531, 1919, 1330, 1197, 404, 1364, 1142, 3059, 3067, 1536,
+    2546, 1358, 1653, 71, 3120, 2224, 2437, 2927, 2440, 2138, 1114, 824, 2324,
+    1726, 3246, 1541, 2062, 3733, 2749, 3844, 1678, 3838, 1938, 2393, 2321,
+    3419, 3709, 3162, 1033, 2216, 1799, 2512, 2171, 2826, 2962, 3531, 1548, 911,
+    1386, 3111, 265, 3387, 4046, 3869, 899, 1453, 1559, 1177, 1665, 3498, 811,
+    3273, 1545, 403, 1785, 263, 2975, 932, 3279, 2709, 1807, 1895, 3470, 3771,
+    3649, 766, 265, 3105, 2402, 3065, 3489, 3392, 3325, 1219, 1362, 272, 449,
+    89, 1814, 1424, 1929, 3234, 3643, 3773, 862, 3938, 2957, 3773, 415, 1770,
+    2999, 3167, 3992, 3640, 405, 2616, 2046, 919, 1019, 324, 2104, 3851, 3795,
+    1571, 2779, 2360, 1915, 2773, 1359, 2850, 1891, 480, 589, 2772, 2449, 977,
+    2106, 2539, 1262, 1129, 2383, 3092, 4023, 50, 2228, 367, 3644, 1100, 2055,
+    2203, 3067, 3062, 42, 313, 3685, 3606, 1462, 3324, 2052, 2355, 2586, 3762,
+    2879, 3653, 38, 783, 1262, 1540, 3002, 1466, 1639, 3472, 1801, 3830, 3801,
+    2620, 514, 1183, 2361, 3002, 2043, 2020, 3798, 1198, 3151, 942, 4016, 2957,
+    4018, 2874, 4095, 1358, 2796, 2728, 3034, 2927, 1224, 1178, 24, 2396, 3422,
+    124, 3164, 635, 170, 4083, 3085, 2528, 1685, 3959, 2319, 3832, 3223, 65,
+    3899, 48, 3629, 2633, 3241, 2127, 2291, 2725, 1067, 3772, 2948, 2816, 3493,
+    3732, 578, 3219, 4026, 635, 2807, 417, 2868, 929, 3072, 3312, 238, 1584, 92,
+    807, 2235, 794, 1233, 3815, 4074, 1105, 141, 1315, 1517, 2346, 1132, 3899,
+    3904, 3063, 3085, 1630, 1880, 743, 1825, 1793, 2441, 709, 2477, 3382, 348,
+    2626
+  };
+}
+
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/LICENSE b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/LICENSE
new file mode 100644
index 0000000..330d9e7
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/LICENSE
@@ -0,0 +1,34 @@
+Revised BSD license
+
+This is a specific instance of the Open Source Initiative (OSI) BSD license
+template http://www.opensource.org/licenses/bsd-license.php
+
+
+Copyright © 2004-2008 Brent Fulgham, 2005-2015 Isaac Gouy
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+   Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+   Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+   Neither the name of "The Computer Language Benchmarks Game" nor the name of
+   of "The Computer Language Shootout Benchmarks" nor the names of its
+   contributors may be used to endorse or promote products derived from this
+   software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/binarytrees.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/binarytrees.java
new file mode 100644
index 0000000..97df4c7
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/binarytrees.java
@@ -0,0 +1,118 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `binarytrees/binarytrees.java-2.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Jarkko Miettinen
+ */
+
+/*
+ * Description:     Allocate and deallocate many many binary trees.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+// CHECKSTYLE.OFF: .*
+public class binarytrees {
+
+   private static final int PREDEFINED_DEPTH = 10;
+   private final static int minDepth = 4;
+   
+   public int old_main(){
+      int n = 0;
+      int maxDepth = (minDepth + 2 > PREDEFINED_DEPTH) ? minDepth + 2 : PREDEFINED_DEPTH;
+      int stretchDepth = maxDepth + 1;
+      
+      int check = (TreeNode.bottomUpTree(0,stretchDepth)).itemCheck();
+      
+      TreeNode longLivedTree = TreeNode.bottomUpTree(0,maxDepth);
+      
+      for (int depth=minDepth; depth<=maxDepth; depth+=2){
+         int iterations = 1 << (maxDepth - depth + minDepth);
+         check = 0;
+         
+         for (int i=1; i<=iterations; i++){
+            check += (TreeNode.bottomUpTree(i,depth)).itemCheck();
+            check += (TreeNode.bottomUpTree(-i,depth)).itemCheck();
+         }
+      }   
+      return check;
+   }
+   
+   
+   private static class TreeNode
+   {
+      private TreeNode left, right;
+      private int item;
+      
+      TreeNode(int item){
+         this.item = item;
+      }
+      
+      private static TreeNode bottomUpTree(int item, int depth){
+         if (depth>0){
+            return new TreeNode(
+                  bottomUpTree(2*item-1, depth-1)
+                  , bottomUpTree(2*item, depth-1)
+                  , item
+            );
+         }
+         else {
+            return new TreeNode(item);
+         }
+      }
+      
+      TreeNode(TreeNode left, TreeNode right, int item){
+         this.left = left;
+         this.right = right;
+         this.item = item;
+      }
+      
+      private int itemCheck(){
+         // if necessary deallocate here
+         if (left==null) return item;
+         else return item + left.itemCheck() - right.itemCheck();
+      }
+   }
+  // CHECKSTYLE.ON: .*
+
+  public void timeBinaryTrees(int iters) {
+    for (int j = 0; j < iters; j++) {
+      old_main();
+    }
+  }
+
+  public boolean verifyBinaryTrees() {
+    int expected = -32;
+    int found = old_main();
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    binarytrees obj = new binarytrees();
+    final long before = System.currentTimeMillis();
+    obj.timeBinaryTrees(30);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyBinaryTrees()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/binarytrees: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/chameneosredux.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/chameneosredux.java
new file mode 100644
index 0000000..6569388
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/chameneosredux.java
@@ -0,0 +1,275 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `chameneosredux/chameneosredux.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Michael Barker
+ */
+
+/*
+ * Description:     Symmetrical thread rendezvous requests.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+
+/**
+ * This implementation uses the java.util.concurrent.atomic library
+ * i.e. (compare and set) to avoid locking.  Real threads are used, but
+ * are set up as a thread pool and meeting requests are pushed onto a
+ * queue that feeds the thread pool.
+ */
+// CHECKSTYLE.OFF: .*
+public final class chameneosredux {
+
+    enum Colour {
+        blue,
+        red,
+        yellow
+    }
+
+    private static Colour doCompliment(final Colour c1, final Colour c2) {
+        switch (c1) {
+        case blue:
+            switch (c2) {
+            case blue:
+                return Colour.blue;
+            case red:
+                return Colour.yellow;
+            case yellow:
+                return Colour.red;
+            }
+        case red:
+            switch (c2) {
+            case blue:
+                return Colour.yellow;
+            case red:
+                return Colour.red;
+            case yellow:
+                return Colour.blue;
+            }
+        case yellow:
+            switch (c2) {
+            case blue:
+                return Colour.red;
+            case red:
+                return Colour.blue;
+            case yellow:
+                return Colour.yellow;
+            }
+        }
+
+        throw new RuntimeException("Error");
+    }
+
+    static final class MeetingPlace {
+
+        private final AtomicInteger meetingsLeft;
+        private final AtomicReference<Creature> creatureRef = new AtomicReference<Creature>();
+
+        public MeetingPlace(final int meetings) {
+            meetingsLeft = new AtomicInteger(meetings);
+        }
+
+        public void meet(final Creature incoming) {
+            Colour newColour = null;
+            Creature first = null;
+            Creature next = null;
+            do {
+                first = creatureRef.get();
+                next = incoming;
+                if (first != null) {
+                    newColour = doCompliment(incoming.colour, first.colour);
+                    next = null;
+                }
+            } while (!creatureRef.compareAndSet(first, next));
+
+            if (first != null) {
+                final int meetings = meetingsLeft.decrementAndGet();
+                if (meetings >= 0) {
+                    first.setColour(incoming.id, newColour);
+                    incoming.setColour(first.id, newColour);
+                } else {
+                    first.complete();
+                    incoming.complete();
+                }
+            }
+        }
+    }
+
+    static final class Dispatcher implements Runnable {
+        private final BlockingQueue<Creature> q;
+
+        public Dispatcher(final BlockingQueue<Creature> q) {
+            this.q = q;
+        }
+
+        public void run() {
+            try {
+                while (true) {
+                    q.take().run();
+                }
+            } catch (final InterruptedException e) {
+            }
+        }
+    }
+
+    static final class Creature {
+
+        private final int id;
+        private final MeetingPlace place;
+        private final BlockingQueue<Creature> q;
+        private final CountDownLatch latch;
+        private int count = 0;
+        private int sameCount = 0;
+        private Colour colour;
+
+        public Creature(final MeetingPlace place, final Colour colour,
+                        final BlockingQueue<Creature> q, final CountDownLatch latch) {
+            this.id = System.identityHashCode(this);
+            this.place = place;
+            this.latch = latch;
+            this.colour = colour;
+            this.q = q;
+        }
+
+        public void complete() {
+            latch.countDown();
+        }
+
+        public void setColour(final int id, final Colour newColour) {
+            this.colour = newColour;
+            count++;
+            sameCount += 1 ^ Integer.signum(abs(this.id - id));
+            q.add(this);
+        }
+
+        private int abs(final int x) {
+            final int y = x >> 31;
+            return (x ^ y) - y;
+        }
+
+        public void run() {
+            place.meet(this);
+        }
+
+        public int getCount() {
+            return count;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(count) + getNumber(sameCount);
+        }
+    }
+
+    private int run(final int n, final Colour...colours) {
+        final int len = colours.length;
+        final MeetingPlace place = new MeetingPlace(n);
+        final Creature[] creatures = new Creature[len];
+        final BlockingQueue<Creature> q = new ArrayBlockingQueue<Creature>(len);
+        final CountDownLatch latch = new CountDownLatch(len - 1);
+
+        for (int i = 0; i < len; i++) {
+            creatures[i] = new Creature(place, colours[i], q, latch);
+        }
+
+        final Thread[] ts = new Thread[len];
+        for (int i = 0, h = ts.length; i < h; i++) {
+            ts[i] = new Thread(new Dispatcher(q));
+            ts[i].setDaemon(true);
+            ts[i].start();
+        }
+
+        for (final Creature creature : creatures) {
+            q.add(creature);
+        }
+
+        try {
+            latch.await();
+            for (final Thread t : ts) {
+                t.interrupt();
+            }
+            for (final Thread t : ts) {
+                t.join();
+            }
+        } catch (final InterruptedException e1) {
+            System.err.println("Existing with error: " + e1);
+        }
+
+        int total = 0;
+        for (final Creature creature : creatures) {
+            total += creature.getCount();
+        }
+        return total;
+    }
+
+    private static final String[] NUMBERS = {
+        "zero", "one", "two", "three", "four", "five",
+        "six", "seven", "eight", "nine"
+    };
+
+    private static String getNumber(final int n) {
+        final StringBuilder sb = new StringBuilder();
+        final String nStr = String.valueOf(n);
+        for (int i = 0; i < nStr.length(); i++) {
+            sb.append(" ");
+            sb.append(NUMBERS[Character.getNumericValue(nStr.charAt(i))]);
+        }
+
+        return sb.toString();
+    }
+    // CHECKSTYLE.ON: .*
+
+  private static final int PREDEFINED_N = 600;
+
+  public void timeChameneosRedux(int iters) {
+    for (int i = 0; i < iters; i++) {
+      run(PREDEFINED_N, Colour.blue, Colour.red, Colour.yellow);
+      run(PREDEFINED_N, Colour.blue, Colour.red, Colour.yellow, Colour.red, Colour.yellow,
+                        Colour.blue, Colour.red, Colour.yellow, Colour.red, Colour.blue);
+    }
+  }
+
+  public boolean verifyChameneosRedux() {
+    int expected = 1200;
+    int found = run(PREDEFINED_N, Colour.blue, Colour.red, Colour.yellow, Colour.red, Colour.yellow,
+                                  Colour.blue, Colour.red, Colour.yellow, Colour.red, Colour.blue);
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(final String[] args) {
+    int rc = 0;
+    chameneosredux obj = new chameneosredux();
+
+    final long before = System.currentTimeMillis();
+    obj.timeChameneosRedux(40);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyChameneosRedux()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/chameneosredux: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fannkuchredux.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fannkuchredux.java
new file mode 100644
index 0000000..eb9b9ec
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fannkuchredux.java
@@ -0,0 +1,114 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `fannkuchredux/fannkuchredux.java-2.java` from the
+ * archive available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause).
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Isaac Gouy
+ * converted to Java by Oleg Mazurov
+ */
+
+/*
+ * Description:     Indexed-access to tiny integer-sequence.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+ // CHECKSTYLE.OFF: .*
+public class fannkuchredux
+{
+   public int fannkuch(int n) {
+      int[] perm = new int[n];
+      int[] perm1 = new int[n];
+      int[] count = new int[n];
+      int maxFlipsCount = 0;
+      int permCount = 0;
+      int checksum = 0;
+
+      for(int i=0; i<n; i++) perm1[i] = i;
+      int r = n;
+
+      while (true) {
+
+         while (r != 1){ count[r-1] = r; r--; }
+
+         for(int i=0; i<n; i++) perm[i] = perm1[i];
+         int flipsCount = 0;
+         int k;
+
+         while ( !((k=perm[0]) == 0) ) {
+            int k2 = (k+1) >> 1;
+            for(int i=0; i<k2; i++) {
+               int temp = perm[i]; perm[i] = perm[k-i]; perm[k-i] = temp;
+            }
+            flipsCount++;
+         }
+
+         maxFlipsCount = Math.max(maxFlipsCount, flipsCount);
+         checksum += permCount%2 == 0 ? flipsCount : -flipsCount;
+
+         // Use incremental change to generate another permutation
+         while (true) {
+            if (r == n) {
+	       return maxFlipsCount;
+	    }
+            int perm0 = perm1[0];
+            int i = 0;
+            while (i < r) {
+               int j = i + 1;
+               perm1[i] = perm1[j];
+               i = j;
+            }
+            perm1[r] = perm0;
+
+            count[r] = count[r] - 1;
+            if (count[r] > 0) break;
+            r++;
+         }
+
+         permCount++;
+      }
+   }
+   // CHECKSTYLE.ON: .*
+
+  private static final int PREDEFINED_N_PANCAKES = 7;
+
+  public void timeFannkuchRedux(int iters) {
+    for (int i = 0; i < iters; i++) {
+      fannkuch(PREDEFINED_N_PANCAKES);
+    }
+  }
+
+  public boolean verifyFannkuchRedux() {
+    int expected = 16;
+    int found = fannkuch(PREDEFINED_N_PANCAKES);
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    fannkuchredux obj = new fannkuchredux();
+    final long before = System.currentTimeMillis();
+    obj.timeFannkuchRedux(1100);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyFannkuchRedux()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/fannkuchredux: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fasta.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fasta.java
new file mode 100644
index 0000000..8491355
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fasta.java
@@ -0,0 +1,214 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and modified
+ * to fit the benchmarking framework.
+ * The original benchmarks printed long strings to the stdout. This print was removed to fit the
+ * framework. These action can cause difference in behaviour of the original and changed benchmarks;
+ * it hasn't been estimated yet.
+ *
+ * The original file is `fasta/fasta.java-2.java` from the archive available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause).
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * modified by Mehmet D. AKIN
+ *
+ */
+
+/*
+ * Description:     Generate and write random DNA sequences.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+// CHECKSTYLE.OFF: .*
+public class fasta {
+    public static final int IM = 139968;
+    public static final int IA = 3877;
+    public static final int IC = 29573;
+    public static int last = 42;
+
+    public static final int LINE_LENGTH = 60;
+
+    // pseudo-random number generator
+    public static final double random(double max) {
+        last = (last * IA + IC) % IM;
+        return max * last / IM;
+    }
+
+    // Weighted selection from alphabet
+    public static String ALU = 
+              "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"
+            + "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"
+            + "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"
+            + "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"
+            + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"
+            + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"
+            + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+    public static byte[] ALUB = ALU.getBytes(); 
+
+    public static final frequency[] IUB = new frequency[] {
+            new frequency('a', 0.27), 
+            new frequency('c', 0.12),
+            new frequency('g', 0.12), 
+            new frequency('t', 0.27),
+            
+            new frequency('B', 0.02), 
+            new frequency('D', 0.02),
+            new frequency('H', 0.02), 
+            new frequency('K', 0.02),
+            new frequency('M', 0.02), 
+            new frequency('N', 0.02),
+            new frequency('R', 0.02), 
+            new frequency('S', 0.02),
+            new frequency('V', 0.02), 
+            new frequency('W', 0.02),
+            new frequency('Y', 0.02) };
+
+    public static final frequency[] HomoSapiens = new frequency[] {
+            new frequency('a', 0.3029549426680d),
+            new frequency('c', 0.1979883004921d),
+            new frequency('g', 0.1975473066391d),
+            new frequency('t', 0.3015094502008d)};
+
+    public static void makeCumulative(frequency[] a) {
+        double cp = 0.0;
+        for (int i = 0; i < a.length; i++) {
+            cp += a[i].p;
+            a[i].p = cp;
+        }
+    }
+
+    // naive
+    public final static byte selectRandom(frequency[] a) {
+        int len = a.length;
+        double r = random(1.0);
+        for (int i = 0; i < len; i++)
+            if (r < a[i].p)
+                return a[i].c;
+        return a[len - 1].c;
+    }
+
+    static int BUFFER_SIZE = 1024;
+    static int index = 0;
+    static byte[] bbuffer = new byte[BUFFER_SIZE];
+    final void makeRandomFasta(String id, String desc,frequency[] a, int n)
+    {
+        index = 0;
+        int m = 0;
+        String descStr = ">" + id + " " + desc + '\n'; 
+        while (n > 0) {
+            if (n < LINE_LENGTH) m = n;  else m = LINE_LENGTH;
+            if(BUFFER_SIZE - index < m){
+                index = 0;
+            }
+            for (int i = 0; i < m; i++) {
+                bbuffer[index++] = selectRandom(a);
+            }
+            bbuffer[index++] = '\n';
+            n -= LINE_LENGTH;
+        }
+    }    
+    
+    final void makeRepeatFasta(String id, String desc, String alu, int n)
+    {
+        index = 0;
+        int m = 0;
+        int k = 0;
+        int kn = ALUB.length;
+        String descStr = ">" + id + " " + desc + '\n'; 
+        while (n > 0) {
+            if (n < LINE_LENGTH) m = n; else m = LINE_LENGTH;
+            if(BUFFER_SIZE - index < m){
+                index = 0;
+            }
+            for (int i = 0; i < m; i++) {
+                if (k == kn) k = 0;
+                bbuffer[index++] = ALUB[k];
+                k++;
+            }
+            bbuffer[index++] = '\n';
+            n -= LINE_LENGTH;
+        }
+    }
+
+    public static class frequency {
+        public byte c;
+        public double p;
+
+        public frequency(char c, double p) {
+            this.c = (byte)c;
+            this.p = p;
+        }
+    }
+
+    public void old_main() {
+        int n = 1000;
+     
+        makeRepeatFasta("ONE", "Homo sapiens alu", ALU, n * 2);
+        makeRandomFasta("TWO", "IUB ambiguity codes", IUB, n * 3);
+        makeRandomFasta("THREE", "Homo sapiens frequency", HomoSapiens, n * 5);
+    }
+    // CHECKSTYLE.ON: .*
+
+  public void timeFasta(int iters) {
+    makeCumulative(HomoSapiens);
+    makeCumulative(IUB);
+
+    for (int i = 0; i < iters; i++) {
+      old_main();
+    }
+  }
+
+  public boolean verifyFasta() {
+    index = 0;
+    int n = 25;
+    
+    makeRepeatFasta("ONE", "Homo sapiens alu", ALU, n * 2);
+    int expected = 51;
+    int found = index;
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+  
+    makeRandomFasta("THREE", "Homo sapiens frequency", HomoSapiens, n * 5);
+    expected = 128;
+    found = index;
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+
+    makeRandomFasta("TWO", "IUB ambiguity codes", IUB, n * 3);
+    expected = 77;
+    found = index;
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    fasta obj = new fasta();
+
+    final long before = System.currentTimeMillis();
+    obj.timeFasta(1700);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyFasta()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/fasta: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fastaredux.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fastaredux.java
new file mode 100644
index 0000000..187b777
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/fastaredux.java
@@ -0,0 +1,233 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and modified
+ * to fit the benchmarking framework.
+ * The original benchmarks printed long strings to the stdout. This print was overrided to do
+ * nothing to fit the framework. These action can cause difference in behaviour of the original and
+ * changed benchmarks; it hasn't been estimated yet.
+ *
+ * The original file is `fastaredux/fastaredux.java-3.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause).
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * modified by Enotus
+ *
+ */
+
+/*
+ * Description:     Generate and write random DNA sequences.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.io.*;
+
+// CHECKSTYLE.OFF: .*
+public class fastaredux {
+
+    static final int LINE_LENGTH = 60;
+    static final int OUT_BUFFER_SIZE = 256*1024;
+    static final int LOOKUP_SIZE = 4*1024;
+    static final double LOOKUP_SCALE = LOOKUP_SIZE - 1;
+
+    static final class Freq {
+        byte c;
+        double p;
+        Freq(char cc, double pp) {c = (byte) cc;p = pp;}
+    }
+
+    static final String ALU =
+            "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"
+            + "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"
+            + "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"
+            + "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"
+            + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"
+            + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"
+            + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+    static final Freq[] IUB = {
+        new Freq('a', 0.27),
+        new Freq('c', 0.12),
+        new Freq('g', 0.12),
+        new Freq('t', 0.27),
+        new Freq('B', 0.02),
+        new Freq('D', 0.02),
+        new Freq('H', 0.02),
+        new Freq('K', 0.02),
+        new Freq('M', 0.02),
+        new Freq('N', 0.02),
+        new Freq('R', 0.02),
+        new Freq('S', 0.02),
+        new Freq('V', 0.02),
+        new Freq('W', 0.02),
+        new Freq('Y', 0.02)};
+    static final Freq[] HomoSapiens = {
+        new Freq('a', 0.3029549426680),
+        new Freq('c', 0.1979883004921),
+        new Freq('g', 0.1975473066391),
+        new Freq('t', 0.3015094502008)};
+
+    static void sumAndScale(Freq[] a) {
+        double p = 0;
+        for (int i = 0; i < a.length; i++)
+            a[i].p = (p += a[i].p) * LOOKUP_SCALE;
+        a[a.length - 1].p = LOOKUP_SCALE;
+    }
+
+    static final class Random {
+    
+        static final int IM = 139968;
+        static final int IA = 3877;
+        static final int IC = 29573;
+        static final double SCALE = LOOKUP_SCALE / IM;
+        static int last = 42;
+
+        static double next() {
+            return SCALE * (last = (last * IA + IC) % IM);
+        }
+    }
+
+    static final class Out {
+    
+        static byte buf[] = new byte[OUT_BUFFER_SIZE];
+        static final int lim = OUT_BUFFER_SIZE - 2*LINE_LENGTH - 1;
+        static int ct = 0;
+        static OutputStream stream;
+
+        static void checkFlush() throws IOException {
+            if (ct >= lim) { stream.write(buf, 0, ct); ct = 0;}
+        }
+        
+        static void close() throws IOException {
+            stream.write(buf, 0, ct);ct = 0;
+            stream.close();
+        }
+    }
+    
+    static final class RandomFasta {
+
+        static final Freq[] lookup=new Freq[LOOKUP_SIZE];
+        
+        static void makeLookup(Freq[] a) {
+            for (int i = 0, j = 0; i < LOOKUP_SIZE; i++) {
+                while (a[j].p < i) j++;
+                lookup[i] = a[j];
+            }
+        }
+
+        static void addLine(int bytes) throws IOException{
+            Out.checkFlush();
+            int lct=Out.ct;
+            while(lct<Out.ct+bytes){
+                double r = Random.next();  // Problematic for AOT! See fastaredux_revised.java.
+                int ai = (int) r; while (lookup[ai].p < r) ai++;
+                Out.buf[lct++] = lookup[ai].c;
+            }
+            Out.buf[lct++] = (byte)'\n';
+            Out.ct=lct;
+        }
+
+        static void make(String desc, Freq[] a, int n) throws IOException {
+            makeLookup(a);
+
+            System.arraycopy(desc.getBytes(), 0, Out.buf, Out.ct, desc.length());
+            Out.ct+=desc.length();
+            
+            while (n > 0) {
+                int bytes = Math.min(LINE_LENGTH, n);
+                addLine(bytes);
+                n -= bytes;
+            }
+        }
+    }
+
+    static final class RepeatFasta {
+
+        static void make(String desc, byte[] alu, int n) throws IOException {
+            System.arraycopy(desc.getBytes(), 0, Out.buf, Out.ct, desc.length());
+            Out.ct+=desc.length();
+
+            byte buf[] = new byte[alu.length + LINE_LENGTH];
+            for (int i = 0; i < buf.length; i += alu.length)
+                System.arraycopy(alu, 0, buf, i, Math.min(alu.length, buf.length - i));
+
+            int pos = 0;
+            while (n > 0) {
+                int bytes = Math.min(LINE_LENGTH, n);
+                Out.checkFlush();
+                System.arraycopy(buf, pos, Out.buf, Out.ct, bytes); Out.ct+=bytes;
+                Out.buf[Out.ct++] = (byte)'\n';
+                pos = (pos + bytes) % alu.length;
+                n -= bytes;
+            }
+        }
+    }
+
+    private void old_main() throws IOException {
+        int n = 1000;
+
+        RepeatFasta.make(">ONE Homo sapiens alu\n", ALU.getBytes(), n * 2);
+        RandomFasta.make(">TWO IUB ambiguity codes\n", IUB, n * 3);
+        RandomFasta.make(">THREE Homo sapiens frequency\n", HomoSapiens, n * 5);
+    }
+    // CHECKSTYLE.ON: .*
+
+  /** Writes to nowhere */
+  public class NullOutputStream extends OutputStream {
+    @Override
+    public void write(int b) throws IOException {
+    }
+  }
+
+  public void timeFastaRedux(int iters) throws IOException {
+    sumAndScale(IUB);
+    sumAndScale(HomoSapiens);
+
+    Out.stream = new NullOutputStream();
+
+    for (int i = 0; i < iters; i++) {
+      old_main();
+    }
+  }
+
+  static final int VERIFY_MAGIC_NUMBER = 25;
+
+  public boolean verifyFastaRedux() throws IOException {
+    int n = VERIFY_MAGIC_NUMBER;
+    Out.buf = new byte[OUT_BUFFER_SIZE];
+    sumAndScale(IUB);
+    sumAndScale(HomoSapiens);
+
+    RepeatFasta.make(">ONE Homo sapiens alu\n", ALU.getBytes(), n * 2);
+    RandomFasta.make(">TWO IUB ambiguity codes\n", IUB, n * 3);
+    RandomFasta.make(">THREE Homo sapiens frequency\n", HomoSapiens, n * 5);
+
+    int expected = 0;
+    int found = Out.buf[VERIFY_MAGIC_NUMBER - 1];
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+
+    return true;
+  }
+
+  public static void main(String[] args) throws IOException {
+    int rc = 0;
+    fastaredux obj = new fastaredux();
+
+    final long before = System.currentTimeMillis();
+    obj.timeFastaRedux(1700);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyFastaRedux()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/fastaredux: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/knucleotide.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/knucleotide.java
new file mode 100644
index 0000000..40f5f13
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/knucleotide.java
@@ -0,0 +1,1336 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `knucleotide/knucleotide.java-4.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause).
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Daryl Griffith
+ */
+
+/*
+ * Description:     Hashtable update and k-nucleotide strings.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.io.ByteArrayInputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+// CHECKSTYLE.OFF: .*
+public class knucleotide {
+
+  private byte[] temp = null;
+  private byte[] buffer = null;
+  private byte[] species = null;
+  private ByteArrayInputStream stream = null;
+  private LineInputStream in;
+
+    static Map<Key, Value> MAP;
+    static final int[] SEQUENCES1 = {2, 1};
+    static final int[] SEQUENCES2 = {18, 12, 6, 4, 3};
+    static final String[] SPICIFIC_SEQUENCES = new String[]{"GGT", "GGTA", "GGTATT", "GGTATTTTAATT", "GGTATTTTAATTTATAGT"};
+    static final int LINE_LENGTH = 60;
+    static final int EOF = -1;
+    static byte[] nucleotides;
+
+    public void old_main() {
+        {
+            int n;
+            int i;
+
+            try {
+outer:
+                for (;;) {
+                    n = in.readLine(temp);
+                    if (n == EOF) {
+                        return;
+                    }
+                    if (n != LINE_LENGTH) {
+                        for (i = 0; i < species.length; i++) {
+                            if (temp[i] != species[i]) {
+                                continue outer;
+                            }
+                        }
+                        break;
+                    }
+                }
+                i = 0;
+                for (;;) {
+                    n = in.readLine(temp);
+                    if (n == EOF) {
+                        break;
+                    }
+                    for (int j = 0; j < n; i++, j++) {
+                        buffer[i] = translate(temp[j]);
+                    }
+                }
+                if (i == buffer.length) {
+                    nucleotides = buffer;
+                } else {
+                    nucleotides = new byte[i];
+                    System.arraycopy(buffer, 0, nucleotides, 0, i);
+                }
+            } catch (IOException e) {
+
+            }
+        }
+        countSequences(SEQUENCES1);
+        {
+            List<Entry<Key, Value>> sequence1 = new ArrayList<>();
+            List<Entry<Key, Value>> sequence2 = new ArrayList<>();
+
+            for (Entry<Key, Value> entry : MAP.entrySet()) {
+                switch (Long.numberOfLeadingZeros(entry.getKey().key)) {
+                    case 61:
+                        sequence1.add(entry);
+                        break;
+                    case 59:
+                        sequence2.add(entry);
+                }
+            }
+            printSequence(sequence1);
+            printSequence(sequence2);
+        }
+        countSequences(SEQUENCES2);
+        {
+            Key key = new Key();
+        }
+    }
+        
+    static byte translate(byte b) {
+        return (byte) ((b >> 1) & 3);
+    }
+
+    static void countSequences(int[] sequences) {
+        for (int sequence : sequences) {
+            updateHashtable(sequence);
+        }
+    }
+
+    static void updateHashtable(int sequence) {
+        int sequenceTop = nucleotides.length - sequence + 1;
+        Key key = new Key();
+        Value value;
+        
+        for (int i = 0; i < sequenceTop; i++) {
+            key.setHash(i, sequence);
+            value = MAP.get(key);
+            if (value == null) {
+                value = new Value();
+                value.count = 1;
+                MAP.put(key, value);
+                key = new Key();
+            } else {
+                value.count++;
+            }
+        }
+    }
+
+    static void printSequence(List<Entry<Key, Value>> sequence) {
+        int sum = 0;
+
+        Collections.sort(sequence, new Comparator<Entry<Key, Value>>() {
+
+            @Override
+            public int compare(Entry<Key, Value> entry1, Entry<Key, Value> entry2) {
+                if (entry2.getValue().count != entry1.getValue().count) {
+                    return entry2.getValue().count - entry1.getValue().count;
+                }
+                return entry1.getKey().toString().compareTo(entry2.getKey().toString());
+            }
+        });
+        for (Entry<Key, Value> entry : sequence) {
+            sum += entry.getValue().count;
+        }
+    }
+
+    static class LineInputStream implements Closeable {
+
+        private static final int LF = 10;
+        private final ByteBuffer buffer = ByteBuffer.allocate(8192);
+        private final InputStream in;
+
+        public LineInputStream(InputStream in) {
+            this.in = in;
+            buffer.limit(buffer.position());
+        }
+
+        public int readLine(byte[] b) throws IOException {
+            for (int end = buffer.position(); end < buffer.limit(); end++) {
+                if (buffer.get(end) == LF) {
+                    if (end - buffer.position() == LINE_LENGTH) {
+                        buffer.get(b);
+                        buffer.position(buffer.position() + 1);
+                        return LINE_LENGTH;
+                    } else {
+                        int size = end - buffer.position();
+
+                        buffer.get(b, 0, size);
+                        buffer.position(buffer.position() + 1);
+                        return size;
+                    }
+                }
+            }
+            buffer.compact();
+            int n = in.read(buffer.array(), buffer.position(), buffer.remaining());
+
+            if (n == EOF) {
+                buffer.flip();
+                if (buffer.hasRemaining()) {
+                    int size = buffer.remaining();
+
+                    buffer.get(b, 0, size);
+                    return size;
+                } else {
+                    return EOF;
+                }
+            } else {
+                buffer.position(buffer.position() + n);
+                buffer.flip();
+            }
+            for (int end = buffer.position(); end < buffer.limit(); end++) {
+                if (buffer.get(end) == LF) {
+                    if (end - buffer.position() == LINE_LENGTH) {
+                        buffer.get(b);
+                        buffer.position(buffer.position() + 1);
+                        return LINE_LENGTH;
+                    } else {
+                        int size = end - buffer.position();
+
+                        buffer.get(b, 0, size);
+                        buffer.position(buffer.position() + 1);
+                        return size;
+                    }
+                }
+            }
+            return EOF;
+        }
+
+        @Override
+        public void close() throws IOException {
+            in.close();
+        }
+    }
+
+    static class Key {
+
+        long key;
+
+        void setHash(int offset, int length) {
+            key = 1;
+            for (int i = offset + length - 1; i >= offset; i--) {
+                key = (key << 2) | nucleotides[i];
+            }
+        }
+
+        void setHash(String species) {
+            key = 1;
+            for (int i = species.length() - 1; i >= 0; i--) {
+                key = (key << 2) | translate((byte) species.charAt(i));
+            }
+        }
+
+        @Override
+        public int hashCode() {
+            return (int) key;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            final Key other = (Key) obj;
+
+            return key == other.key;
+        }
+
+        @Override
+        public String toString() {
+            char[] name = new char[(63 - Long.numberOfLeadingZeros(key)) / 2];
+            long temp = key;
+
+            for (int i = 0; temp > 1; temp >>= 2, i++) {
+                name[i] = (char) (((temp & 3) << 1) | 'A');
+                if (name[i] == 'E') {
+                    name[i] = 'T';
+                }
+            }
+            return new String(name);
+        }
+    }
+
+    static class Value {
+
+        int count;
+    }
+    // CHECKSTYLE.ON: .*
+
+  public void reinitBuffers() {
+    MAP = new HashMap<>();
+    species = ">TH".getBytes();
+  }
+
+  public knucleotide() {
+    temp = new byte[LINE_LENGTH];
+    buffer = new byte[125_000_000];
+    stream = new ByteArrayInputStream(fastaStr.getBytes());
+    in = new LineInputStream(stream);
+  }
+
+  public void timeKnucleotide(int iters) {
+    for (int count = 0; count < iters; count++) {
+      reinitBuffers();
+      old_main();
+      stream.reset();
+    }
+  }
+
+  public boolean verifyKnucleotide() {
+    Key key = new Key();
+    key.setHash(SPICIFIC_SEQUENCES[2]);
+
+    int expected = 12;
+    int found = MAP.get(key).count;
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    knucleotide obj = new knucleotide();
+
+    final long before = System.currentTimeMillis();
+    obj.timeKnucleotide(9);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyKnucleotide()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/knucleotide: " + (after - before));
+    System.exit(rc);
+  }
+
+  private static final String fastaStr = ">ONE Homo sapiens alu\n"
+      + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\n"
+      + "TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\n"
+      + "AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\n"
+      + "GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\n"
+      + "CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\n"
+      + "GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\n"
+      + "GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\n"
+      + "TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\n"
+      + "AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\n"
+      + "GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT\n"
+      + "AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC\n"
+      + "AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG\n"
+      + "GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC\n"
+      + "CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG\n"
+      + "AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT\n"
+      + "TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA\n"
+      + "TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT\n"
+      + "GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG\n"
+      + "TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT\n"
+      + "CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG\n"
+      + "CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG\n"
+      + "TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA\n"
+      + "CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG\n"
+      + "AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG\n"
+      + "GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC\n"
+      + "TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA\n"
+      + "TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA\n"
+      + "GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT\n"
+      + "GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC\n"
+      + "ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT\n"
+      + "TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC\n"
+      + "CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG\n"
+      + "CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG\n"
+      + "GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC\n"
+      + "CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT\n"
+      + "GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC\n"
+      + "GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA\n"
+      + "GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA\n"
+      + "GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA\n"
+      + "GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG\n"
+      + "AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT\n"
+      + "CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA\n"
+      + "GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA\n"
+      + "AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC\n"
+      + "GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT\n"
+      + "ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG\n"
+      + "GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC\n"
+      + "GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC\n"
+      + "GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\n"
+      + "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA\n"
+      + "AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG\n"
+      + "GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT\n"
+      + "CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC\n"
+      + "TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG\n"
+      + "ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC\n"
+      + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA\n"
+      + "ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA\n"
+      + "CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA\n"
+      + "CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA\n"
+      + "ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG\n"
+      + "CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG\n"
+      + "AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC\n"
+      + "CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG\n"
+      + "AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC\n"
+      + "CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG\n"
+      + "CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG\n"
+      + "CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG\n"
+      + "CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC\n"
+      + "ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA\n"
+      + "AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC\n"
+      + "TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC\n"
+      + "ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG\n"
+      + "CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG\n"
+      + "AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT\n"
+      + "AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA\n"
+      + "TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC\n"
+      + "CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA\n"
+      + "TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG\n"
+      + "CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT\n"
+      + "GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG\n"
+      + "GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG\n"
+      + "CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\n"
+      + "GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG\n"
+      + "GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT\n"
+      + "AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT\n"
+      + "GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT\n"
+      + "CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG\n"
+      + "GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC\n"
+      + "TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT\n"
+      + "CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG\n"
+      + "ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG\n"
+      + "CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG\n"
+      + "AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA\n"
+      + "CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG\n"
+      + "CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC\n"
+      + "ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC\n"
+      + "GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC\n"
+      + "GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG\n"
+      + "GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT\n"
+      + "TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG\n"
+      + "CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA\n"
+      + "GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG\n"
+      + "CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC\n"
+      + "GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG\n"
+      + "CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA\n"
+      + "CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG\n"
+      + "CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA\n"
+      + "ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC\n"
+      + "CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT\n"
+      + "GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA\n"
+      + "AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG\n"
+      + "ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC\n"
+      + "TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA\n"
+      + "GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC\n"
+      + "GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG\n"
+      + "TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC\n"
+      + "AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA\n"
+      + "ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA\n"
+      + "GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\n"
+      + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG\n"
+      + "TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC\n"
+      + "CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT\n"
+      + "GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC\n"
+      + "CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA\n"
+      + "GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT\n"
+      + "TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC\n"
+      + "ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC\n"
+      + "TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG\n"
+      + "GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG\n"
+      + "TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG\n"
+      + "GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC\n"
+      + "GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT\n"
+      + "ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC\n"
+      + "GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC\n"
+      + "GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC\n"
+      + "CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA\n"
+      + "ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG\n"
+      + "AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC\n"
+      + "TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT\n"
+      + "CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG\n"
+      + "TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG\n"
+      + "CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC\n"
+      + "GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT\n"
+      + "GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC\n"
+      + "CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC\n"
+      + "TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG\n"
+      + "CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\n"
+      + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG\n"
+      + "AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG\n"
+      + "AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT\n"
+      + "GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA\n"
+      + "TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC\n"
+      + "AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA\n"
+      + "AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG\n"
+      + "CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC\n"
+      + "TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG\n"
+      + "GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT\n"
+      + "CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG\n"
+      + "CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG\n"
+      + "GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA\n"
+      + "AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA\n"
+      + "GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC\n"
+      + "TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC\n"
+      + "CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA\n"
+      + "GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\n"
+      + "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG\n"
+      + "AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG\n"
+      + "ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC\n"
+      + "ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC\n"
+      + "AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC\n"
+      + "GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG\n"
+      + "GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT\n"
+      + "CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC\n"
+      + "GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC\n"
+      + "CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\n"
+      + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA\n"
+      + "GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG\n"
+      + "GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT\n"
+      + "CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA\n"
+      + "AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG\n"
+      + "CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC\n"
+      + "CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG\n"
+      + "GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG\n"
+      + "GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT\n"
+      + "TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA\n"
+      + "ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG\n"
+      + "CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA\n"
+      + "ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA\n"
+      + "GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG\n"
+      + "TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC\n"
+      + "GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA\n"
+      + "GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT\n"
+      + "GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT\n"
+      + "GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG\n"
+      + "TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT\n"
+      + "TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC\n"
+      + "TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC\n"
+      + "GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT\n"
+      + "CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC\n"
+      + "TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA\n"
+      + ">TWO IUB ambiguity codes\n"
+      + "cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg\n"
+      + "tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa\n"
+      + "NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt\n"
+      + "cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga\n"
+      + "gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa\n"
+      + "HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca\n"
+      + "tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt\n"
+      + "tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt\n"
+      + "acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct\n"
+      + "tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt\n"
+      + "gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa\n"
+      + "accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt\n"
+      + "RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt\n"
+      + "tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag\n"
+      + "cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg\n"
+      + "ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat\n"
+      + "actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg\n"
+      + "YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa\n"
+      + "KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata\n"
+      + "aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa\n"
+      + "aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg\n"
+      + "gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc\n"
+      + "tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK\n"
+      + "tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt\n"
+      + "ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg\n"
+      + "ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa\n"
+      + "BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt\n"
+      + "aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc\n"
+      + "tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc\n"
+      + "cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac\n"
+      + "aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga\n"
+      + "tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga\n"
+      + "aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD\n"
+      + "gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg\n"
+      + "ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV\n"
+      + "taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa\n"
+      + "ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat\n"
+      + "gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg\n"
+      + "gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa\n"
+      + "tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt\n"
+      + "tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt\n"
+      + "taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca\n"
+      + "cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag\n"
+      + "aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt\n"
+      + "cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt\n"
+      + "ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW\n"
+      + "attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag\n"
+      + "ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa\n"
+      + "attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc\n"
+      + "tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta\n"
+      + "aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata\n"
+      + "cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc\n"
+      + "gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg\n"
+      + "attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca\n"
+      + "BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga\n"
+      + "DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat\n"
+      + "tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM\n"
+      + "tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR\n"
+      + "tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg\n"
+      + "taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc\n"
+      + "aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc\n"
+      + "DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa\n"
+      + "VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt\n"
+      + "agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat\n"
+      + "gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt\n"
+      + "tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt\n"
+      + "catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt\n"
+      + "tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR\n"
+      + "aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat\n"
+      + "aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac\n"
+      + "acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS\n"
+      + "tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga\n"
+      + "aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM\n"
+      + "acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt\n"
+      + "RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt\n"
+      + "RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta\n"
+      + "tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac\n"
+      + "gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt\n"
+      + "YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc\n"
+      + "ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt\n"
+      + "ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat\n"
+      + "gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta\n"
+      + "KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD\n"
+      + "aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg\n"
+      + "gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH\n"
+      + "taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact\n"
+      + "VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV\n"
+      + "NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa\n"
+      + "MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag\n"
+      + "cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata\n"
+      + "ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg\n"
+      + "tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN\n"
+      + "aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc\n"
+      + "actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg\n"
+      + "tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga\n"
+      + "gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa\n"
+      + "BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca\n"
+      + "aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata\n"
+      + "aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat\n"
+      + "YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt\n"
+      + "aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW\n"
+      + "cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata\n"
+      + "tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata\n"
+      + "tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt\n"
+      + "MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac\n"
+      + "taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta\n"
+      + "tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS\n"
+      + "RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc\n"
+      + "agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata\n"
+      + "NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa\n"
+      + "gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata\n"
+      + "aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt\n"
+      + "ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW\n"
+      + "cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt\n"
+      + "tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa\n"
+      + "RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt\n"
+      + "tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD\n"
+      + "gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc\n"
+      + "tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta\n"
+      + "ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM\n"
+      + "tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc\n"
+      + "ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc\n"
+      + "BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt\n"
+      + "gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga\n"
+      + "acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag\n"
+      + "gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc\n"
+      + "taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat\n"
+      + "acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta\n"
+      + "tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt\n"
+      + "catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa\n"
+      + "tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB\n"
+      + "atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR\n"
+      + "ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta\n"
+      + "ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta\n"
+      + "cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK\n"
+      + "SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW\n"
+      + "VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc\n"
+      + "BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct\n"
+      + "NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt\n"
+      + "tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa\n"
+      + "ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa\n"
+      + "cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa\n"
+      + "VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR\n"
+      + "atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac\n"
+      + "aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc\n"
+      + "tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac\n"
+      + "RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag\n"
+      + "gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc\n"
+      + "tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact\n"
+      + "attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc\n"
+      + "atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga\n"
+      + "cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt\n"
+      + "NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR\n"
+      + "ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat\n"
+      + "cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg\n"
+      + "aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac\n"
+      + "agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR\n"
+      + "tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga\n"
+      + "ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg\n"
+      + "ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa\n"
+      + "tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag\n"
+      + "taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg\n"
+      + "tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN\n"
+      + "YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt\n"
+      + "ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa\n"
+      + "tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat\n"
+      + "ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg\n"
+      + "attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt\n"
+      + "atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW\n"
+      + "YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta\n"
+      + "gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV\n"
+      + "MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta\n"
+      + "tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt\n"
+      + "ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa\n"
+      + "aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa\n"
+      + "BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM\n"
+      + "tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK\n"
+      + "StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV\n"
+      + "cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN\n"
+      + "atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg\n"
+      + "atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg\n"
+      + "ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct\n"
+      + "gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM\n"
+      + "tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD\n"
+      + "BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc\n"
+      + "agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga\n"
+      + "HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR\n"
+      + "tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt\n"
+      + "aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa\n"
+      + "catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB\n"
+      + "aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat\n"
+      + "tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt\n"
+      + "cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag\n"
+      + "DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat\n"
+      + "gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta\n"
+      + "tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM\n"
+      + "atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc\n"
+      + "KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt\n"
+      + "tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata\n"
+      + "tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK\n"
+      + "taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt\n"
+      + "NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa\n"
+      + "HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa\n"
+      + "ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg\n"
+      + "tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK\n"
+      + "cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga\n"
+      + "ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca\n"
+      + "HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg\n"
+      + "gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS\n"
+      + "BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg\n"
+      + "gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat\n"
+      + "KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact\n"
+      + "cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat\n"
+      + "tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD\n"
+      + "taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM\n"
+      + "gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt\n"
+      + "aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat\n"
+      + "acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta\n"
+      + "RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc\n"
+      + "attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac\n"
+      + "KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS\n"
+      + "KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD\n"
+      + "gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB\n"
+      + "aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct\n"
+      + "aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga\n"
+      + "ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY\n"
+      + "tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga\n"
+      + "aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta\n"
+      + "tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY\n"
+      + "MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc\n"
+      + "cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta\n"
+      + "caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt\n"
+      + "ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc\n"
+      + "acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat\n"
+      + "tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc\n"
+      + "gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa\n"
+      + "atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga\n"
+      + "aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat\n"
+      + "NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt\n"
+      + "taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa\n"
+      + "aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat\n"
+      + "ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca\n"
+      + "DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata\n"
+      + "tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat\n"
+      + "aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa\n"
+      + "ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM\n"
+      + "ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca\n"
+      + "RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa\n"
+      + "aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac\n"
+      + "aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt\n"
+      + "aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK\n"
+      + "tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat\n"
+      + "atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR\n"
+      + "BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc\n"
+      + "gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct\n"
+      + "cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN\n"
+      + "RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat\n"
+      + "taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt\n"
+      + "aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt\n"
+      + "gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct\n"
+      + "gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa\n"
+      + "aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta\n"
+      + "gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg\n"
+      + "ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat\n"
+      + "MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct\n"
+      + "SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY\n"
+      + "aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt\n"
+      + "VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat\n"
+      + "HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc\n"
+      + "agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt\n"
+      + "gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg\n"
+      + "agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg\n"
+      + "tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag\n"
+      + "gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga\n"
+      + "VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg\n"
+      + "tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV\n"
+      + "MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt\n"
+      + "actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa\n"
+      + "WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa\n"
+      + "tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD\n"
+      + "KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct\n"
+      + "BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac\n"
+      + "attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB\n"
+      + "VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD\n"
+      + "aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca\n"
+      + "tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat\n"
+      + "tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK\n"
+      + "tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt\n"
+      + "VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta\n"
+      + "tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat\n"
+      + "ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa\n"
+      + "tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg\n"
+      + "WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta\n"
+      + "tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc\n"
+      + "tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct\n"
+      + "MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat\n"
+      + "tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac\n"
+      + "atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg\n"
+      + "aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt\n"
+      + "aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa\n"
+      + ">THREE Homo sapiens frequency\n"
+      + "aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca\n"
+      + "tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg\n"
+      + "tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg\n"
+      + "gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc\n"
+      + "atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc\n"
+      + "cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt\n"
+      + "caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat\n"
+      + "tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt\n"
+      + "agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt\n"
+      + "ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt\n"
+      + "aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta\n"
+      + "ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat\n"
+      + "cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac\n"
+      + "gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa\n"
+      + "atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc\n"
+      + "ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta\n"
+      + "gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt\n"
+      + "aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt\n"
+      + "aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc\n"
+      + "atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac\n"
+      + "tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat\n"
+      + "cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc\n"
+      + "taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt\n"
+      + "taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt\n"
+      + "ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc\n"
+      + "acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct\n"
+      + "cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg\n"
+      + "tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt\n"
+      + "attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat\n"
+      + "cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga\n"
+      + "atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc\n"
+      + "accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag\n"
+      + "tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc\n"
+      + "acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag\n"
+      + "ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa\n"
+      + "gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc\n"
+      + "cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg\n"
+      + "aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca\n"
+      + "tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta\n"
+      + "atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac\n"
+      + "ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc\n"
+      + "gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat\n"
+      + "ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt\n"
+      + "gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata\n"
+      + "gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc\n"
+      + "atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga\n"
+      + "agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct\n"
+      + "aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac\n"
+      + "ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc\n"
+      + "tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa\n"
+      + "cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc\n"
+      + "gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga\n"
+      + "atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta\n"
+      + "ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca\n"
+      + "gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt\n"
+      + "acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga\n"
+      + "tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg\n"
+      + "ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc\n"
+      + "ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt\n"
+      + "acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat\n"
+      + "tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag\n"
+      + "tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga\n"
+      + "tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca\n"
+      + "aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg\n"
+      + "aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg\n"
+      + "actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt\n"
+      + "tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa\n"
+      + "gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag\n"
+      + "tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc\n"
+      + "attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt\n"
+      + "gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc\n"
+      + "atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact\n"
+      + "ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta\n"
+      + "aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt\n"
+      + "gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta\n"
+      + "taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga\n"
+      + "tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc\n"
+      + "gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca\n"
+      + "cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga\n"
+      + "ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac\n"
+      + "agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat\n"
+      + "aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt\n"
+      + "atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac\n"
+      + "actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa\n"
+      + "tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa\n"
+      + "ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta\n"
+      + "cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag\n"
+      + "ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc\n"
+      + "ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag\n"
+      + "cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag\n"
+      + "tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc\n"
+      + "agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat\n"
+      + "gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc\n"
+      + "gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca\n"
+      + "ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct\n"
+      + "acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga\n"
+      + "tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat\n"
+      + "tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg\n"
+      + "cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac\n"
+      + "cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata\n"
+      + "agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca\n"
+      + "aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg\n"
+      + "gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta\n"
+      + "atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg\n"
+      + "ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag\n"
+      + "acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta\n"
+      + "ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg\n"
+      + "gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc\n"
+      + "atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg\n"
+      + "actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg\n"
+      + "cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt\n"
+      + "cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa\n"
+      + "ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca\n"
+      + "tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta\n"
+      + "atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc\n"
+      + "acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct\n"
+      + "gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta\n"
+      + "ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc\n"
+      + "aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga\n"
+      + "taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa\n"
+      + "cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca\n"
+      + "tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta\n"
+      + "gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg\n"
+      + "gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag\n"
+      + "ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat\n"
+      + "tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta\n"
+      + "aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt\n"
+      + "aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc\n"
+      + "cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca\n"
+      + "acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta\n"
+      + "aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct\n"
+      + "cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa\n"
+      + "tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt\n"
+      + "cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat\n"
+      + "tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt\n"
+      + "taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg\n"
+      + "ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt\n"
+      + "taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc\n"
+      + "accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa\n"
+      + "ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg\n"
+      + "atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg\n"
+      + "taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga\n"
+      + "aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt\n"
+      + "attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt\n"
+      + "atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa\n"
+      + "attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa\n"
+      + "cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg\n"
+      + "agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt\n"
+      + "tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca\n"
+      + "aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa\n"
+      + "actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag\n"
+      + "tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta\n"
+      + "acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg\n"
+      + "tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat\n"
+      + "agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag\n"
+      + "ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat\n"
+      + "tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt\n"
+      + "attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta\n"
+      + "tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt\n"
+      + "ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt\n"
+      + "catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga\n"
+      + "caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc\n"
+      + "cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac\n"
+      + "accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca\n"
+      + "atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct\n"
+      + "tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct\n"
+      + "cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat\n"
+      + "gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca\n"
+      + "gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga\n"
+      + "agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca\n"
+      + "ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc\n"
+      + "ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa\n"
+      + "aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc\n"
+      + "ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga\n"
+      + "tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt\n"
+      + "taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg\n"
+      + "caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt\n"
+      + "tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc\n"
+      + "taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac\n"
+      + "gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca\n"
+      + "gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat\n"
+      + "aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt\n"
+      + "atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc\n"
+      + "gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat\n"
+      + "aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa\n"
+      + "aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga\n"
+      + "aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat\n"
+      + "ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc\n"
+      + "gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa\n"
+      + "acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac\n"
+      + "attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc\n"
+      + "gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag\n"
+      + "gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct\n"
+      + "gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata\n"
+      + "tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat\n"
+      + "ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata\n"
+      + "aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc\n"
+      + "tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat\n"
+      + "tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa\n"
+      + "ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt\n"
+      + "agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct\n"
+      + "cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt\n"
+      + "tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat\n"
+      + "tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc\n"
+      + "gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc\n"
+      + "tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg\n"
+      + "tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat\n"
+      + "atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag\n"
+      + "cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa\n"
+      + "ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt\n"
+      + "ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat\n"
+      + "atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc\n"
+      + "gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact\n"
+      + "tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag\n"
+      + "gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg\n"
+      + "atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag\n"
+      + "tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac\n"
+      + "ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag\n"
+      + "tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta\n"
+      + "aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt\n"
+      + "gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa\n"
+      + "ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc\n"
+      + "agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt\n"
+      + "agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat\n"
+      + "acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc\n"
+      + "cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct\n"
+      + "cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct\n"
+      + "cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa\n"
+      + "aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt\n"
+      + "tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt\n"
+      + "atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct\n"
+      + "cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga\n"
+      + "tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat\n"
+      + "catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc\n"
+      + "tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg\n"
+      + "caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc\n"
+      + "tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc\n"
+      + "aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag\n"
+      + "aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat\n"
+      + "ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac\n"
+      + "gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag\n"
+      + "ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt\n"
+      + "cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta\n"
+      + "gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca\n"
+      + "ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt\n"
+      + "cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg\n"
+      + "taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg\n"
+      + "gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc\n"
+      + "taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt\n"
+      + "ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt\n"
+      + "aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt\n"
+      + "gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta\n"
+      + "acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct\n"
+      + "ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta\n"
+      + "tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt\n"
+      + "tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg\n"
+      + "tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa\n"
+      + "ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac\n"
+      + "aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga\n"
+      + "tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca\n"
+      + "gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt\n"
+      + "gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc\n"
+      + "cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg\n"
+      + "actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa\n"
+      + "tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg\n"
+      + "ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt\n"
+      + "ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta\n"
+      + "agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc\n"
+      + "gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa\n"
+      + "tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt\n"
+      + "atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca\n"
+      + "cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa\n"
+      + "tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca\n"
+      + "gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg\n"
+      + "gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat\n"
+      + "aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg\n"
+      + "gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat\n"
+      + "cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa\n"
+      + "taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg\n"
+      + "tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt\n"
+      + "ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac\n"
+      + "aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc\n"
+      + "gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag\n"
+      + "aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc\n"
+      + "tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa\n"
+      + "tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata\n"
+      + "aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta\n"
+      + "ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc\n"
+      + "ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc\n"
+      + "caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct\n"
+      + "gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg\n"
+      + "cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc\n"
+      + "ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta\n"
+      + "tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg\n"
+      + "atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc\n"
+      + "ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc\n"
+      + "acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc\n"
+      + "taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga\n"
+      + "ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga\n"
+      + "aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat\n"
+      + "cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc\n"
+      + "tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact\n"
+      + "gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa\n"
+      + "aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag\n"
+      + "cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc\n"
+      + "cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa\n"
+      + "gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg\n"
+      + "cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg\n"
+      + "gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca\n"
+      + "agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac\n"
+      + "aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt\n"
+      + "aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg\n"
+      + "cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt\n"
+      + "agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg\n"
+      + "cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa\n"
+      + "agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga\n"
+      + "gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta\n"
+      + "aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata\n"
+      + "agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc\n"
+      + "cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc\n"
+      + "agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca\n"
+      + "ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga\n"
+      + "tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag\n"
+      + "gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat\n"
+      + "gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt\n"
+      + "ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg\n"
+      + "gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc\n"
+      + "atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc\n"
+      + "tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata\n"
+      + "ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg\n"
+      + "tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag\n"
+      + "cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg\n"
+      + "ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat\n"
+      + "aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg\n"
+      + "gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat\n"
+      + "ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag\n"
+      + "atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac\n"
+      + "aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct\n"
+      + "gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga\n"
+      + "atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt\n"
+      + "aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt\n"
+      + "tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg\n"
+      + "ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta\n"
+      + "gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac\n"
+      + "cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct\n"
+      + "ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga\n"
+      + "ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg\n"
+      + "ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat\n"
+      + "cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga\n"
+      + "tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt\n"
+      + "tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc\n"
+      + "cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt\n"
+      + "gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct\n"
+      + "ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt\n"
+      + "ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa\n"
+      + "tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc\n"
+      + "agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta\n"
+      + "ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc\n"
+      + "cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct\n"
+      + "agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc\n"
+      + "tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc\n"
+      + "gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga\n"
+      + "ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa\n"
+      + "ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca\n"
+      + "agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata\n"
+      + "attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact\n"
+      + "ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat\n"
+      + "agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat\n"
+      + "aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata\n"
+      + "gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta\n"
+      + "gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg\n"
+      + "ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac\n"
+      + "gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata\n"
+      + "ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat\n"
+      + "taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta\n"
+      + "aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata\n"
+      + "tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata\n"
+      + "ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga\n"
+      + "agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt\n"
+      + "ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt\n"
+      + "agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg\n"
+      + "gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa\n"
+      + "tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg\n"
+      + "gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct\n"
+      + "cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc\n"
+      + "ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta\n"
+      + "cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt\n"
+      + "gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc\n"
+      + "gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc\n"
+      + "tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt\n"
+      + "cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca\n"
+      + "aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac\n"
+      + "ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac\n"
+      + "gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag\n"
+      + "aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga\n"
+      + "gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct\n"
+      + "aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta\n"
+      + "gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat\n"
+      + "agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat\n"
+      + "caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta\n"
+      + "gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta\n"
+      + "aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt\n"
+      + "tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt\n"
+      + "tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc\n"
+      + "ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg\n"
+      + "ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg\n"
+      + "gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa\n"
+      + "ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa\n"
+      + "aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa\n"
+      + "tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat\n"
+      + "acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac\n"
+      + "atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga\n"
+      + "gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac\n"
+      + "tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc\n"
+      + "cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa\n"
+      + "gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg\n"
+      + "acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga\n"
+      + "acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga\n"
+      + "attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg\n"
+      + "tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt\n"
+      + "cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag\n"
+      + "aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac\n"
+      + "ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac\n"
+      + "tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat\n"
+      + "gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga\n"
+      + "gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc\n"
+      + "acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta\n"
+      + "gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac\n"
+      + "gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc\n"
+      + "ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt\n"
+      + "taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg\n"
+      + "agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa\n"
+      + "gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag\n"
+      + "ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc\n"
+      + "accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag\n"
+      + "tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact\n"
+      + "taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga\n"
+      + "catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat\n"
+      + "tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga\n"
+      + "ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg\n"
+      + "aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa\n"
+      + "atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa\n"
+      + "tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt\n"
+      + "ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact\n"
+      + "tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt\n"
+      + "aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat\n"
+      + "agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc\n"
+      + "acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc\n"
+      + "aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct\n"
+      + "ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat\n"
+      + "gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat\n"
+      + "taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata\n"
+      + "taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga\n"
+      + "tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat\n"
+      + "gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg\n"
+      + "ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa\n"
+      + "atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat\n"
+      + "tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat\n"
+      + "cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt\n"
+      + "aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac\n"
+      + "taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag\n"
+      + "caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata\n"
+      + "ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct\n"
+      + "tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac\n"
+      + "tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg\n"
+      + "gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta\n"
+      + "gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat\n"
+      + "gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg\n"
+      + "ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa\n"
+      + "tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa\n"
+      + "taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac\n"
+      + "gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt\n"
+      + "ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga\n"
+      + "gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca\n"
+      + "tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc\n"
+      + "ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt\n"
+      + "tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc\n"
+      + "cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat\n"
+      + "ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg\n"
+      + "caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg\n"
+      + "cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat\n"
+      + "gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat\n"
+      + "cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg\n"
+      + "taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat\n"
+      + "tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata\n"
+      + "taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc\n"
+      + "tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac\n"
+      + "tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt\n"
+      + "tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt\n"
+      + "ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt\n"
+      + "aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg\n"
+      + "atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga\n"
+      + "actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta\n"
+      + "gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga\n"
+      + "ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga\n"
+      + "gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct\n"
+      + "tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc\n"
+      + "aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta\n"
+      + "atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt\n"
+      + "catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc";
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/mandelbrot.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/mandelbrot.java
new file mode 100644
index 0000000..5d2bd35
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/mandelbrot.java
@@ -0,0 +1,126 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `mandelbrot/mandelbrot.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Stefan Krause
+ * slightly modified by Chad Whipkey
+ */
+
+/*
+ * Description:     Generate Mandelbrot set portable bitmap file.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.lang.System;
+
+// CHECKSTYLE.OFF: .*
+public class mandelbrot {
+  private static final int PREDEFINED_SIZE = 200;
+
+       private static final int BUFFER_SIZE = 8192;
+
+       public mandelbrot() {
+         this.size = PREDEFINED_SIZE;
+         fac = 2.0 / size;
+         shift = size % 8 == 0 ? 0 : (8- size % 8);
+      }
+      final int size;
+      final byte [] buf = new byte[BUFFER_SIZE];
+      int bufLen = 0;
+      final double fac;
+      final int shift;
+
+      public void compute()
+      {
+         for (int y = 0; y<size; y++)
+            computeRow(y);
+      }
+
+      private void computeRow(int y)
+      {
+         int bits = 0;
+
+         final double Ci = (y*fac - 1.0);
+          final byte[] bufLocal = buf;
+          for (int x = 0; x<size;x++) {
+            double Zr = 0.0;
+            double Zi = 0.0;
+            double Cr = (x*fac - 1.5);
+            int i = 50;
+            double ZrN = 0;
+            double ZiN = 0;
+            do {
+               Zi = 2.0 * Zr * Zi + Ci;
+               Zr = ZrN - ZiN + Cr;
+               ZiN = Zi * Zi;
+               ZrN = Zr * Zr;
+            } while (!(ZiN + ZrN > 4.0) && --i > 0);
+
+            bits = bits << 1;
+            if (i == 0) bits++;
+
+            if (x%8 == 7) {
+                bufLocal[bufLen++] = (byte) bits;
+                if ( bufLen == BUFFER_SIZE) {
+                    bufLen = 0;
+                }
+               bits = 0;
+            }
+         }
+         if (shift!=0) {
+            bits = bits << shift;
+            bufLocal[bufLen++] = (byte) bits;
+            if ( bufLen == BUFFER_SIZE) {
+                bufLen = 0;
+            }
+         }
+      }
+      // CHECKSTYLE.OFF: .*
+
+  public void timeMandelbrot(int iters) {
+    for (int i = 0; i < iters; i++) {
+      bufLen = 0;
+      compute();
+    }
+  }
+
+  public boolean verifyMandelbrot() {
+    bufLen = 0;
+    compute();
+
+    int expected = 5000;
+    int found = bufLen;
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    mandelbrot obj = new mandelbrot();
+
+    final long before = System.currentTimeMillis();
+    obj.timeMandelbrot(65);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyMandelbrot()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/mandelbrot: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/meteor.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/meteor.java
new file mode 100644
index 0000000..596b0fd
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/meteor.java
@@ -0,0 +1,498 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `meteor/meteor.java` from the archive available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Tony Seebregts
+ * modified by
+ */
+
+/*
+ * Description:     Search for solutions to shape packing puzzle
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+
+import java.util.ArrayList;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/** First hack at a Java solver for the meteor puzzle - just the IBM 
+  * developerWorks article algorithm optimized with precalculated shapes 
+  * and bitmasks. Should be possible to optimize it some more to take 
+  * advantage of reflections but its turning out to be less obvious 
+  * than expected :-).
+  * <p>
+  * Notes:
+  * <ul>
+  * <li>Seems to run faster without the -server switch.
+  * <li>Testing for islands seems to be slower than just fitting pieces.
+  * </ul>
+  * 
+  * @author Tony Seebregts
+  *
+  */
+  
+// CHECKSTYLE.OFF: .*
+public class meteor
+   { // CONSTANTS
+       
+     private static final int[]    SHIFT = { 0,6,11,17,22,28,33,39,44,50 };
+     private static final long[][] MASK  = { { 0x01L,      0x02L,      0x04L,      0x08L,      0x10L   },
+                     { 0x01L << 6, 0x02L << 6, 0x04L << 6, 0x08L <<  6,0x10L << 6  },
+                     { 0x01L << 11,0x02L << 11,0x04L << 11,0x08L << 11,0x10L << 11 },
+                     { 0x01L << 17,0x02L << 17,0x04L << 17,0x08L << 17,0x10L << 17 },
+                     { 0x01L << 22,0x02L << 22,0x04L << 22,0x08L << 22,0x10L << 22 },
+                     { 0x01L << 28,0x02L << 28,0x04L << 28,0x08L << 28,0x10L << 28 },
+                     { 0x01L << 33,0x02L << 33,0x04L << 33,0x08L << 33,0x10L << 33 },
+                     { 0x01L << 39,0x02L << 39,0x04L << 39,0x08L << 39,0x10L << 39 },
+                     { 0x01L << 44,0x02L << 44,0x04L << 44,0x08L << 44,0x10L << 44 },
+                     { 0x01L << 50,0x02L << 50,0x04L << 50,0x08L << 50,0x10L << 50 }
+                       };
+     
+     private static final boolean DEBUG = false;
+
+     // CLASS VARIABLES
+     
+     // INSTANCE VARIABLES
+     
+     private SortedSet<String> solutions = new TreeSet<String>();
+     private Entry[]       solution  = new Entry[10];
+     private int       depth     = 0;
+     private Piece[]       pieces    = { new Piece(PIECE0),
+                     new Piece(PIECE1),
+                     new Piece(PIECE2),
+                     new Piece(PIECE3),
+                     new Piece(PIECE4),
+                     new Piece(PIECE5),
+                     new Piece(PIECE6),
+                     new Piece(PIECE7),
+                     new Piece(PIECE8),
+                     new Piece(PIECE9)
+                       };
+       
+     // CLASS METHODS
+
+     /** Prints out the puzzle.
+       * 
+       * 
+       */
+    
+     private static void print (String solution)
+         { System.out.print(solution.replaceAll("(\\d{5})(\\d{5})","$1 $2")
+                    .replaceAll("(\\d{5})","$1\n")
+                    .replaceAll("(\\d)","$1 "));
+         }
+
+     // CONSTRUCTORS
+     
+     /** Initialises the puzzle.
+       * 
+       */
+
+     public meteor ()
+        { for (int i=0; i<10; i++)
+          solution[i] = new Entry();
+        }
+     
+     // INSTANCE METHODS
+     
+     /** Initialises the puzzle and solution set at [0,0]
+       *
+       * @return Sorted list of solution strings.
+       */ 
+     
+     private SortedSet<String> solve()
+         { solve(0x0002004008010020L,0,0);
+         
+           return solutions;
+         }
+     
+     /** Recursively solves the puzzle by fitting pieces into the 
+       * next available hexagon.
+       * 
+       * @param puzzle  Current puzzle bitmask.
+       * @param row     Row of next available hexagon. 
+       * @param col     Column next available hexagon. 
+       * 
+       */
+      
+     private void solve (long puzzle,int row,int col)
+         { for (int ix=0; ix<pieces.length; ix++)
+           { Piece   piece;
+             Shape[] list;
+ 
+             // ... find shapes that fit
+             
+             if ((piece = pieces[ix]) == null)
+            continue;
+            else
+            list  = pieces[ix].shapes(row,col);
+               
+             for (Shape shape: list)
+             { // ... fits badly ?
+          
+               if ((shape.bitmap & puzzle) != 0)
+                  continue;
+               
+               // ... try piece in puzzle
+ 
+               long clone = puzzle | shape.bitmap;
+ 
+               // ... find next position
+                
+               int irow = row;
+               int icol = col/2 + 1;
+                
+               next:
+               while (irow < 10)
+                 { while (icol < 5)
+                     { if ((clone & MASK[irow][icol]) == 0)
+                      break next;
+                              
+                       icol++;
+                     }
+                         
+                   irow++;
+                   icol = 0;
+                 }
+                 
+               // ... solve next
+               
+               Entry entry;
+                 
+               pieces[ix]  = null;
+               entry   = solution[depth++];
+               entry.row   = row;
+               entry.col   = col;
+               entry.shape = shape;
+ 
+               if (depth == 10)
+                  solutions.add(serialize(solution));
+                  else
+                  solve (clone,irow,2*icol + (irow % 2));
+                
+               depth--;
+               pieces[ix] = piece;
+             }
+           }
+         }
+      
+     /** Serializes the current solution to a string.
+       * 
+       */
+      
+     private String serialize (Entry[] solution)
+         { char[] puzzle = new char[50];
+           Shape   shape;
+           int     row;
+           int     col;
+           
+           for (Entry entry: solution)
+           { shape = entry.shape;
+             row   = entry.row;
+             col   = entry.col;
+             
+             for (int[] xy: shape.vector)
+             puzzle[5 * (row + xy[0]) + (col + xy[1])/2] = shape.symbol;
+           }
+      
+           return new String(puzzle);
+         }
+    
+     // INNER CLASSES
+     
+     /** Container class for a solution set entry.
+       * 
+       */
+     
+     private static class Entry
+         { public int   row;
+           public int   col;
+           public Shape shape; 
+         }
+     
+     /** Container class for the shapes for a single puzzle piece.
+       * 
+       * 
+       */
+     
+     private static class Piece
+         { private Shape[][][] shapes = new Shape[10][10][];
+         
+           @SuppressWarnings("unchecked")
+           private Piece (Shape[] list)
+               { // ... initialise
+               
+             ArrayList[][] array = new ArrayList[10][10];
+             
+             for (int i=0; i<10; i++)
+                 for (int j=0; j<10; j++)
+                 array[i][j] = new ArrayList<Shape>();
+             
+             // ... generate list
+             
+             for (Shape mutant: list)
+                 for (int row=0; row<=mutant.maxRow; row++)
+                 for (int col=mutant.minCol; col<=mutant.maxCol; col++)
+                     { if (!mutant.islet)
+                      array[row][col].add(new Shape(mutant,row,col));
+                      else if ((row != 0) || (col != 0))
+                      array[row][col].add(new Shape(mutant,row,col));
+                     }
+             
+             for (int row=0; row<10; row++)
+                 for (int col=0; col<10; col++)
+                 shapes[row][col] = (Shape[]) array[row][col].toArray(new Shape[0]);
+               }
+           
+           @SuppressWarnings("unchecked")
+           private Shape[] shapes(int row,int col)
+               { return shapes[row][col];
+               }
+         
+         }
+
+     /** Container class for the shape vector and bitmap single puzzle piece mutation.
+       * 
+       * 
+       */
+     
+     private static class Shape
+        { private char    symbol;
+          private int[][] vector;
+          private long    bitmap;
+          private int     shift;
+          
+          private boolean islet;
+          private int     maxRow;
+          private int     minCol;
+          private int     maxCol;
+          
+          private Shape (char    symbol,
+                 int[][] vector,
+                 long    bitmap,
+                 int     shift,
+                 boolean islet,
+                 int     maxRow,
+                 int     minCol,
+                 int     maxCol)
+              { this.symbol  = symbol;
+            this.vector  = vector;
+            this.bitmap  = bitmap;
+            this.shift   = shift;
+            
+            this.islet   = islet;
+            this.maxRow  = maxRow;
+            this.minCol  = minCol;
+            this.maxCol  = maxCol;
+              }
+          
+          private Shape (Shape shape,
+                 int   row,
+                 int   col)
+              { this.symbol  = shape.symbol;
+            this.vector  = shape.vector;
+            this.bitmap  = shape.bitmap << ((SHIFT[row] + (col - (row % 2))/2) - shape.shift);
+            
+            this.islet   = shape.islet;
+            this.maxRow  = shape.maxRow;
+            this.minCol  = shape.minCol;
+            this.maxCol  = shape.maxCol;
+              }
+        }
+     
+     // PIECES
+
+     private static final Shape[] PIECE0 = { new Shape ('0',new int[][] {{3, 5},{2, 4},{1, 3},{0, 2},{0, 0}},0x0000000000082083L,0,false,6,0,4),
+                     new Shape ('0',new int[][] {{4,-2},{3,-1},{2, 0},{1, 1},{0, 0}},0x0000000000421082L,1,false,5,2,8),
+                     new Shape ('0',new int[][] {{1,-7},{1,-5},{1,-3},{1,-1},{0, 0}},0x00000000000003D0L,4,false,8,7,9),
+                     new Shape ('0',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{3, 5}},0x00000000000C1041L,0,false,6,0,4),
+                     new Shape ('0',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{4,-2}},0x0000000000821084L,2,false,5,3,9),
+                     new Shape ('0',new int[][] {{0, 6},{0, 4},{0, 2},{0, 0},{1,-1}},0x000000000000005EL,1,false,8,1,3),
+                     new Shape ('0',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{4, 2}},0x0000000000841041L,0,false,5,0,6),
+                     new Shape ('0',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{3,-5}},0x0000000000062108L,3,false,6,5,9),
+                     new Shape ('0',new int[][] {{1, 7},{1, 5},{1, 3},{1, 1},{0, 0}},0x00000000000003C1L,0,false,8,0,2),
+                     new Shape ('0',new int[][] {{4, 2},{3, 1},{2, 0},{1,-1},{0, 0}},0x0000000001041042L,1,false,5,1,7),
+                     new Shape ('0',new int[][] {{3,-3},{2,-2},{1,-1},{0, 0},{0, 2}},0x000000000002108CL,2,false,6,3,7),
+                     new Shape ('0',new int[][] {{0, 0},{0, 2},{0, 4},{0, 6},{1, 7}},0x000000000000020FL,0,false,8,0,2)
+                       };
+
+     private static final Shape[] PIECE1 = { new Shape ('1',new int[][] {{0, 2},{0, 0},{1,-1},{2, 0},{3,-1}},0x0000000000021046L,1,false,6,1,7),
+                     new Shape ('1',new int[][] {{1, 3},{0, 2},{0, 0},{1,-1},{1,-3}},0x00000000000002CCL,2,false,8,3,6),
+                     new Shape ('1',new int[][] {{3, 3},{2, 4},{1, 3},{1, 1},{0, 0}},0x00000000000420C1L,0,false,6,0,5),
+                     new Shape ('1',new int[][] {{3,-3},{3,-1},{2, 0},{1,-1},{0, 0}},0x0000000000062084L,2,false,6,3,9),
+                     new Shape ('1',new int[][] {{0, 0},{1, 1},{1, 3},{0, 4},{0, 6}},0x00000000000000CDL,0,true, 8,0,3),
+                     new Shape ('1',new int[][] {{0, 0},{1,-1},{2, 0},{2, 2},{3, 3}},0x0000000000083042L,1,false,6,1,6),
+                     new Shape ('1',new int[][] {{0, 6},{1, 5},{1, 3},{0, 2},{0, 0}},0x000000000000018BL,0,true, 8,0,3),
+                     new Shape ('1',new int[][] {{3, 3},{3, 1},{2, 0},{1, 1},{0, 0}},0x0000000000060841L,0,false,6,0,6),
+                     new Shape ('1',new int[][] {{3,-3},{2,-4},{1,-3},{1,-1},{0, 0}},0x00000000000208C4L,2,false,6,4,9),
+                     new Shape ('1',new int[][] {{1,-1},{0, 0},{0, 2},{1, 3},{1, 5}},0x0000000000000346L,1,false,8,1,4),
+                     new Shape ('1',new int[][] {{0, 0},{0, 2},{1, 3},{2, 2},{3, 3}},0x0000000000041083L,0,false,6,0,6),
+                     new Shape ('1',new int[][] {{0, 0},{1, 1},{2, 0},{2,-2},{3,-3}},0x0000000000023104L,2,false,6,3,8)
+                       };
+
+     private static final Shape[] PIECE2 = { new Shape ('2',new int[][] {{1, 1},{0, 0},{2, 0},{2,-2},{2,-4}},0x0000000000003904L,2,false,7,4,8),
+                     new Shape ('2',new int[][] {{2, 4},{1, 5},{2, 2},{1, 1},{0, 0}},0x0000000000003141L,0,false,7,0,4),
+                     new Shape ('2',new int[][] {{3,-1},{3, 1},{2,-2},{1,-1},{0, 0}},0x0000000000060842L,1,false,6,2,8),
+                     new Shape ('2',new int[][] {{1,-1},{2, 0},{0, 0},{0, 2},{0, 4}},0x000000000000104EL,1,false,7,1,5),
+                     new Shape ('2',new int[][] {{0, 0},{1,-1},{0, 2},{1, 3},{2, 4}},0x0000000000004146L,1,false,7,1,5),
+                     new Shape ('2',new int[][] {{0, 2},{0, 0},{1, 3},{2, 2},{3, 1}},0x0000000000021083L,0,true, 6,0,6),
+                     new Shape ('2',new int[][] {{0, 2},{1, 3},{0, 0},{1,-1},{2,-2}},0x0000000000000946L,1,false,7,2,6),
+                     new Shape ('2',new int[][] {{1, 5},{2, 4},{0, 4},{0, 2},{0, 0}},0x0000000000002107L,0,false,7,0,4),
+                     new Shape ('2',new int[][] {{3, 1},{3,-1},{2, 2},{1, 1},{0, 0}},0x0000000000062082L,1,false,6,1,7),
+                     new Shape ('2',new int[][] {{2,-4},{1,-5},{2,-2},{1,-1},{0, 0}},0x0000000000003148L,3,false,7,5,9),
+                     new Shape ('2',new int[][] {{1,-1},{0, 0},{2, 0},{2, 2},{2, 4}},0x0000000000007042L,1,false,7,1,5),
+                     new Shape ('2',new int[][] {{0, 0},{0, 2},{1,-1},{2, 0},{3, 1}},0x0000000000041046L,1,false,6,1,7)
+                       };
+
+     private static final Shape[] PIECE3 = { new Shape ('3',new int[][] {{0, 0},{2, 0},{1,-1},{2,-2},{2,-4}},0x0000000000003884L,2,false,7,4,9),
+                     new Shape ('3',new int[][] {{1, 5},{2, 2},{1, 3},{1, 1},{0, 0}},0x00000000000011C1L,0,false,7,0,4),
+                     new Shape ('3',new int[][] {{3, 1},{2,-2},{2, 0},{1,-1},{0, 0}},0x0000000000041842L,1,false,6,2,8),
+                     new Shape ('3',new int[][] {{2, 0},{0, 0},{1, 1},{0, 2},{0, 4}},0x0000000000000847L,0,false,7,0,5),
+                     new Shape ('3',new int[][] {{1,-3},{0, 0},{1,-1},{1, 1},{2, 2}},0x00000000000041C4L,2,false,7,3,7),
+                     new Shape ('3',new int[][] {{0, 0},{1, 3},{1, 1},{2, 2},{3, 1}},0x00000000000210C1L,0,true, 6,0,6),
+                     new Shape ('3',new int[][] {{1, 3},{0, 0},{1, 1},{1,-1},{2,-2}},0x00000000000009C2L,1,false,7,2,6),
+                     new Shape ('3',new int[][] {{2, 4},{0, 4},{1, 3},{0, 2},{0, 0}},0x0000000000002087L,0,false,7,0,5),
+                     new Shape ('3',new int[][] {{3,-1},{2, 2},{2, 0},{1, 1},{0, 0}},0x0000000000023082L,1,false,6,1,7),
+                     new Shape ('3',new int[][] {{1,-5},{2,-2},{1,-3},{1,-1},{0, 0}},0x00000000000021C8L,3,false,7,5,9),
+                     new Shape ('3',new int[][] {{0, 0},{2, 0},{1, 1},{2, 2},{2, 4}},0x0000000000003841L,0,false,7,0,5),
+                     new Shape ('3',new int[][] {{0, 0},{1,-3},{1,-1},{2,-2},{3,-1}},0x00000000000410C4L,2,false,6,3,9)
+                       };
+
+     private static final Shape[] PIECE4 = { new Shape ('4',new int[][] {{1, 5},{2, 2},{1, 3},{0, 2},{0, 0}},0x0000000000001183L,0,false,7,0,4),
+                     new Shape ('4',new int[][] {{3, 1},{2,-2},{2, 0},{1, 1},{0, 0}},0x0000000000041882L,1,false,6,2,8),
+                     new Shape ('4',new int[][] {{2, 0},{0, 0},{1, 1},{1, 3},{0, 4}},0x00000000000008C5L,0,true, 7,0,5),
+                     new Shape ('4',new int[][] {{1,-3},{0, 0},{1,-1},{2, 0},{2, 2}},0x00000000000060C4L,2,false,7,3,7),
+                     new Shape ('4',new int[][] {{0, 0},{1, 3},{1, 1},{2, 0},{3, 1}},0x00000000000208C1L,0,false,6,0,6),
+                     new Shape ('4',new int[][] {{0, 0},{2, 0},{1,-1},{1,-3},{2,-4}},0x00000000000028C4L,2,false,7,4,9),
+                     new Shape ('4',new int[][] {{0, 0},{1,-3},{1,-1},{2, 0},{3,-1}},0x00000000000420C4L,2,false,6,3,9),
+                     new Shape ('4',new int[][] {{1, 3},{0, 0},{1, 1},{2, 0},{2,-2}},0x0000000000001982L,1,false,7,2,6),
+                     new Shape ('4',new int[][] {{2, 4},{0, 4},{1, 3},{1, 1},{0, 0}},0x00000000000020C5L,0,true, 7,0,5),
+                     new Shape ('4',new int[][] {{3,-1},{2, 2},{2, 0},{1,-1},{0, 0}},0x0000000000023042L,1,false,6,1,7),
+                     new Shape ('4',new int[][] {{1,-3},{2, 0},{1,-1},{0, 0},{0, 2}},0x00000000000020CCL,2,false,7,3,7),
+                     new Shape ('4',new int[][] {{0, 0},{2, 0},{1, 1},{1, 3},{2, 4}},0x00000000000028C1L,0,false,7,0,5)
+                       };
+
+     private static final Shape[] PIECE5 = { new Shape ('5',new int[][] {{0, 2},{1, 1},{0, 0},{1,-1},{2,-2}},0x00000000000008C6L,1,false,7,2,7),
+                     new Shape ('5',new int[][] {{1, 5},{1, 3},{0, 4},{0, 2},{0, 0}},0x0000000000000187L,0,false,8,0,4),
+                     new Shape ('5',new int[][] {{3, 1},{2, 0},{2, 2},{1, 1},{0, 0}},0x0000000000021841L,0,false,6,0,7),
+                     new Shape ('5',new int[][] {{2,-4},{1,-3},{2,-2},{1,-1},{0, 0}},0x00000000000018C4L,2,false,7,4,9),
+                     new Shape ('5',new int[][] {{0, 0},{0, 2},{1, 1},{1, 3},{1, 5}},0x00000000000001C3L,0,false,8,0,4),
+                     new Shape ('5',new int[][] {{0, 0},{1, 1},{1,-1},{2, 0},{3, 1}},0x00000000000410C2L,1,false,6,1,8),
+                     new Shape ('5',new int[][] {{0, 2},{0, 0},{1, 1},{1,-1},{1,-3}},0x00000000000001CCL,2,false,8,3,7),
+                     new Shape ('5',new int[][] {{2, 4},{1, 3},{2, 2},{1, 1},{0, 0}},0x00000000000030C1L,0,false,7,0,5),
+                     new Shape ('5',new int[][] {{3,-1},{2, 0},{2,-2},{1,-1},{0, 0}},0x0000000000021842L,1,false,6,2,9),
+                     new Shape ('5',new int[][] {{1,-1},{1, 1},{0, 0},{0, 2},{0, 4}},0x00000000000000CEL,1,false,8,1,5),
+                     new Shape ('5',new int[][] {{0, 0},{1, 1},{0, 2},{1, 3},{2, 4}},0x00000000000020C3L,0,false,7,0,5),
+                     new Shape ('5',new int[][] {{0, 0},{1,-1},{1, 1},{2, 0},{3,-1}},0x00000000000210C2L,1,false,6,1,8)
+                       };
+
+     private static final Shape[] PIECE6 = { new Shape ('6',new int[][] {{1, 1},{0, 0},{1,-1},{1,-3},{2,-4}},0x00000000000009C4L,2,false,7,4,8),
+                     new Shape ('6',new int[][] {{2, 4},{1, 5},{1, 3},{0, 2},{0, 0}},0x0000000000002183L,0,false,7,0,4),
+                     new Shape ('6',new int[][] {{3,-1},{3, 1},{2, 0},{1, 1},{0, 0}},0x0000000000061082L,1,false,6,1,8),
+                     new Shape ('6',new int[][] {{1,-5},{2,-4},{1,-3},{1,-1},{0, 0}},0x00000000000011C8L,3,false,7,5,9),
+                     new Shape ('6',new int[][] {{0, 0},{1,-1},{1, 1},{2, 2},{2, 4}},0x00000000000060C2L,1,false,7,1,5),
+                     new Shape ('6',new int[][] {{0, 2},{0, 0},{1, 1},{2, 0},{3, 1}},0x0000000000020843L,0,false,6,0,7),
+                     new Shape ('6',new int[][] {{0, 0},{1, 1},{1,-1},{2,-2},{2,-4}},0x0000000000001984L,2,false,7,4,8),
+                     new Shape ('6',new int[][] {{1, 5},{2, 4},{1, 3},{1, 1},{0, 0}},0x00000000000021C1L,0,false,7,0,4),
+                     new Shape ('6',new int[][] {{3, 1},{3,-1},{2, 0},{1,-1},{0, 0}},0x0000000000061042L,1,false,6,1,8),
+                     new Shape ('6',new int[][] {{2,-2},{1,-3},{1,-1},{0, 0},{0, 2}},0x00000000000010CCL,2,false,7,3,7),
+                     new Shape ('6',new int[][] {{1,-1},{0, 0},{1, 1},{1, 3},{2, 4}},0x00000000000041C2L,1,false,7,1,5),
+                     new Shape ('6',new int[][] {{0, 0},{0, 2},{1, 1},{2, 2},{3, 1}},0x0000000000021043L,0,false,6,0,7)
+                       };
+
+     private static final Shape[] PIECE7 = { new Shape ('7',new int[][] {{0, 2},{1, 1},{0, 0},{2, 0},{2,-2}},0x0000000000001886L,1,false,7,2,7),
+                     new Shape ('7',new int[][] {{1, 5},{1, 3},{0, 4},{1, 1},{0, 0}},0x00000000000001C5L,0,true, 8,0,4),
+                     new Shape ('7',new int[][] {{3, 1},{2, 0},{2, 2},{1,-1},{0, 0}},0x0000000000043042L,1,false,6,1,7),
+                     new Shape ('7',new int[][] {{2,-2},{1,-1},{2, 0},{0, 0},{0, 2}},0x0000000000001846L,1,false,7,2,7),
+                     new Shape ('7',new int[][] {{0, 0},{0, 2},{1, 1},{0, 4},{1, 5}},0x0000000000000147L,0,false,8,0,4),
+                     new Shape ('7',new int[][] {{0, 0},{1, 1},{1,-1},{2, 2},{3, 1}},0x00000000000420C2L,1,false,6,1,7),
+                     new Shape ('7',new int[][] {{0, 4},{0, 2},{1, 3},{0, 0},{1,-1}},0x000000000000014EL,1,false,8,1,5),
+                     new Shape ('7',new int[][] {{2, 4},{1, 3},{2, 2},{0, 2},{0, 0}},0x0000000000003083L,0,false,7,0,5),
+                     new Shape ('7',new int[][] {{3,-1},{2, 0},{2,-2},{1, 1},{0, 0}},0x0000000000021882L,1,false,6,2,8),
+                     new Shape ('7',new int[][] {{1,-1},{1, 1},{0, 0},{1, 3},{0, 4}},0x00000000000001CAL,1,false,8,1,5),
+                     new Shape ('7',new int[][] {{0, 0},{1, 1},{0, 2},{2, 2},{2, 4}},0x0000000000003043L,0,false,7,0,5),
+                     new Shape ('7',new int[][] {{0, 0},{1,-1},{1, 1},{2,-2},{3,-1}},0x00000000000208C2L,1,false,6,2,8)
+                       };
+
+     private static final Shape[] PIECE8 = { new Shape ('8',new int[][] {{4, 2},{3, 1},{2, 0},{1, 1},{0, 0}},0x0000000000820841L,0,false,5,0,7),
+                     new Shape ('8',new int[][] {{3,-5},{2,-4},{1,-3},{1,-1},{0, 0}},0x0000000000021188L,3,false,6,5,9),
+                     new Shape ('8',new int[][] {{0, 0},{0, 2},{0, 4},{1, 5},{1, 7}},0x0000000000000307L,0,false,8,0,2),
+                     new Shape ('8',new int[][] {{0, 0},{1, 1},{2, 2},{3, 1},{4, 2}},0x0000000000821041L,0,true, 5,0,7),
+                     new Shape ('8',new int[][] {{0, 0},{1,-1},{2,-2},{2,-4},{3,-5}},0x0000000000023108L,3,false,6,5,9),
+                     new Shape ('8',new int[][] {{1, 7},{1, 5},{1, 3},{0, 2},{0, 0}},0x0000000000000383L,0,false,8,0,2),
+                     new Shape ('8',new int[][] {{0, 0},{1, 1},{2, 2},{2, 4},{3, 5}},0x0000000000083041L,0,false,6,0,4),
+                     new Shape ('8',new int[][] {{0, 0},{1,-1},{2,-2},{3,-1},{4,-2}},0x0000000000420842L,1,false,5,2,9),
+                     new Shape ('8',new int[][] {{0, 4},{0, 2},{0, 0},{1,-1},{1,-3}},0x00000000000000DCL,2,false,8,3,5),
+                     new Shape ('8',new int[][] {{3, 5},{2, 4},{1, 3},{1, 1},{0, 0}},0x00000000000820C1L,0,false,6,0,4),
+                     new Shape ('8',new int[][] {{4,-2},{3,-1},{2, 0},{1,-1},{0, 0}},0x0000000000421042L,1,false,5,2,9),
+                     new Shape ('8',new int[][] {{1,-5},{1,-3},{1,-1},{0, 0},{0, 2}},0x00000000000001D8L,3,false,8,5,7)
+                       };
+
+     private static final Shape[] PIECE9 = { new Shape ('9',new int[][] {{3, 3},{2, 2},{1, 1},{0, 0},{0, 2}},0x0000000000041043L,0,false,6,0,6),
+                     new Shape ('9',new int[][] {{3,-3},{2,-2},{1,-1},{0, 0},{1, 1}},0x0000000000021184L,2,false,6,3,8),
+                     new Shape ('9',new int[][] {{0, 0},{0, 2},{0, 4},{0, 6},{1, 5}},0x000000000000010FL,0,false,8,0,3),
+                     new Shape ('9',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{3, 1}},0x0000000000061041L,0,true, 6,0,6),
+                     new Shape ('9',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{2,-4}},0x0000000000021884L,2,false,6,4,9),
+                     new Shape ('9',new int[][] {{1, 5},{1, 3},{1, 1},{1,-1},{0, 0}},0x00000000000003C2L,1,false,8,1,4),
+                     new Shape ('9',new int[][] {{0, 0},{1, 1},{2, 2},{3, 3},{2, 4}},0x0000000000043041L,0,false,6,0,5),
+                     new Shape ('9',new int[][] {{0, 0},{1,-1},{2,-2},{3,-3},{3,-1}},0x0000000000061084L,2,false,6,3,9),
+                     new Shape ('9',new int[][] {{0, 6},{0, 4},{0, 2},{0, 0},{1, 1}},0x000000000000004FL,0,false,8,0,3),
+                     new Shape ('9',new int[][] {{3, 3},{2, 2},{1, 1},{0, 0},{1,-1}},0x00000000000820C2L,1,false,6,1,6),
+                     new Shape ('9',new int[][] {{3,-1},{2, 0},{1, 1},{0, 2},{0, 0}},0x0000000000021086L,1,false,6,1,7),
+                     new Shape ('9',new int[][] {{1,-5},{1,-3},{1,-1},{1, 1},{0, 0}},0x00000000000003C8L,3,false,8,5,8)
+                       };
+                       
+     // CHECKSTYLE.ON: .*
+
+  public void resetMeteor() {
+    for (int i = 0; i < 10; ++i) {
+      solution[i] = new Entry();
+    }
+  }
+
+  public void timeMeteor(int iters) {
+    for (int i = 0; i < iters; i++) {
+      solve();
+      resetMeteor();
+    }
+  }
+
+  public boolean verifyMeteor() {
+    solve();
+    String found = solutions.first().toString();
+    String expected = "00001222012661126155865558633348893448934747977799";
+
+    if (!expected.equals(found)) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    meteor puzzle = new meteor();
+
+    final long before = System.currentTimeMillis();
+    puzzle.timeMeteor(1);
+    final long after = System.currentTimeMillis();
+
+    if (!puzzle.verifyMeteor()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/meteor: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/nbody.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/nbody.java
new file mode 100644
index 0000000..d66044d
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/nbody.java
@@ -0,0 +1,229 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `nbody/nbody.java` from the archive available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Mark C. Lewis
+ * modified slightly by Chad Whipkey
+ *
+ * Same program, different command-line:
+ *     -XX:MaxMetaspaceSize=3m -XX:InitialCodeCacheSize=2048K -XX:ReservedCodeCacheSize=2048K
+ */
+
+/*
+ * Description:     Double-precision N-body simulation.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+// CHECKSTYLE.OFF: .*
+final class NBodySystem {
+   private Body[] bodies;
+
+   public NBodySystem(){
+      bodies = new Body[]{
+            Body.sun(),
+            Body.jupiter(),
+            Body.saturn(),
+            Body.uranus(),
+            Body.neptune()
+         };
+
+      double px = 0.0;
+      double py = 0.0;
+      double pz = 0.0;
+      for(int i=0; i < bodies.length; ++i) {
+         px += bodies[i].vx * bodies[i].mass;
+         py += bodies[i].vy * bodies[i].mass;
+         pz += bodies[i].vz * bodies[i].mass;
+      }
+      bodies[0].offsetMomentum(px,py,pz);
+   }
+
+   public void advance(double dt) {
+
+      for(int i=0; i < bodies.length; ++i) {
+            Body iBody = bodies[i];
+         for(int j=i+1; j < bodies.length; ++j) {
+                double dx = iBody.x - bodies[j].x;
+            double dy = iBody.y - bodies[j].y;
+            double dz = iBody.z - bodies[j].z;
+
+                double dSquared = dx * dx + dy * dy + dz * dz;
+                double distance = Math.sqrt(dSquared);
+                double mag = dt / (dSquared * distance);
+
+            iBody.vx -= dx * bodies[j].mass * mag;
+            iBody.vy -= dy * bodies[j].mass * mag;
+            iBody.vz -= dz * bodies[j].mass * mag;
+
+            bodies[j].vx += dx * iBody.mass * mag;
+            bodies[j].vy += dy * iBody.mass * mag;
+            bodies[j].vz += dz * iBody.mass * mag;
+         }
+      }
+
+        for ( Body body : bodies) {
+         body.x += dt * body.vx;
+         body.y += dt * body.vy;
+         body.z += dt * body.vz;
+      }
+   }
+
+   public double energy(){
+      double dx, dy, dz, distance;
+      double e = 0.0;
+
+      for (int i=0; i < bodies.length; ++i) {
+            Body iBody = bodies[i];
+            e += 0.5 * iBody.mass *
+                 ( iBody.vx * iBody.vx
+                   + iBody.vy * iBody.vy
+                   + iBody.vz * iBody.vz );
+
+         for (int j=i+1; j < bodies.length; ++j) {
+                Body jBody = bodies[j];
+                dx = iBody.x - jBody.x;
+            dy = iBody.y - jBody.y;
+            dz = iBody.z - jBody.z;
+
+            distance = Math.sqrt(dx*dx + dy*dy + dz*dz);
+            e -= (iBody.mass * jBody.mass) / distance;
+         }
+      }
+      return e;
+   }
+}
+
+
+final class Body {
+   static final double PI = 3.141592653589793;
+   static final double SOLAR_MASS = 4 * PI * PI;
+   static final double DAYS_PER_YEAR = 365.24;
+
+   public double x, y, z, vx, vy, vz, mass;
+
+   public Body(){}
+
+   static Body jupiter(){
+      Body p = new Body();
+      p.x = 4.84143144246472090e+00;
+      p.y = -1.16032004402742839e+00;
+      p.z = -1.03622044471123109e-01;
+      p.vx = 1.66007664274403694e-03 * DAYS_PER_YEAR;
+      p.vy = 7.69901118419740425e-03 * DAYS_PER_YEAR;
+      p.vz = -6.90460016972063023e-05 * DAYS_PER_YEAR;
+      p.mass = 9.54791938424326609e-04 * SOLAR_MASS;
+      return p;
+   }
+
+   static Body saturn(){
+      Body p = new Body();
+      p.x = 8.34336671824457987e+00;
+      p.y = 4.12479856412430479e+00;
+      p.z = -4.03523417114321381e-01;
+      p.vx = -2.76742510726862411e-03 * DAYS_PER_YEAR;
+      p.vy = 4.99852801234917238e-03 * DAYS_PER_YEAR;
+      p.vz = 2.30417297573763929e-05 * DAYS_PER_YEAR;
+      p.mass = 2.85885980666130812e-04 * SOLAR_MASS;
+      return p;
+   }
+
+   static Body uranus(){
+      Body p = new Body();
+      p.x = 1.28943695621391310e+01;
+      p.y = -1.51111514016986312e+01;
+      p.z = -2.23307578892655734e-01;
+      p.vx = 2.96460137564761618e-03 * DAYS_PER_YEAR;
+      p.vy = 2.37847173959480950e-03 * DAYS_PER_YEAR;
+      p.vz = -2.96589568540237556e-05 * DAYS_PER_YEAR;
+      p.mass = 4.36624404335156298e-05 * SOLAR_MASS;
+      return p;
+   }
+
+   static Body neptune(){
+      Body p = new Body();
+      p.x = 1.53796971148509165e+01;
+      p.y = -2.59193146099879641e+01;
+      p.z = 1.79258772950371181e-01;
+      p.vx = 2.68067772490389322e-03 * DAYS_PER_YEAR;
+      p.vy = 1.62824170038242295e-03 * DAYS_PER_YEAR;
+      p.vz = -9.51592254519715870e-05 * DAYS_PER_YEAR;
+      p.mass = 5.15138902046611451e-05 * SOLAR_MASS;
+      return p;
+   }
+
+   static Body sun(){
+      Body p = new Body();
+      p.mass = SOLAR_MASS;
+      return p;
+   }
+
+   Body offsetMomentum(double px, double py, double pz){
+      vx = -px / SOLAR_MASS;
+      vy = -py / SOLAR_MASS;
+      vz = -pz / SOLAR_MASS;
+      return this;
+   }
+}
+
+public final class nbody {
+  // CHECKSTYLE.ON: .*
+  private NBodySystem bodies;
+
+  public nbody() {
+    bodies = new NBodySystem();
+  }
+
+  private static final int PREDEFINED_N_STEPS = 1000;
+
+  public void solve() {
+    for (int i = 0; i < PREDEFINED_N_STEPS; ++i) {
+      bodies.advance(0.01);
+    }
+  }
+
+  public void timeNBody(int iters) {
+    for (int j = 0; j < iters; ++j) {
+      solve();
+    }
+  }
+
+  public boolean verifyNBody() {
+    bodies = new NBodySystem();
+    solve();
+
+    double expected = -0.169087605234606;
+    double found = bodies.energy();
+
+    if (Math.abs(expected - found) > 0.000000001) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    nbody obj = new nbody();
+
+    final long before = System.currentTimeMillis();
+    obj.timeNBody(1000);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyNBody()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/nbody: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/pidigits.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/pidigits.java
new file mode 100644
index 0000000..cafb4af
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/pidigits.java
@@ -0,0 +1,183 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `pidigits/pidigits.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Isaac Gouy
+ */
+
+/*
+ * Description:     Streaming arbitrary-precision arithmetic.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.math.BigInteger;
+
+// CHECKSTYLE.OFF: .*
+public class pidigits {
+   static final int L = 10;
+   private static final int PREDEFINED_N_DIGITS = 27;
+
+   public static void old_main() { 
+      int n = PREDEFINED_N_DIGITS;
+      int j = 0;
+   
+      PiDigitSpigot digits = new PiDigitSpigot();
+      
+      while (n > 0){
+         if (n >= L){
+            for (int i=0; i<L; i++) digits.next();
+            j += L;
+         } else {
+            for (int i=0; i<n; i++) digits.next();
+            j += n;   
+         }
+         n -= L;           
+      }               
+   }
+   // CHECKSTYLE.ON: .*
+
+  public void timePidigits(int iters) {
+    for (int j = 0; j < iters; j++) {
+      old_main();
+    }
+  }
+
+  public boolean verifyPidigits() {
+    PiDigitSpigot digits = new PiDigitSpigot();
+
+    for (int i = 0; i < PREDEFINED_N_DIGITS; ++i) {
+      digits.next();
+    }
+    int expected = 3;
+    int found = digits.next();
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    pidigits obj = new pidigits();
+
+    final long before = System.currentTimeMillis();
+    obj.timePidigits(100);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyPidigits()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/pidigits: " + (after - before));
+    System.exit(rc);
+  }
+}
+
+
+// CHECKSTYLE.OFF: .*
+class PiDigitSpigot {
+   Transformation z, x, inverse;            
+       
+   public PiDigitSpigot(){
+      z = new Transformation(1,0,0,1);
+      x = new Transformation(0,0,0,0);
+      inverse = new Transformation(0,0,0,0);
+   }   
+   
+   public int next(){
+      int y = digit();
+      if (isSafe(y)){ 
+         z = produce(y); return y;
+      } else {
+         z = consume( x.next() ); return next();   
+      }
+   }    
+      
+   public int digit(){
+      return z.extract(3);
+   }        
+   
+   public boolean isSafe(int digit){
+      return digit == z.extract(4);
+   }   
+   
+   public Transformation produce(int i){
+      return ( inverse.qrst(10,-10*i,0,1) ).compose(z);
+   }     
+      
+   public Transformation consume(Transformation a){
+      return z.compose(a);
+   }                   
+} 
+
+
+class Transformation {
+   BigInteger q, r, s, t;
+   int k;              
+       
+   public Transformation(int q, int r, int s, int t){
+      this.q = BigInteger.valueOf(q);
+      this.r = BigInteger.valueOf(r);
+      this.s = BigInteger.valueOf(s);
+      this.t = BigInteger.valueOf(t);                  
+      k = 0;
+   }
+   
+   public Transformation(BigInteger q, BigInteger r, BigInteger s, BigInteger t){
+      this.q = q;
+      this.r = r;
+      this.s = s;
+      this.t = t;                  
+      k = 0;
+   }        
+   
+   public Transformation next(){
+      k++;
+      q = BigInteger.valueOf(k);
+      r = BigInteger.valueOf(4 * k + 2);
+      s = BigInteger.valueOf(0);
+      t = BigInteger.valueOf(2 * k + 1); 
+      return this;                 
+   }      
+   
+   public int extract(int j){
+      BigInteger bigj = BigInteger.valueOf(j);
+      BigInteger numerator = (q.multiply(bigj)).add(r);
+      BigInteger denominator = (s.multiply(bigj)).add(t);                  
+      return ( numerator.divide(denominator) ).intValue();                    
+   }     
+   
+   public Transformation qrst(int q, int r, int s, int t){
+      this.q = BigInteger.valueOf(q);
+      this.r = BigInteger.valueOf(r);
+      this.s = BigInteger.valueOf(s);
+      this.t = BigInteger.valueOf(t); 
+      k = 0;  
+      return this;                             
+   }         
+  
+   public Transformation compose(Transformation a){      
+      return new Transformation(
+         q.multiply(a.q)
+         ,(q.multiply(a.r)).add( (r.multiply(a.t)) ) 
+         ,(s.multiply(a.q)).add( (t.multiply(a.s)) ) 
+         ,(s.multiply(a.r)).add( (t.multiply(a.t)) )                   
+         );                    
+   }          
+}
+// CHECKSTYLE.ON: .*
+
+
+  
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/regexdna.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/regexdna.java
new file mode 100644
index 0000000..9b1ac12
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/regexdna.java
@@ -0,0 +1,1171 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `regexdna/regexdna.java-4.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ * contributed by Razii, idea taken from Elliott Hughes and Roger Millington
+ */
+
+/*
+ * Description:     Match DNA 8-mers and substitute nucleotides for IUB codes.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+// CHECKSTYLE.OFF: .*
+import java.io.*;
+import java.util.regex.*;
+import java.util.*;
+
+public final class regexdna {
+
+   private static final Map<String, String> replacements = new HashMap<String, String>();
+   private InputStream stream;
+   private char[] cbuf;
+   private Reader r;
+
+   public regexdna() throws IOException {
+     stream = new ByteArrayInputStream(fastaStr.getBytes());
+     cbuf = new char[16384];
+     r = new InputStreamReader(stream, "ISO-8859-1");
+   }
+
+   static {
+
+      replacements.put("W", "(a|t)");
+      replacements.put("Y", "(c|t)");
+      replacements.put("K", "(g|t)");
+      replacements.put("M", "(a|c)");
+      replacements.put("S", "(c|g)");
+      replacements.put("R", "(a|g)");
+      replacements.put("B", "(c|g|t)");
+      replacements.put("D", "(a|g|t)");
+      replacements.put("V", "(a|c|g)");
+      replacements.put("H", "(a|c|t)");
+      replacements.put("N", "(a|c|g|t)");
+   }
+
+   static abstract class Rewriter {
+      private Pattern pattern;
+      private Matcher matcher;
+
+      public Rewriter(String regularExpression) {
+
+         this.pattern = Pattern.compile(regularExpression);
+      }
+
+      public String group(int i) {
+         return matcher.group(i);
+      }
+
+      public abstract String replacement();
+
+      public String rewrite(CharSequence original) {
+         return rewrite(original, new StringBuffer(original.length())).toString();
+      }
+
+      public StringBuffer rewrite(CharSequence original, StringBuffer destination) {
+         this.matcher = pattern.matcher(original);
+         while (matcher.find()) {
+            matcher.appendReplacement(destination, "");
+            destination.append(replacement());
+         }
+         matcher.appendTail(destination);
+         return destination;
+      }
+   }
+
+   public int old_main() throws IOException {
+      stream.reset();
+      StringBuilder sb = new StringBuilder(5100000);
+
+      int charsRead;
+      while ((charsRead = r.read(cbuf)) != -1)
+         sb.append(cbuf, 0, charsRead);
+
+      int initialLength = sb.length();
+
+      String sequence = new Rewriter(">.*\n|\n") {
+
+         public String replacement() {
+            return "";
+         }
+      }.rewrite(sb);
+
+
+      int codeLength = sequence.length();
+
+      String[] variants = { "agggtaaa|tttaccct" ,
+                       "[cgt]gggtaaa|tttaccc[acg]",
+                       "a[act]ggtaaa|tttacc[agt]t",
+                       "ag[act]gtaaa|tttac[agt]ct",
+                       "agg[act]taaa|ttta[agt]cct",
+                       "aggg[acg]aaa|ttt[cgt]ccct",
+                       "agggt[cgt]aa|tt[acg]accct",
+                       "agggta[cgt]a|t[acg]taccct",
+                       "agggtaa[cgt]|[acg]ttaccct"
+                     };
+
+      int count = 0;
+      for (String variant : variants) {
+
+         Matcher m = Pattern.compile(variant).matcher(sequence);
+         while (m.find())
+            count++;
+      }
+
+      sequence = new Rewriter("[WYKMSRBDVHN]") {
+
+         public String replacement() {
+            return replacements.get(group(0));
+         }
+      }.rewrite(sequence);
+
+     return count;
+   }
+   // CHECKSTYLE.ON: .*
+
+  public void timeRegexDna(int iters) throws IOException {
+    for (int j = 0; j < iters; j++) {
+      old_main();
+    }
+  }
+
+  public boolean verifyRegexDna() throws IOException {
+    int expected = 27;
+    int found = old_main();
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) throws IOException {
+    int rc = 0;
+    regexdna obj = new regexdna();
+
+    final long before = System.currentTimeMillis();
+    obj.timeRegexDna(10);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyRegexDna()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/regexdna: " + (after - before));
+    System.exit(rc);
+  }
+
+  private static final String fastaStr = ">ONE Homo sapiens alu\n"
+      + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\n"
+      + "TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\n"
+      + "AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\n"
+      + "GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\n"
+      + "CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\n"
+      + "GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\n"
+      + "GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\n"
+      + "TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\n"
+      + "AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\n"
+      + "GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT\n"
+      + "AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC\n"
+      + "AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG\n"
+      + "GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC\n"
+      + "CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG\n"
+      + "AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT\n"
+      + "TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA\n"
+      + "TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT\n"
+      + "GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG\n"
+      + "TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT\n"
+      + "CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG\n"
+      + "CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG\n"
+      + "TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA\n"
+      + "CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG\n"
+      + "AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG\n"
+      + "GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC\n"
+      + "TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA\n"
+      + "TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA\n"
+      + "GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT\n"
+      + "GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC\n"
+      + "ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT\n"
+      + "TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC\n"
+      + "CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG\n"
+      + "CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG\n"
+      + "GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC\n"
+      + "CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT\n"
+      + "GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC\n"
+      + "GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA\n"
+      + "GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA\n"
+      + "GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA\n"
+      + "GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG\n"
+      + "AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT\n"
+      + "CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA\n"
+      + "GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA\n"
+      + "AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC\n"
+      + "GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT\n"
+      + "ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG\n"
+      + "GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC\n"
+      + "GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC\n"
+      + "GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\n"
+      + "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA\n"
+      + "AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG\n"
+      + "GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT\n"
+      + "CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC\n"
+      + "TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG\n"
+      + "ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC\n"
+      + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA\n"
+      + "ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA\n"
+      + "CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA\n"
+      + "CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA\n"
+      + "ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG\n"
+      + "CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG\n"
+      + "AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC\n"
+      + "CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG\n"
+      + "AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC\n"
+      + "CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG\n"
+      + "CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG\n"
+      + "CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG\n"
+      + "CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC\n"
+      + "ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA\n"
+      + "AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC\n"
+      + "TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC\n"
+      + "ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG\n"
+      + "CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG\n"
+      + "AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT\n"
+      + "AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA\n"
+      + "TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC\n"
+      + "CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA\n"
+      + "TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG\n"
+      + "CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT\n"
+      + "GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG\n"
+      + "GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG\n"
+      + "CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\n"
+      + "GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG\n"
+      + "GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT\n"
+      + "AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT\n"
+      + "GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT\n"
+      + "CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG\n"
+      + "GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC\n"
+      + "TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT\n"
+      + "CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG\n"
+      + "ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG\n"
+      + "CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG\n"
+      + "AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA\n"
+      + "CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG\n"
+      + "CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC\n"
+      + "ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC\n"
+      + "GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC\n"
+      + "GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG\n"
+      + "GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT\n"
+      + "TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG\n"
+      + "CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA\n"
+      + "GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG\n"
+      + "CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC\n"
+      + "GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG\n"
+      + "CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA\n"
+      + "CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG\n"
+      + "CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA\n"
+      + "ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC\n"
+      + "CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT\n"
+      + "GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA\n"
+      + "AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG\n"
+      + "ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC\n"
+      + "TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA\n"
+      + "GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC\n"
+      + "GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG\n"
+      + "TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC\n"
+      + "AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA\n"
+      + "ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA\n"
+      + "GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\n"
+      + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG\n"
+      + "TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC\n"
+      + "CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT\n"
+      + "GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC\n"
+      + "CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA\n"
+      + "GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT\n"
+      + "TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC\n"
+      + "ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC\n"
+      + "TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG\n"
+      + "GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG\n"
+      + "TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG\n"
+      + "GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC\n"
+      + "GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT\n"
+      + "ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC\n"
+      + "GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC\n"
+      + "GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC\n"
+      + "CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA\n"
+      + "ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG\n"
+      + "AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC\n"
+      + "TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT\n"
+      + "CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG\n"
+      + "TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG\n"
+      + "CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC\n"
+      + "GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT\n"
+      + "GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC\n"
+      + "CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC\n"
+      + "TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG\n"
+      + "CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\n"
+      + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG\n"
+      + "AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG\n"
+      + "AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT\n"
+      + "GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA\n"
+      + "TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC\n"
+      + "AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA\n"
+      + "AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG\n"
+      + "CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC\n"
+      + "TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG\n"
+      + "GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT\n"
+      + "CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG\n"
+      + "CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG\n"
+      + "GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA\n"
+      + "AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA\n"
+      + "GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC\n"
+      + "TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC\n"
+      + "CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA\n"
+      + "GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\n"
+      + "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG\n"
+      + "AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG\n"
+      + "ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC\n"
+      + "ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC\n"
+      + "AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC\n"
+      + "GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG\n"
+      + "GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT\n"
+      + "CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC\n"
+      + "GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC\n"
+      + "CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\n"
+      + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA\n"
+      + "GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG\n"
+      + "GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT\n"
+      + "CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA\n"
+      + "AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG\n"
+      + "CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC\n"
+      + "CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG\n"
+      + "GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG\n"
+      + "GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT\n"
+      + "TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA\n"
+      + "ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG\n"
+      + "CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA\n"
+      + "ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA\n"
+      + "GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG\n"
+      + "TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC\n"
+      + "GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA\n"
+      + "GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT\n"
+      + "GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT\n"
+      + "GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG\n"
+      + "TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT\n"
+      + "TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC\n"
+      + "TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC\n"
+      + "GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT\n"
+      + "CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC\n"
+      + "TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA\n"
+      + ">TWO IUB ambiguity codes\n"
+      + "cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg\n"
+      + "tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa\n"
+      + "NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt\n"
+      + "cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga\n"
+      + "gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa\n"
+      + "HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca\n"
+      + "tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt\n"
+      + "tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt\n"
+      + "acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct\n"
+      + "tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt\n"
+      + "gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa\n"
+      + "accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt\n"
+      + "RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt\n"
+      + "tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag\n"
+      + "cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg\n"
+      + "ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat\n"
+      + "actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg\n"
+      + "YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa\n"
+      + "KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata\n"
+      + "aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa\n"
+      + "aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg\n"
+      + "gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc\n"
+      + "tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK\n"
+      + "tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt\n"
+      + "ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg\n"
+      + "ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa\n"
+      + "BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt\n"
+      + "aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc\n"
+      + "tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc\n"
+      + "cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac\n"
+      + "aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga\n"
+      + "tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga\n"
+      + "aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD\n"
+      + "gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg\n"
+      + "ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV\n"
+      + "taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa\n"
+      + "ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat\n"
+      + "gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg\n"
+      + "gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa\n"
+      + "tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt\n"
+      + "tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt\n"
+      + "taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca\n"
+      + "cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag\n"
+      + "aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt\n"
+      + "cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt\n"
+      + "ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW\n"
+      + "attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag\n"
+      + "ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa\n"
+      + "attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc\n"
+      + "tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta\n"
+      + "aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata\n"
+      + "cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc\n"
+      + "gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg\n"
+      + "attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca\n"
+      + "BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga\n"
+      + "DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat\n"
+      + "tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM\n"
+      + "tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR\n"
+      + "tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg\n"
+      + "taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc\n"
+      + "aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc\n"
+      + "DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa\n"
+      + "VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt\n"
+      + "agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat\n"
+      + "gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt\n"
+      + "tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt\n"
+      + "catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt\n"
+      + "tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR\n"
+      + "aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat\n"
+      + "aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac\n"
+      + "acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS\n"
+      + "tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga\n"
+      + "aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM\n"
+      + "acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt\n"
+      + "RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt\n"
+      + "RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta\n"
+      + "tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac\n"
+      + "gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt\n"
+      + "YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc\n"
+      + "ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt\n"
+      + "ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat\n"
+      + "gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta\n"
+      + "KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD\n"
+      + "aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg\n"
+      + "gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH\n"
+      + "taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact\n"
+      + "VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV\n"
+      + "NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa\n"
+      + "MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag\n"
+      + "cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata\n"
+      + "ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg\n"
+      + "tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN\n"
+      + "aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc\n"
+      + "actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg\n"
+      + "tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga\n"
+      + "gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa\n"
+      + "BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca\n"
+      + "aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata\n"
+      + "aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat\n"
+      + "YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt\n"
+      + "aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW\n"
+      + "cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata\n"
+      + "tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata\n"
+      + "tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt\n"
+      + "MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac\n"
+      + "taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta\n"
+      + "tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS\n"
+      + "RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc\n"
+      + "agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata\n"
+      + "NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa\n"
+      + "gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata\n"
+      + "aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt\n"
+      + "ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW\n"
+      + "cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt\n"
+      + "tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa\n"
+      + "RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt\n"
+      + "tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD\n"
+      + "gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc\n"
+      + "tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta\n"
+      + "ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM\n"
+      + "tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc\n"
+      + "ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc\n"
+      + "BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt\n"
+      + "gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga\n"
+      + "acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag\n"
+      + "gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc\n"
+      + "taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat\n"
+      + "acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta\n"
+      + "tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt\n"
+      + "catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa\n"
+      + "tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB\n"
+      + "atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR\n"
+      + "ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta\n"
+      + "ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta\n"
+      + "cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK\n"
+      + "SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW\n"
+      + "VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc\n"
+      + "BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct\n"
+      + "NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt\n"
+      + "tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa\n"
+      + "ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa\n"
+      + "cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa\n"
+      + "VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR\n"
+      + "atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac\n"
+      + "aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc\n"
+      + "tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac\n"
+      + "RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag\n"
+      + "gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc\n"
+      + "tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact\n"
+      + "attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc\n"
+      + "atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga\n"
+      + "cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt\n"
+      + "NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR\n"
+      + "ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat\n"
+      + "cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg\n"
+      + "aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac\n"
+      + "agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR\n"
+      + "tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga\n"
+      + "ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg\n"
+      + "ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa\n"
+      + "tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag\n"
+      + "taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg\n"
+      + "tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN\n"
+      + "YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt\n"
+      + "ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa\n"
+      + "tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat\n"
+      + "ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg\n"
+      + "attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt\n"
+      + "atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW\n"
+      + "YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta\n"
+      + "gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV\n"
+      + "MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta\n"
+      + "tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt\n"
+      + "ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa\n"
+      + "aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa\n"
+      + "BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM\n"
+      + "tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK\n"
+      + "StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV\n"
+      + "cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN\n"
+      + "atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg\n"
+      + "atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg\n"
+      + "ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct\n"
+      + "gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM\n"
+      + "tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD\n"
+      + "BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc\n"
+      + "agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga\n"
+      + "HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR\n"
+      + "tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt\n"
+      + "aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa\n"
+      + "catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB\n"
+      + "aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat\n"
+      + "tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt\n"
+      + "cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag\n"
+      + "DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat\n"
+      + "gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta\n"
+      + "tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM\n"
+      + "atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc\n"
+      + "KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt\n"
+      + "tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata\n"
+      + "tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK\n"
+      + "taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt\n"
+      + "NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa\n"
+      + "HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa\n"
+      + "ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg\n"
+      + "tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK\n"
+      + "cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga\n"
+      + "ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca\n"
+      + "HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg\n"
+      + "gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS\n"
+      + "BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg\n"
+      + "gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat\n"
+      + "KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact\n"
+      + "cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat\n"
+      + "tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD\n"
+      + "taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM\n"
+      + "gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt\n"
+      + "aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat\n"
+      + "acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta\n"
+      + "RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc\n"
+      + "attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac\n"
+      + "KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS\n"
+      + "KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD\n"
+      + "gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB\n"
+      + "aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct\n"
+      + "aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga\n"
+      + "ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY\n"
+      + "tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga\n"
+      + "aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta\n"
+      + "tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY\n"
+      + "MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc\n"
+      + "cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta\n"
+      + "caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt\n"
+      + "ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc\n"
+      + "acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat\n"
+      + "tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc\n"
+      + "gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa\n"
+      + "atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga\n"
+      + "aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat\n"
+      + "NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt\n"
+      + "taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa\n"
+      + "aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat\n"
+      + "ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca\n"
+      + "DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata\n"
+      + "tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat\n"
+      + "aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa\n"
+      + "ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM\n"
+      + "ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca\n"
+      + "RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa\n"
+      + "aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac\n"
+      + "aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt\n"
+      + "aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK\n"
+      + "tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat\n"
+      + "atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR\n"
+      + "BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc\n"
+      + "gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct\n"
+      + "cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN\n"
+      + "RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat\n"
+      + "taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt\n"
+      + "aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt\n"
+      + "gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct\n"
+      + "gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa\n"
+      + "aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta\n"
+      + "gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg\n"
+      + "ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat\n"
+      + "MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct\n"
+      + "SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY\n"
+      + "aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt\n"
+      + "VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat\n"
+      + "HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc\n"
+      + "agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt\n"
+      + "gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg\n"
+      + "agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg\n"
+      + "tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag\n"
+      + "gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga\n"
+      + "VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg\n"
+      + "tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV\n"
+      + "MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt\n"
+      + "actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa\n"
+      + "WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa\n"
+      + "tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD\n"
+      + "KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct\n"
+      + "BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac\n"
+      + "attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB\n"
+      + "VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD\n"
+      + "aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca\n"
+      + "tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat\n"
+      + "tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK\n"
+      + "tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt\n"
+      + "VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta\n"
+      + "tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat\n"
+      + "ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa\n"
+      + "tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg\n"
+      + "WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta\n"
+      + "tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc\n"
+      + "tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct\n"
+      + "MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat\n"
+      + "tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac\n"
+      + "atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg\n"
+      + "aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt\n"
+      + "aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa\n"
+      + ">THREE Homo sapiens frequency\n"
+      + "aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca\n"
+      + "tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg\n"
+      + "tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg\n"
+      + "gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc\n"
+      + "atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc\n"
+      + "cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt\n"
+      + "caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat\n"
+      + "tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt\n"
+      + "agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt\n"
+      + "ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt\n"
+      + "aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta\n"
+      + "ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat\n"
+      + "cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac\n"
+      + "gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa\n"
+      + "atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc\n"
+      + "ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta\n"
+      + "gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt\n"
+      + "aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt\n"
+      + "aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc\n"
+      + "atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac\n"
+      + "tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat\n"
+      + "cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc\n"
+      + "taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt\n"
+      + "taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt\n"
+      + "ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc\n"
+      + "acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct\n"
+      + "cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg\n"
+      + "tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt\n"
+      + "attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat\n"
+      + "cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga\n"
+      + "atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc\n"
+      + "accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag\n"
+      + "tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc\n"
+      + "acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag\n"
+      + "ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa\n"
+      + "gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc\n"
+      + "cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg\n"
+      + "aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca\n"
+      + "tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta\n"
+      + "atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac\n"
+      + "ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc\n"
+      + "gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat\n"
+      + "ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt\n"
+      + "gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata\n"
+      + "gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc\n"
+      + "atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga\n"
+      + "agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct\n"
+      + "aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac\n"
+      + "ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc\n"
+      + "tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa\n"
+      + "cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc\n"
+      + "gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga\n"
+      + "atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta\n"
+      + "ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca\n"
+      + "gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt\n"
+      + "acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga\n"
+      + "tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg\n"
+      + "ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc\n"
+      + "ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt\n"
+      + "acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat\n"
+      + "tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag\n"
+      + "tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga\n"
+      + "tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca\n"
+      + "aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg\n"
+      + "aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg\n"
+      + "actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt\n"
+      + "tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa\n"
+      + "gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag\n"
+      + "tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc\n"
+      + "attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt\n"
+      + "gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc\n"
+      + "atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact\n"
+      + "ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta\n"
+      + "aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt\n"
+      + "gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta\n"
+      + "taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga\n"
+      + "tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc\n"
+      + "gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca\n"
+      + "cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga\n"
+      + "ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac\n"
+      + "agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat\n"
+      + "aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt\n"
+      + "atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac\n"
+      + "actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa\n"
+      + "tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa\n"
+      + "ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta\n"
+      + "cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag\n"
+      + "ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc\n"
+      + "ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag\n"
+      + "cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag\n"
+      + "tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc\n"
+      + "agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat\n"
+      + "gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc\n"
+      + "gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca\n"
+      + "ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct\n"
+      + "acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga\n"
+      + "tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat\n"
+      + "tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg\n"
+      + "cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac\n"
+      + "cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata\n"
+      + "agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca\n"
+      + "aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg\n"
+      + "gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta\n"
+      + "atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg\n"
+      + "ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag\n"
+      + "acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta\n"
+      + "ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg\n"
+      + "gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc\n"
+      + "atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg\n"
+      + "actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg\n"
+      + "cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt\n"
+      + "cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa\n"
+      + "ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca\n"
+      + "tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta\n"
+      + "atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc\n"
+      + "acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct\n"
+      + "gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta\n"
+      + "ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc\n"
+      + "aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga\n"
+      + "taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa\n"
+      + "cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca\n"
+      + "tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta\n"
+      + "gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg\n"
+      + "gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag\n"
+      + "ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat\n"
+      + "tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta\n"
+      + "aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt\n"
+      + "aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc\n"
+      + "cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca\n"
+      + "acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta\n"
+      + "aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct\n"
+      + "cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa\n"
+      + "tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt\n"
+      + "cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat\n"
+      + "tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt\n"
+      + "taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg\n"
+      + "ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt\n"
+      + "taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc\n"
+      + "accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa\n"
+      + "ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg\n"
+      + "atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg\n"
+      + "taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga\n"
+      + "aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt\n"
+      + "attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt\n"
+      + "atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa\n"
+      + "attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa\n"
+      + "cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg\n"
+      + "agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt\n"
+      + "tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca\n"
+      + "aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa\n"
+      + "actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag\n"
+      + "tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta\n"
+      + "acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg\n"
+      + "tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat\n"
+      + "agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag\n"
+      + "ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat\n"
+      + "tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt\n"
+      + "attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta\n"
+      + "tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt\n"
+      + "ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt\n"
+      + "catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga\n"
+      + "caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc\n"
+      + "cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac\n"
+      + "accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca\n"
+      + "atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct\n"
+      + "tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct\n"
+      + "cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat\n"
+      + "gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca\n"
+      + "gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga\n"
+      + "agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca\n"
+      + "ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc\n"
+      + "ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa\n"
+      + "aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc\n"
+      + "ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga\n"
+      + "tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt\n"
+      + "taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg\n"
+      + "caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt\n"
+      + "tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc\n"
+      + "taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac\n"
+      + "gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca\n"
+      + "gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat\n"
+      + "aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt\n"
+      + "atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc\n"
+      + "gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat\n"
+      + "aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa\n"
+      + "aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga\n"
+      + "aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat\n"
+      + "ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc\n"
+      + "gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa\n"
+      + "acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac\n"
+      + "attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc\n"
+      + "gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag\n"
+      + "gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct\n"
+      + "gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata\n"
+      + "tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat\n"
+      + "ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata\n"
+      + "aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc\n"
+      + "tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat\n"
+      + "tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa\n"
+      + "ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt\n"
+      + "agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct\n"
+      + "cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt\n"
+      + "tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat\n"
+      + "tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc\n"
+      + "gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc\n"
+      + "tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg\n"
+      + "tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat\n"
+      + "atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag\n"
+      + "cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa\n"
+      + "ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt\n"
+      + "ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat\n"
+      + "atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc\n"
+      + "gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact\n"
+      + "tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag\n"
+      + "gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg\n"
+      + "atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag\n"
+      + "tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac\n"
+      + "ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag\n"
+      + "tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta\n"
+      + "aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt\n"
+      + "gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa\n"
+      + "ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc\n"
+      + "agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt\n"
+      + "agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat\n"
+      + "acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc\n"
+      + "cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct\n"
+      + "cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct\n"
+      + "cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa\n"
+      + "aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt\n"
+      + "tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt\n"
+      + "atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct\n"
+      + "cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga\n"
+      + "tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat\n"
+      + "catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc\n"
+      + "tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg\n"
+      + "caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc\n"
+      + "tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc\n"
+      + "aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag\n"
+      + "aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat\n"
+      + "ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac\n"
+      + "gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag\n"
+      + "ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt\n"
+      + "cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta\n"
+      + "gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca\n"
+      + "ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt\n"
+      + "cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg\n"
+      + "taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg\n"
+      + "gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc\n"
+      + "taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt\n"
+      + "ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt\n"
+      + "aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt\n"
+      + "gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta\n"
+      + "acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct\n"
+      + "ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta\n"
+      + "tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt\n"
+      + "tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg\n"
+      + "tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa\n"
+      + "ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac\n"
+      + "aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga\n"
+      + "tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca\n"
+      + "gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt\n"
+      + "gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc\n"
+      + "cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg\n"
+      + "actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa\n"
+      + "tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg\n"
+      + "ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt\n"
+      + "ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta\n"
+      + "agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc\n"
+      + "gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa\n"
+      + "tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt\n"
+      + "atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca\n"
+      + "cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa\n"
+      + "tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca\n"
+      + "gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg\n"
+      + "gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat\n"
+      + "aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg\n"
+      + "gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat\n"
+      + "cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa\n"
+      + "taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg\n"
+      + "tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt\n"
+      + "ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac\n"
+      + "aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc\n"
+      + "gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag\n"
+      + "aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc\n"
+      + "tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa\n"
+      + "tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata\n"
+      + "aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta\n"
+      + "ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc\n"
+      + "ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc\n"
+      + "caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct\n"
+      + "gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg\n"
+      + "cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc\n"
+      + "ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta\n"
+      + "tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg\n"
+      + "atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc\n"
+      + "ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc\n"
+      + "acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc\n"
+      + "taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga\n"
+      + "ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga\n"
+      + "aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat\n"
+      + "cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc\n"
+      + "tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact\n"
+      + "gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa\n"
+      + "aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag\n"
+      + "cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc\n"
+      + "cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa\n"
+      + "gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg\n"
+      + "cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg\n"
+      + "gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca\n"
+      + "agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac\n"
+      + "aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt\n"
+      + "aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg\n"
+      + "cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt\n"
+      + "agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg\n"
+      + "cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa\n"
+      + "agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga\n"
+      + "gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta\n"
+      + "aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata\n"
+      + "agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc\n"
+      + "cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc\n"
+      + "agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca\n"
+      + "ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga\n"
+      + "tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag\n"
+      + "gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat\n"
+      + "gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt\n"
+      + "ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg\n"
+      + "gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc\n"
+      + "atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc\n"
+      + "tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata\n"
+      + "ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg\n"
+      + "tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag\n"
+      + "cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg\n"
+      + "ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat\n"
+      + "aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg\n"
+      + "gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat\n"
+      + "ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag\n"
+      + "atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac\n"
+      + "aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct\n"
+      + "gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga\n"
+      + "atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt\n"
+      + "aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt\n"
+      + "tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg\n"
+      + "ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta\n"
+      + "gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac\n"
+      + "cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct\n"
+      + "ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga\n"
+      + "ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg\n"
+      + "ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat\n"
+      + "cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga\n"
+      + "tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt\n"
+      + "tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc\n"
+      + "cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt\n"
+      + "gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct\n"
+      + "ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt\n"
+      + "ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa\n"
+      + "tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc\n"
+      + "agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta\n"
+      + "ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc\n"
+      + "cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct\n"
+      + "agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc\n"
+      + "tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc\n"
+      + "gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga\n"
+      + "ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa\n"
+      + "ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca\n"
+      + "agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata\n"
+      + "attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact\n"
+      + "ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat\n"
+      + "agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat\n"
+      + "aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata\n"
+      + "gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta\n"
+      + "gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg\n"
+      + "ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac\n"
+      + "gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata\n"
+      + "ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat\n"
+      + "taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta\n"
+      + "aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata\n"
+      + "tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata\n"
+      + "ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga\n"
+      + "agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt\n"
+      + "ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt\n"
+      + "agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg\n"
+      + "gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa\n"
+      + "tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg\n"
+      + "gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct\n"
+      + "cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc\n"
+      + "ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta\n"
+      + "cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt\n"
+      + "gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc\n"
+      + "gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc\n"
+      + "tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt\n"
+      + "cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca\n"
+      + "aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac\n"
+      + "ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac\n"
+      + "gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag\n"
+      + "aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga\n"
+      + "gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct\n"
+      + "aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta\n"
+      + "gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat\n"
+      + "agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat\n"
+      + "caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta\n"
+      + "gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta\n"
+      + "aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt\n"
+      + "tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt\n"
+      + "tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc\n"
+      + "ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg\n"
+      + "ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg\n"
+      + "gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa\n"
+      + "ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa\n"
+      + "aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa\n"
+      + "tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat\n"
+      + "acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac\n"
+      + "atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga\n"
+      + "gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac\n"
+      + "tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc\n"
+      + "cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa\n"
+      + "gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg\n"
+      + "acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga\n"
+      + "acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga\n"
+      + "attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg\n"
+      + "tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt\n"
+      + "cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag\n"
+      + "aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac\n"
+      + "ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac\n"
+      + "tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat\n"
+      + "gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga\n"
+      + "gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc\n"
+      + "acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta\n"
+      + "gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac\n"
+      + "gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc\n"
+      + "ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt\n"
+      + "taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg\n"
+      + "agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa\n"
+      + "gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag\n"
+      + "ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc\n"
+      + "accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag\n"
+      + "tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact\n"
+      + "taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga\n"
+      + "catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat\n"
+      + "tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga\n"
+      + "ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg\n"
+      + "aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa\n"
+      + "atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa\n"
+      + "tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt\n"
+      + "ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact\n"
+      + "tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt\n"
+      + "aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat\n"
+      + "agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc\n"
+      + "acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc\n"
+      + "aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct\n"
+      + "ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat\n"
+      + "gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat\n"
+      + "taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata\n"
+      + "taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga\n"
+      + "tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat\n"
+      + "gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg\n"
+      + "ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa\n"
+      + "atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat\n"
+      + "tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat\n"
+      + "cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt\n"
+      + "aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac\n"
+      + "taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag\n"
+      + "caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata\n"
+      + "ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct\n"
+      + "tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac\n"
+      + "tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg\n"
+      + "gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta\n"
+      + "gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat\n"
+      + "gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg\n"
+      + "ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa\n"
+      + "tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa\n"
+      + "taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac\n"
+      + "gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt\n"
+      + "ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga\n"
+      + "gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca\n"
+      + "tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc\n"
+      + "ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt\n"
+      + "tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc\n"
+      + "cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat\n"
+      + "ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg\n"
+      + "caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg\n"
+      + "cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat\n"
+      + "gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat\n"
+      + "cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg\n"
+      + "taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat\n"
+      + "tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata\n"
+      + "taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc\n"
+      + "tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac\n"
+      + "tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt\n"
+      + "tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt\n"
+      + "ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt\n"
+      + "aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg\n"
+      + "atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga\n"
+      + "actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta\n"
+      + "gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga\n"
+      + "ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga\n"
+      + "gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct\n"
+      + "tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc\n"
+      + "aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta\n"
+      + "atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt\n"
+      + "catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc";
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/revcomp.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/revcomp.java
new file mode 100644
index 0000000..1508f4e
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/revcomp.java
@@ -0,0 +1,1127 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `revcomp/revcomp.java-4.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ * contributed by Anthony Donnefort
+ * slightly modified to read 82 bytes at a time by Razii
+ */
+
+/*
+ * Description:     Read DNA sequences - write their reverse-complement.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.io.*;
+
+// CHECKSTYLE.OFF: .*
+public class revcomp {
+   private ReversibleByteArray buf = new ReversibleByteArray();
+   InputStream stream = new ByteArrayInputStream(fastaStr.getBytes());
+   static final byte[] cmp = new byte[128];
+   static {
+      for (int i = 0; i < cmp.length; i++) cmp[i] = (byte) i;
+      cmp['t'] = cmp['T'] = 'A';
+      cmp['a'] = cmp['A'] = 'T';
+      cmp['g'] = cmp['G'] = 'C';
+      cmp['c'] = cmp['C'] = 'G';
+      cmp['v'] = cmp['V'] = 'B';
+      cmp['h'] = cmp['H'] = 'D';
+      cmp['r'] = cmp['R'] = 'Y';
+      cmp['m'] = cmp['M'] = 'K';
+      cmp['y'] = cmp['Y'] = 'R';
+      cmp['k'] = cmp['K'] = 'M';
+      cmp['b'] = cmp['B'] = 'V';
+      cmp['d'] = cmp['D'] = 'H';
+      cmp['u'] = cmp['U'] = 'A';
+   }
+
+   static class ReversibleByteArray extends java.io.ByteArrayOutputStream {
+      void reverse() throws Exception {
+         if (count > 0) {
+            int begin = 0, end = count - 1;
+            while (buf[begin++] != '\n');
+            while (begin <= end) {
+               if (buf[begin] == '\n') begin++;
+               if (buf[end] == '\n') end--;
+               if (begin <= end) {
+                  byte tmp = buf[begin];
+                  buf[begin++] = cmp[buf[end]];
+                  buf[end--] = cmp[tmp];
+               }
+            }
+         }
+      }
+   }
+
+   public void old_main() throws Exception {
+      byte[] line = new byte[82];
+      int read;
+      buf.reset();
+      stream.reset();
+
+      while ((read = stream.read(line)) != -1) {
+         int i = 0, last = 0;
+         while (i < read) {
+            if (line[i] == '>') {
+               buf.write(line, last, i - last);
+               buf.reverse();
+               buf.reset();
+               last = i;
+            }
+            i++;
+         }
+         buf.write(line, last, read - last);
+      }
+      buf.reverse();
+      stream.reset();
+   }
+   // CHECKSTYLE.ON: .*
+
+  public void timeRevComp(int iters) throws Exception {
+    for (int frameworkCount = 0; frameworkCount < iters; frameworkCount++) {
+      old_main();
+    }
+  }
+
+  public boolean verifyRevComp() throws Exception {
+    old_main();
+
+    int expected = 71;
+    int found = buf.toByteArray()[100];
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) throws Exception {
+    int rc = 0;
+    revcomp obj = new revcomp();
+
+    final long before = System.currentTimeMillis();
+    obj.timeRevComp(400);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyRevComp()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/revcomp: " + (after - before));
+    System.exit(rc);
+  }
+
+  private static final String fastaStr = ">ONE Homo sapiens alu\n"
+      + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\n"
+      + "TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\n"
+      + "AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\n"
+      + "GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\n"
+      + "CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\n"
+      + "GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\n"
+      + "GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\n"
+      + "TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\n"
+      + "AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\n"
+      + "GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT\n"
+      + "AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC\n"
+      + "AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG\n"
+      + "GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC\n"
+      + "CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG\n"
+      + "AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT\n"
+      + "TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA\n"
+      + "TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT\n"
+      + "GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG\n"
+      + "TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT\n"
+      + "CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG\n"
+      + "CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG\n"
+      + "TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA\n"
+      + "CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG\n"
+      + "AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG\n"
+      + "GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC\n"
+      + "TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA\n"
+      + "TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA\n"
+      + "GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT\n"
+      + "GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC\n"
+      + "ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT\n"
+      + "TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC\n"
+      + "CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG\n"
+      + "CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG\n"
+      + "GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC\n"
+      + "CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT\n"
+      + "GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC\n"
+      + "GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA\n"
+      + "GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA\n"
+      + "GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA\n"
+      + "GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG\n"
+      + "AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT\n"
+      + "CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA\n"
+      + "GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA\n"
+      + "AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC\n"
+      + "GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT\n"
+      + "ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG\n"
+      + "GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC\n"
+      + "GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC\n"
+      + "GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\n"
+      + "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA\n"
+      + "AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG\n"
+      + "GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT\n"
+      + "CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC\n"
+      + "TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG\n"
+      + "ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC\n"
+      + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA\n"
+      + "ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA\n"
+      + "CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA\n"
+      + "CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA\n"
+      + "ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG\n"
+      + "CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG\n"
+      + "AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC\n"
+      + "CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG\n"
+      + "AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC\n"
+      + "CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG\n"
+      + "CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG\n"
+      + "CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG\n"
+      + "CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC\n"
+      + "ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA\n"
+      + "AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC\n"
+      + "TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC\n"
+      + "ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG\n"
+      + "CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG\n"
+      + "AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT\n"
+      + "AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA\n"
+      + "TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC\n"
+      + "CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA\n"
+      + "TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG\n"
+      + "CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT\n"
+      + "GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG\n"
+      + "GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG\n"
+      + "CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\n"
+      + "GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG\n"
+      + "GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT\n"
+      + "AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT\n"
+      + "GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT\n"
+      + "CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG\n"
+      + "GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC\n"
+      + "TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT\n"
+      + "CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG\n"
+      + "ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG\n"
+      + "CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG\n"
+      + "AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA\n"
+      + "CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG\n"
+      + "CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC\n"
+      + "ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC\n"
+      + "GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC\n"
+      + "GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG\n"
+      + "GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT\n"
+      + "TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG\n"
+      + "CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA\n"
+      + "GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG\n"
+      + "CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC\n"
+      + "GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG\n"
+      + "CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA\n"
+      + "CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG\n"
+      + "CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA\n"
+      + "ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC\n"
+      + "CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT\n"
+      + "GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA\n"
+      + "AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG\n"
+      + "ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC\n"
+      + "TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA\n"
+      + "GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC\n"
+      + "GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG\n"
+      + "TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC\n"
+      + "AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA\n"
+      + "ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA\n"
+      + "GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\n"
+      + "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG\n"
+      + "TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC\n"
+      + "CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT\n"
+      + "GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC\n"
+      + "CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA\n"
+      + "GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT\n"
+      + "TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC\n"
+      + "ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC\n"
+      + "TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG\n"
+      + "GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG\n"
+      + "TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG\n"
+      + "GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC\n"
+      + "GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT\n"
+      + "ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC\n"
+      + "GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC\n"
+      + "GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC\n"
+      + "CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA\n"
+      + "ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG\n"
+      + "AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC\n"
+      + "TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT\n"
+      + "CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG\n"
+      + "TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG\n"
+      + "CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC\n"
+      + "GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT\n"
+      + "GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC\n"
+      + "CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC\n"
+      + "TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG\n"
+      + "CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\n"
+      + "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG\n"
+      + "AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG\n"
+      + "AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT\n"
+      + "GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA\n"
+      + "TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC\n"
+      + "AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA\n"
+      + "AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG\n"
+      + "CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC\n"
+      + "TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG\n"
+      + "GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT\n"
+      + "CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG\n"
+      + "CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG\n"
+      + "GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA\n"
+      + "AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA\n"
+      + "GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC\n"
+      + "TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC\n"
+      + "CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA\n"
+      + "GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\n"
+      + "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG\n"
+      + "AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG\n"
+      + "ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC\n"
+      + "ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC\n"
+      + "AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC\n"
+      + "GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG\n"
+      + "GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT\n"
+      + "CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC\n"
+      + "GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC\n"
+      + "CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\n"
+      + "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA\n"
+      + "GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG\n"
+      + "GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT\n"
+      + "CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA\n"
+      + "AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG\n"
+      + "CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC\n"
+      + "CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG\n"
+      + "GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG\n"
+      + "GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT\n"
+      + "TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA\n"
+      + "ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG\n"
+      + "CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA\n"
+      + "ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA\n"
+      + "GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG\n"
+      + "TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC\n"
+      + "GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA\n"
+      + "GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT\n"
+      + "GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT\n"
+      + "GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG\n"
+      + "TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT\n"
+      + "TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC\n"
+      + "TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC\n"
+      + "GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT\n"
+      + "CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC\n"
+      + "TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA\n"
+      + ">TWO IUB ambiguity codes\n"
+      + "cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg\n"
+      + "tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa\n"
+      + "NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt\n"
+      + "cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga\n"
+      + "gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa\n"
+      + "HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca\n"
+      + "tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt\n"
+      + "tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt\n"
+      + "acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct\n"
+      + "tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt\n"
+      + "gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa\n"
+      + "accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt\n"
+      + "RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt\n"
+      + "tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag\n"
+      + "cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg\n"
+      + "ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat\n"
+      + "actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg\n"
+      + "YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa\n"
+      + "KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata\n"
+      + "aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa\n"
+      + "aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg\n"
+      + "gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc\n"
+      + "tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK\n"
+      + "tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt\n"
+      + "ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg\n"
+      + "ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa\n"
+      + "BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt\n"
+      + "aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc\n"
+      + "tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc\n"
+      + "cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac\n"
+      + "aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga\n"
+      + "tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga\n"
+      + "aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD\n"
+      + "gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg\n"
+      + "ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV\n"
+      + "taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa\n"
+      + "ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat\n"
+      + "gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg\n"
+      + "gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa\n"
+      + "tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt\n"
+      + "tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt\n"
+      + "taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca\n"
+      + "cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag\n"
+      + "aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt\n"
+      + "cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt\n"
+      + "ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW\n"
+      + "attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag\n"
+      + "ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa\n"
+      + "attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc\n"
+      + "tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta\n"
+      + "aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata\n"
+      + "cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc\n"
+      + "gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg\n"
+      + "attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca\n"
+      + "BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga\n"
+      + "DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat\n"
+      + "tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM\n"
+      + "tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR\n"
+      + "tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg\n"
+      + "taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc\n"
+      + "aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc\n"
+      + "DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa\n"
+      + "VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt\n"
+      + "agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat\n"
+      + "gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt\n"
+      + "tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt\n"
+      + "catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt\n"
+      + "tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR\n"
+      + "aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat\n"
+      + "aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac\n"
+      + "acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS\n"
+      + "tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga\n"
+      + "aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM\n"
+      + "acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt\n"
+      + "RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt\n"
+      + "RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta\n"
+      + "tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac\n"
+      + "gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt\n"
+      + "YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc\n"
+      + "ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt\n"
+      + "ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat\n"
+      + "gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta\n"
+      + "KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD\n"
+      + "aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg\n"
+      + "gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH\n"
+      + "taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact\n"
+      + "VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV\n"
+      + "NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa\n"
+      + "MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag\n"
+      + "cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata\n"
+      + "ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg\n"
+      + "tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN\n"
+      + "aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc\n"
+      + "actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg\n"
+      + "tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga\n"
+      + "gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa\n"
+      + "BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca\n"
+      + "aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata\n"
+      + "aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat\n"
+      + "YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt\n"
+      + "aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW\n"
+      + "cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata\n"
+      + "tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata\n"
+      + "tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt\n"
+      + "MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac\n"
+      + "taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta\n"
+      + "tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS\n"
+      + "RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc\n"
+      + "agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata\n"
+      + "NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa\n"
+      + "gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata\n"
+      + "aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt\n"
+      + "ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW\n"
+      + "cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt\n"
+      + "tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa\n"
+      + "RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt\n"
+      + "tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD\n"
+      + "gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc\n"
+      + "tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta\n"
+      + "ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM\n"
+      + "tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc\n"
+      + "ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc\n"
+      + "BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt\n"
+      + "gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga\n"
+      + "acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag\n"
+      + "gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc\n"
+      + "taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat\n"
+      + "acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta\n"
+      + "tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt\n"
+      + "catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa\n"
+      + "tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB\n"
+      + "atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR\n"
+      + "ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta\n"
+      + "ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta\n"
+      + "cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK\n"
+      + "SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW\n"
+      + "VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc\n"
+      + "BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct\n"
+      + "NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt\n"
+      + "tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa\n"
+      + "ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa\n"
+      + "cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa\n"
+      + "VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR\n"
+      + "atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac\n"
+      + "aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc\n"
+      + "tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac\n"
+      + "RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag\n"
+      + "gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc\n"
+      + "tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact\n"
+      + "attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc\n"
+      + "atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga\n"
+      + "cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt\n"
+      + "NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR\n"
+      + "ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat\n"
+      + "cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg\n"
+      + "aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac\n"
+      + "agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR\n"
+      + "tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga\n"
+      + "ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg\n"
+      + "ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa\n"
+      + "tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag\n"
+      + "taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg\n"
+      + "tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN\n"
+      + "YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt\n"
+      + "ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa\n"
+      + "tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat\n"
+      + "ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg\n"
+      + "attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt\n"
+      + "atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW\n"
+      + "YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta\n"
+      + "gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV\n"
+      + "MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta\n"
+      + "tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt\n"
+      + "ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa\n"
+      + "aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa\n"
+      + "BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM\n"
+      + "tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK\n"
+      + "StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV\n"
+      + "cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN\n"
+      + "atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg\n"
+      + "atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg\n"
+      + "ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct\n"
+      + "gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM\n"
+      + "tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD\n"
+      + "BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc\n"
+      + "agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga\n"
+      + "HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR\n"
+      + "tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt\n"
+      + "aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa\n"
+      + "catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB\n"
+      + "aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat\n"
+      + "tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt\n"
+      + "cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag\n"
+      + "DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat\n"
+      + "gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta\n"
+      + "tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM\n"
+      + "atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc\n"
+      + "KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt\n"
+      + "tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata\n"
+      + "tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK\n"
+      + "taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt\n"
+      + "NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa\n"
+      + "HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa\n"
+      + "ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg\n"
+      + "tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK\n"
+      + "cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga\n"
+      + "ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca\n"
+      + "HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg\n"
+      + "gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS\n"
+      + "BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg\n"
+      + "gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat\n"
+      + "KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact\n"
+      + "cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat\n"
+      + "tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD\n"
+      + "taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM\n"
+      + "gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt\n"
+      + "aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat\n"
+      + "acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta\n"
+      + "RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc\n"
+      + "attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac\n"
+      + "KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS\n"
+      + "KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD\n"
+      + "gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB\n"
+      + "aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct\n"
+      + "aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga\n"
+      + "ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY\n"
+      + "tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga\n"
+      + "aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta\n"
+      + "tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY\n"
+      + "MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc\n"
+      + "cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta\n"
+      + "caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt\n"
+      + "ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc\n"
+      + "acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat\n"
+      + "tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc\n"
+      + "gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa\n"
+      + "atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga\n"
+      + "aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat\n"
+      + "NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt\n"
+      + "taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa\n"
+      + "aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat\n"
+      + "ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca\n"
+      + "DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata\n"
+      + "tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat\n"
+      + "aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa\n"
+      + "ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM\n"
+      + "ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca\n"
+      + "RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa\n"
+      + "aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac\n"
+      + "aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt\n"
+      + "aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK\n"
+      + "tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat\n"
+      + "atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR\n"
+      + "BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc\n"
+      + "gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct\n"
+      + "cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN\n"
+      + "RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat\n"
+      + "taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt\n"
+      + "aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt\n"
+      + "gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct\n"
+      + "gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa\n"
+      + "aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta\n"
+      + "gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg\n"
+      + "ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat\n"
+      + "MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct\n"
+      + "SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY\n"
+      + "aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt\n"
+      + "VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat\n"
+      + "HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc\n"
+      + "agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt\n"
+      + "gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg\n"
+      + "agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg\n"
+      + "tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag\n"
+      + "gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga\n"
+      + "VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg\n"
+      + "tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV\n"
+      + "MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt\n"
+      + "actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa\n"
+      + "WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa\n"
+      + "tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD\n"
+      + "KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct\n"
+      + "BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac\n"
+      + "attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB\n"
+      + "VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD\n"
+      + "aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca\n"
+      + "tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat\n"
+      + "tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK\n"
+      + "tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt\n"
+      + "VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta\n"
+      + "tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat\n"
+      + "ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa\n"
+      + "tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg\n"
+      + "WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta\n"
+      + "tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc\n"
+      + "tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct\n"
+      + "MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat\n"
+      + "tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac\n"
+      + "atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg\n"
+      + "aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt\n"
+      + "aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa\n"
+      + ">THREE Homo sapiens frequency\n"
+      + "aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca\n"
+      + "tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg\n"
+      + "tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg\n"
+      + "gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc\n"
+      + "atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc\n"
+      + "cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt\n"
+      + "caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat\n"
+      + "tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt\n"
+      + "agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt\n"
+      + "ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt\n"
+      + "aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta\n"
+      + "ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat\n"
+      + "cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac\n"
+      + "gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa\n"
+      + "atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc\n"
+      + "ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta\n"
+      + "gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt\n"
+      + "aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt\n"
+      + "aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc\n"
+      + "atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac\n"
+      + "tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat\n"
+      + "cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc\n"
+      + "taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt\n"
+      + "taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt\n"
+      + "ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc\n"
+      + "acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct\n"
+      + "cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg\n"
+      + "tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt\n"
+      + "attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat\n"
+      + "cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga\n"
+      + "atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc\n"
+      + "accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag\n"
+      + "tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc\n"
+      + "acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag\n"
+      + "ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa\n"
+      + "gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc\n"
+      + "cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg\n"
+      + "aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca\n"
+      + "tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta\n"
+      + "atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac\n"
+      + "ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc\n"
+      + "gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat\n"
+      + "ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt\n"
+      + "gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata\n"
+      + "gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc\n"
+      + "atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga\n"
+      + "agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct\n"
+      + "aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac\n"
+      + "ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc\n"
+      + "tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa\n"
+      + "cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc\n"
+      + "gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga\n"
+      + "atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta\n"
+      + "ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca\n"
+      + "gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt\n"
+      + "acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga\n"
+      + "tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg\n"
+      + "ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc\n"
+      + "ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt\n"
+      + "acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat\n"
+      + "tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag\n"
+      + "tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga\n"
+      + "tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca\n"
+      + "aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg\n"
+      + "aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg\n"
+      + "actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt\n"
+      + "tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa\n"
+      + "gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag\n"
+      + "tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc\n"
+      + "attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt\n"
+      + "gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc\n"
+      + "atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact\n"
+      + "ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta\n"
+      + "aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt\n"
+      + "gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta\n"
+      + "taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga\n"
+      + "tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc\n"
+      + "gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca\n"
+      + "cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga\n"
+      + "ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac\n"
+      + "agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat\n"
+      + "aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt\n"
+      + "atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac\n"
+      + "actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa\n"
+      + "tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa\n"
+      + "ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta\n"
+      + "cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag\n"
+      + "ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc\n"
+      + "ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag\n"
+      + "cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag\n"
+      + "tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc\n"
+      + "agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat\n"
+      + "gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc\n"
+      + "gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca\n"
+      + "ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct\n"
+      + "acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga\n"
+      + "tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat\n"
+      + "tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg\n"
+      + "cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac\n"
+      + "cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata\n"
+      + "agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca\n"
+      + "aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg\n"
+      + "gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta\n"
+      + "atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg\n"
+      + "ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag\n"
+      + "acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta\n"
+      + "ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg\n"
+      + "gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc\n"
+      + "atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg\n"
+      + "actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg\n"
+      + "cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt\n"
+      + "cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa\n"
+      + "ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca\n"
+      + "tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta\n"
+      + "atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc\n"
+      + "acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct\n"
+      + "gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta\n"
+      + "ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc\n"
+      + "aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga\n"
+      + "taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa\n"
+      + "cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca\n"
+      + "tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta\n"
+      + "gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg\n"
+      + "gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag\n"
+      + "ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat\n"
+      + "tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta\n"
+      + "aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt\n"
+      + "aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc\n"
+      + "cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca\n"
+      + "acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta\n"
+      + "aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct\n"
+      + "cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa\n"
+      + "tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt\n"
+      + "cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat\n"
+      + "tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt\n"
+      + "taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg\n"
+      + "ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt\n"
+      + "taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc\n"
+      + "accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa\n"
+      + "ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg\n"
+      + "atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg\n"
+      + "taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga\n"
+      + "aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt\n"
+      + "attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt\n"
+      + "atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa\n"
+      + "attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa\n"
+      + "cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg\n"
+      + "agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt\n"
+      + "tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca\n"
+      + "aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa\n"
+      + "actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag\n"
+      + "tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta\n"
+      + "acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg\n"
+      + "tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat\n"
+      + "agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag\n"
+      + "ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat\n"
+      + "tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt\n"
+      + "attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta\n"
+      + "tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt\n"
+      + "ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt\n"
+      + "catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga\n"
+      + "caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc\n"
+      + "cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac\n"
+      + "accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca\n"
+      + "atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct\n"
+      + "tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct\n"
+      + "cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat\n"
+      + "gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca\n"
+      + "gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga\n"
+      + "agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca\n"
+      + "ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc\n"
+      + "ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa\n"
+      + "aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc\n"
+      + "ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga\n"
+      + "tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt\n"
+      + "taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg\n"
+      + "caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt\n"
+      + "tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc\n"
+      + "taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac\n"
+      + "gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca\n"
+      + "gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat\n"
+      + "aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt\n"
+      + "atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc\n"
+      + "gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat\n"
+      + "aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa\n"
+      + "aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga\n"
+      + "aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat\n"
+      + "ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc\n"
+      + "gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa\n"
+      + "acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac\n"
+      + "attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc\n"
+      + "gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag\n"
+      + "gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct\n"
+      + "gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata\n"
+      + "tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat\n"
+      + "ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata\n"
+      + "aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc\n"
+      + "tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat\n"
+      + "tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa\n"
+      + "ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt\n"
+      + "agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct\n"
+      + "cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt\n"
+      + "tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat\n"
+      + "tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc\n"
+      + "gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc\n"
+      + "tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg\n"
+      + "tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat\n"
+      + "atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag\n"
+      + "cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa\n"
+      + "ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt\n"
+      + "ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat\n"
+      + "atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc\n"
+      + "gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact\n"
+      + "tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag\n"
+      + "gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg\n"
+      + "atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag\n"
+      + "tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac\n"
+      + "ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag\n"
+      + "tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta\n"
+      + "aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt\n"
+      + "gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa\n"
+      + "ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc\n"
+      + "agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt\n"
+      + "agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat\n"
+      + "acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc\n"
+      + "cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct\n"
+      + "cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct\n"
+      + "cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa\n"
+      + "aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt\n"
+      + "tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt\n"
+      + "atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct\n"
+      + "cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga\n"
+      + "tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat\n"
+      + "catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc\n"
+      + "tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg\n"
+      + "caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc\n"
+      + "tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc\n"
+      + "aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag\n"
+      + "aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat\n"
+      + "ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac\n"
+      + "gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag\n"
+      + "ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt\n"
+      + "cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta\n"
+      + "gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca\n"
+      + "ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt\n"
+      + "cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg\n"
+      + "taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg\n"
+      + "gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc\n"
+      + "taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt\n"
+      + "ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt\n"
+      + "aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt\n"
+      + "gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta\n"
+      + "acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct\n"
+      + "ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta\n"
+      + "tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt\n"
+      + "tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg\n"
+      + "tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa\n"
+      + "ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac\n"
+      + "aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga\n"
+      + "tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca\n"
+      + "gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt\n"
+      + "gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc\n"
+      + "cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg\n"
+      + "actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa\n"
+      + "tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg\n"
+      + "ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt\n"
+      + "ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta\n"
+      + "agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc\n"
+      + "gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa\n"
+      + "tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt\n"
+      + "atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca\n"
+      + "cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa\n"
+      + "tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca\n"
+      + "gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg\n"
+      + "gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat\n"
+      + "aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg\n"
+      + "gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat\n"
+      + "cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa\n"
+      + "taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg\n"
+      + "tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt\n"
+      + "ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac\n"
+      + "aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc\n"
+      + "gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag\n"
+      + "aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc\n"
+      + "tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa\n"
+      + "tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata\n"
+      + "aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta\n"
+      + "ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc\n"
+      + "ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc\n"
+      + "caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct\n"
+      + "gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg\n"
+      + "cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc\n"
+      + "ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta\n"
+      + "tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg\n"
+      + "atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc\n"
+      + "ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc\n"
+      + "acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc\n"
+      + "taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga\n"
+      + "ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga\n"
+      + "aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat\n"
+      + "cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc\n"
+      + "tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact\n"
+      + "gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa\n"
+      + "aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag\n"
+      + "cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc\n"
+      + "cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa\n"
+      + "gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg\n"
+      + "cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg\n"
+      + "gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca\n"
+      + "agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac\n"
+      + "aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt\n"
+      + "aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg\n"
+      + "cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt\n"
+      + "agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg\n"
+      + "cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa\n"
+      + "agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga\n"
+      + "gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta\n"
+      + "aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata\n"
+      + "agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc\n"
+      + "cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc\n"
+      + "agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca\n"
+      + "ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga\n"
+      + "tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag\n"
+      + "gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat\n"
+      + "gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt\n"
+      + "ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg\n"
+      + "gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc\n"
+      + "atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc\n"
+      + "tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata\n"
+      + "ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg\n"
+      + "tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag\n"
+      + "cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg\n"
+      + "ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat\n"
+      + "aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg\n"
+      + "gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat\n"
+      + "ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag\n"
+      + "atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac\n"
+      + "aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct\n"
+      + "gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga\n"
+      + "atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt\n"
+      + "aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt\n"
+      + "tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg\n"
+      + "ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta\n"
+      + "gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac\n"
+      + "cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct\n"
+      + "ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga\n"
+      + "ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg\n"
+      + "ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat\n"
+      + "cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga\n"
+      + "tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt\n"
+      + "tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc\n"
+      + "cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt\n"
+      + "gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct\n"
+      + "ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt\n"
+      + "ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa\n"
+      + "tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc\n"
+      + "agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta\n"
+      + "ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc\n"
+      + "cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct\n"
+      + "agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc\n"
+      + "tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc\n"
+      + "gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga\n"
+      + "ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa\n"
+      + "ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca\n"
+      + "agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata\n"
+      + "attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact\n"
+      + "ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat\n"
+      + "agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat\n"
+      + "aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata\n"
+      + "gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta\n"
+      + "gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg\n"
+      + "ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac\n"
+      + "gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata\n"
+      + "ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat\n"
+      + "taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta\n"
+      + "aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata\n"
+      + "tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata\n"
+      + "ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga\n"
+      + "agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt\n"
+      + "ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt\n"
+      + "agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg\n"
+      + "gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa\n"
+      + "tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg\n"
+      + "gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct\n"
+      + "cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc\n"
+      + "ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta\n"
+      + "cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt\n"
+      + "gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc\n"
+      + "gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc\n"
+      + "tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt\n"
+      + "cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca\n"
+      + "aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac\n"
+      + "ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac\n"
+      + "gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag\n"
+      + "aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga\n"
+      + "gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct\n"
+      + "aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta\n"
+      + "gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat\n"
+      + "agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat\n"
+      + "caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta\n"
+      + "gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta\n"
+      + "aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt\n"
+      + "tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt\n"
+      + "tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc\n"
+      + "ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg\n"
+      + "ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg\n"
+      + "gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa\n"
+      + "ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa\n"
+      + "aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa\n"
+      + "tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat\n"
+      + "acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac\n"
+      + "atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga\n"
+      + "gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac\n"
+      + "tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc\n"
+      + "cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa\n"
+      + "gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg\n"
+      + "acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga\n"
+      + "acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga\n"
+      + "attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg\n"
+      + "tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt\n"
+      + "cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag\n"
+      + "aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac\n"
+      + "ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac\n"
+      + "tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat\n"
+      + "gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga\n"
+      + "gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc\n"
+      + "acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta\n"
+      + "gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac\n"
+      + "gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc\n"
+      + "ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt\n"
+      + "taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg\n"
+      + "agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa\n"
+      + "gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag\n"
+      + "ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc\n"
+      + "accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag\n"
+      + "tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact\n"
+      + "taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga\n"
+      + "catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat\n"
+      + "tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga\n"
+      + "ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg\n"
+      + "aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa\n"
+      + "atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa\n"
+      + "tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt\n"
+      + "ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact\n"
+      + "tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt\n"
+      + "aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat\n"
+      + "agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc\n"
+      + "acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc\n"
+      + "aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct\n"
+      + "ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat\n"
+      + "gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat\n"
+      + "taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata\n"
+      + "taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga\n"
+      + "tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat\n"
+      + "gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg\n"
+      + "ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa\n"
+      + "atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat\n"
+      + "tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat\n"
+      + "cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt\n"
+      + "aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac\n"
+      + "taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag\n"
+      + "caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata\n"
+      + "ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct\n"
+      + "tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac\n"
+      + "tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg\n"
+      + "gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta\n"
+      + "gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat\n"
+      + "gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg\n"
+      + "ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa\n"
+      + "tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa\n"
+      + "taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac\n"
+      + "gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt\n"
+      + "ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga\n"
+      + "gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca\n"
+      + "tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc\n"
+      + "ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt\n"
+      + "tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc\n"
+      + "cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat\n"
+      + "ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg\n"
+      + "caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg\n"
+      + "cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat\n"
+      + "gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat\n"
+      + "cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg\n"
+      + "taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat\n"
+      + "tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata\n"
+      + "taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc\n"
+      + "tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac\n"
+      + "tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt\n"
+      + "tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt\n"
+      + "ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt\n"
+      + "aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg\n"
+      + "atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga\n"
+      + "actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta\n"
+      + "gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga\n"
+      + "ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga\n"
+      + "gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct\n"
+      + "tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc\n"
+      + "aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta\n"
+      + "atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt\n"
+      + "catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc";
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/spectralnorm.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/spectralnorm.java
new file mode 100644
index 0000000..e00a4b6
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/spectralnorm.java
@@ -0,0 +1,123 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and slightly
+ * modified to fit the benchmarking framework.
+ *
+ * The original file is `spectralnorm/spectralnorm.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Java novice Jarkko Miettinen
+ * modified ~3 lines of the original C#-version
+ * by Isaac Gouy
+ */
+
+ /*
+ * Description:     Eigenvalue using the power method.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat; 
+
+// CHECKSTYLE.OFF: .*
+public class spectralnorm
+{
+   
+   private static final NumberFormat formatter = new DecimalFormat("#.000000000");
+   
+   private final double Approximate(int n) {
+      // create unit vector
+      double[] u = new double[n];
+      for (int i=0; i<n; i++) u[i] =  1;
+      
+      // 20 steps of the power method
+      double[] v = new double[n];
+      for (int i=0; i<n; i++) v[i] = 0;
+      
+      for (int i=0; i<10; i++) {
+         MultiplyAtAv(n,u,v);
+         MultiplyAtAv(n,v,u);
+      }
+      
+      // B=AtA         A multiplied by A transposed
+      // v.Bv /(v.v)   eigenvalue of v
+      double vBv = 0, vv = 0;
+      for (int i=0; i<n; i++) {
+         vBv += u[i]*v[i];
+         vv  += v[i]*v[i];
+      }
+      
+      return Math.sqrt(vBv/vv);
+   }
+   
+   
+   /* return element i,j of infinite matrix A */
+   private final double A(int i, int j){
+      return 1.0/((i+j)*(i+j+1)/2 +i+1);
+   }
+   
+   /* multiply vector v by matrix A */
+   private final void MultiplyAv(int n, double[] v, double[] Av){
+      for (int i=0; i<n; i++){
+         Av[i] = 0;
+         for (int j=0; j<n; j++) Av[i] += A(i,j)*v[j];
+      }
+   }
+   
+   /* multiply vector v by matrix A transposed */
+   private final void MultiplyAtv(int n, double[] v, double[] Atv){
+      for (int i=0;i<n;i++){
+         Atv[i] = 0;
+         for (int j=0; j<n; j++) Atv[i] += A(j,i)*v[j];
+      }
+   }
+   
+   /* multiply vector v by matrix A and then by matrix A transposed */
+   private final void MultiplyAtAv(int n, double[] v, double[] AtAv){
+      double[] u = new double[n];
+      MultiplyAv(n,v,u);
+      MultiplyAtv(n,u,AtAv);
+   }
+   // CHECKSTYLE.ON: .*
+
+  private static final int APPROXIMATE_N = 100;
+
+  public boolean verifySpectralNorm() {
+    double expected = 1.2742199912349306;
+    double found = Approximate(APPROXIMATE_N);
+
+    if (Math.abs(expected - found) > 0.000000001) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public void timeSpectralNorm(int iters) {
+    for (int j = 0; j < iters; j++) {
+      Approximate(APPROXIMATE_N);
+    }
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    spectralnorm obj = new spectralnorm();
+
+    final long before = System.currentTimeMillis();
+    obj.timeSpectralNorm(100);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifySpectralNorm()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/spectralnorm: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/threadring.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/threadring.java
new file mode 100644
index 0000000..ad6f03f
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/benchmarksgame/threadring.java
@@ -0,0 +1,143 @@
+/*
+ * This benchmark has been ported from "The Computer Language Benchmarks Game" suite and
+ * significantly modified to fit the benchmarking framework.
+ *
+ * Originally the benchmark finished with 'System.exit(0)'. A new state of message "-1" was
+ * introduced to avoid this.
+ *
+ * The original file is `threadring/threadring.java-3.java` from the archive
+ * available at
+ * http://benchmarksgame.alioth.debian.org/download/benchmarksgame-sourcecode.zip.
+ * See LICENSE file in the same folder (BSD 3-clause)
+ *
+ * The Computer Language Benchmarks Game
+ * http://benchmarksgame.alioth.debian.org/
+ * contributed by Klaus Friedel
+ */
+
+/*
+ * Description:     Switch from thread to thread passing one token.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.benchmarksgame;
+
+import java.util.concurrent.locks.LockSupport;
+
+// CHECKSTYLE.OFF: .*
+public class threadring {
+// CHECKSTYLE.ON: .*
+  static final int THREAD_COUNT = 503;
+
+  private static String lastActedThreadName;
+
+  public static class MessageThread extends Thread {
+    MessageThread nextThread;
+    volatile Integer message;
+
+    public MessageThread(MessageThread nextThread, int name) {
+      super("" + name);
+      this.nextThread = nextThread;
+    }
+
+    public void run() {
+      Integer msg = dequeue();
+      while (nextThread.enqueue(msg)) {
+        msg = dequeue();
+        if (msg == -1) {
+          break;
+        }
+      }
+    }
+
+    public boolean enqueue(Integer hopsRemaining) {
+      if (hopsRemaining == 0) {
+        message = -1;
+        lastActedThreadName = this.getName();
+
+        // notify all the threads that transmission is over
+        LockSupport.unpark(this);
+        MessageThread current = nextThread;
+        while (current != this) {
+          current.message = -1;
+          LockSupport.unpark(current);
+          current = current.nextThread;
+        }
+
+        return false;
+      }
+
+      message = hopsRemaining - 1;
+      LockSupport.unpark(this);
+      return true;
+    }
+
+    private Integer dequeue() {
+      while (message == null) {
+        LockSupport.park();
+      }
+
+      Integer msg = message;
+      if (msg != -1) {
+        message = null;
+      }
+      return msg;
+    }
+  }
+
+  public void timeThreadRing(int iters) throws Exception {
+
+    for (int j = 0; j < iters; j++) {
+      int hopCount = 1000;
+
+      MessageThread first = null;
+      MessageThread last = null;
+      for (int i = THREAD_COUNT; i >= 1; i--) {
+        first = new MessageThread(first, i);
+        if (i == THREAD_COUNT) {
+          last = first;
+        }
+      }
+      // close the ring:
+      last.nextThread = first;
+
+      // start all Threads
+      MessageThread t = first;
+      do {
+        t.start();
+        t = t.nextThread;
+      } while (t != first);
+
+      first.enqueue(hopCount);
+      first.join(); // wait for System.exit
+    }
+  }
+
+  public boolean verifyThreadRing() throws Exception {
+    timeThreadRing(1);
+    String expected = "498";
+    String found = lastActedThreadName;
+
+    if (!expected.equals(found)) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) throws Exception {
+    int rc = 0;
+    threadring obj = new threadring();
+
+    final long before = System.currentTimeMillis();
+    obj.timeThreadRing(2);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyThreadRing()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/benchmarksgame/threadring: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/FloatAtom.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/FloatAtom.java
new file mode 100644
index 0000000..065f7ab
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/FloatAtom.java
@@ -0,0 +1,209 @@
+/*
+ * This benchmark has been ported from "Caffeinemark" benchmark suite and
+ * slightly modified: Custom version of Math library (FMath) were replaced by
+ * default one.
+ *
+ * This software is available under multiple licenses at
+ * https://community.cablelabs.com/svn/OCAPRI/trunk/ri/RI_Stack/apps/vm_perf_test/src/com/tvworks/plateval/caffeinemark/FloatAtom.java
+ * and we redistribute it under the BSD 2-clause License
+ */
+
+ // COPYRIGHT_BEGIN
+ //  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
+ //
+ //  Copyright (C) 2008-2013, Cable Television Laboratories, Inc.
+ //
+ //  This software is available under multiple licenses:
+ //
+ //  (1) BSD 2-clause
+ //   Redistribution and use in source and binary forms, with or without modification, are
+ //   permitted provided that the following conditions are met:
+ //        .Redistributions of source code must retain the above copyright notice, this list
+ //             of conditions and the following disclaimer.
+ //        .Redistributions in binary form must reproduce the above copyright notice, this list of
+ //             conditions and the following disclaimer in the documentation and/or other materials
+ //             provided with the distribution.
+ //   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ //   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ //   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ //   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ //   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ //   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ //   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ //   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ //   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ //   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ //   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ //
+ //  (2) GPL Version 2
+ //   This program is free software; you can redistribute it and/or modify
+ //   it under the terms of the GNU General Public License as published by
+ //   the Free Software Foundation, version 2. This program is distributed
+ //   in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ //   even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ //   PURPOSE. See the GNU General Public License for more details.
+ //
+ //   You should have received a copy of the GNU General Public License along
+ //   with this program.If not, see<http:www.gnu.org/licenses/>.
+ //
+ //  (3)CableLabs License
+ //   If you or the company you represent has a separate agreement with CableLabs
+ //   concerning the use of this code, your rights and obligations with respect
+ //   to this code shall be as set forth therein. No license is granted hereunder
+ //   for any other purpose.
+ //
+ //   Please contact CableLabs if you need additional information or
+ //   have any questions.
+ //
+ //       CableLabs
+ //       858 Coal Creek Cir
+ //       Louisville, CO 80027-9750
+ //       303 661-9100
+ // COPYRIGHT_END
+
+/*
+ * Description:     Simulates a 3D rotation of objects around a point.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.caffeinemark;
+
+import java.lang.Math;
+
+// TODO: check that disassemble of the 'execute' is similar to the original benchmark's one.
+// CHECKSTYLE.OFF: .*
+public class FloatAtom
+{
+    public boolean initialize(int i)
+    {
+        if(i != 0)
+            wMaxDegrees = i;
+        xA = new float[3][3];
+        vA = new float[3][20];
+        vB = new float[3][20];
+        int j = 0;
+        do
+        {
+            vA[0][j] = j;
+            vA[1][j] = -j;
+            vA[2][j] = (float)j * 3.1415926535897931F;
+        } while(++j < 20);
+        return true;
+    }
+
+    public FloatAtom()
+    {
+        wMaxDegrees = 185;
+    }
+
+    public int execute()
+    {
+        int j;
+        for(j = 0; j < wMaxDegrees; j += 5)
+        {
+            float d = ((float)(float)j * 3.1415926535897931F) / 180F;
+            float d1 = (float)Math.sin(d);
+            float d2 = (float)Math.cos(d);
+            xA[0][0] = d2;
+            xA[1][0] = d1;
+            xA[2][0] = 0.0F;
+            xA[0][1] = -d1;
+            xA[1][1] = d2;
+            xA[2][1] = 0.0F;
+            xA[0][2] = 0.0F;
+            xA[1][2] = 0.0F;
+            xA[2][2] = 1.0F;
+            int i = 0;
+            do
+            {
+                vB[0][i] = 0.0F;
+                vB[1][i] = 0.0F;
+                vB[2][i] = 0.0F;
+                int l = 0;
+                do
+                {
+                    int k = 0;
+                    do
+                        vB[l][i] = vB[l][i] + xA[k][l] * vB[l][i];
+                    while(++k < 3);
+                } while(++l < 3);
+            } while(++i < 20);
+        }
+
+        return j;
+    }
+
+    public String testName()
+    {
+        return new String("Float");
+    }
+
+    public void setLocal()
+    {
+    }
+
+    public int cleanUp()
+    {
+        return 0;
+    }
+
+    public int defaultMagnification()
+    {
+        return 4449;
+    }
+
+    public void setRemote()
+    {
+    }
+
+    public float xA[][];
+    public float xB[][];
+    public float vA[][];
+    public float vB[][];
+    public int wMaxDegrees;
+    public final int POINTCOUNT = 20;
+    // CHECKSTYLE.ON: .*
+
+  private static int PREDEFINED_MAX_DEGREES = 10000;
+
+  public void timeFloatAtom(int iters) {
+    initialize(PREDEFINED_MAX_DEGREES);
+    for (int i = 0; i < iters; i++) {
+      execute();
+    }
+  }
+
+  public boolean verifyFloatAtom() {
+    initialize(PREDEFINED_MAX_DEGREES);
+    execute();
+    float sum = 0.0F;
+    for (int i = 0; i < 20; i++) {
+      sum += vB[0][i] + vB[1][i] + vB[2][i];
+    }
+
+    float expected = 0.0f;
+    float found = sum;
+
+    if (Math.abs(expected - found) > 0.000000001) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] argv) {
+    int rc = 0;
+    FloatAtom obj = new FloatAtom();
+
+    final long before = System.currentTimeMillis();
+    obj.timeFloatAtom(100);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyFloatAtom()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/caffeinemark/FloatAtom: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/LogicAtom.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/LogicAtom.java
new file mode 100644
index 0000000..f4f2c7f
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/LogicAtom.java
@@ -0,0 +1,222 @@
+/*
+ * This software is available under multiple licenses at
+ * https://community.cablelabs.com/svn/OCAPRI/trunk/ri/RI_Stack/apps/vm_perf_test/src/com/tvworks/plateval/caffeinemark/LogicAtom.java
+ * and we redistribute it under the BSD 2-clause License
+ */
+
+ // COPYRIGHT_BEGIN
+ //  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
+ //
+ //  Copyright (C) 2008-2013, Cable Television Laboratories, Inc.
+ //
+ //  This software is available under multiple licenses:
+ //
+ //  (1) BSD 2-clause
+ //   Redistribution and use in source and binary forms, with or without modification, are
+ //   permitted provided that the following conditions are met:
+ //        .Redistributions of source code must retain the above copyright notice, this list
+ //             of conditions and the following disclaimer.
+ //        .Redistributions in binary form must reproduce the above copyright notice, this list of
+ //             conditions and the following disclaimer in the documentation and/or other materials
+ //             provided with the distribution.
+ //   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ //   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ //   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ //   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ //   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ //   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ //   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ //   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ //   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ //   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ //   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ //
+ //  (2) GPL Version 2
+ //   This program is free software; you can redistribute it and/or modify
+ //   it under the terms of the GNU General Public License as published by
+ //   the Free Software Foundation, version 2. This program is distributed
+ //   in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ //   even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ //   PURPOSE. See the GNU General Public License for more details.
+ //
+ //   You should have received a copy of the GNU General Public License along
+ //   with this program.If not, see<http:www.gnu.org/licenses/>.
+ //
+ //  (3)CableLabs License
+ //   If you or the company you represent has a separate agreement with CableLabs
+ //   concerning the use of this code, your rights and obligations with respect
+ //   to this code shall be as set forth therein. No license is granted hereunder
+ //   for any other purpose.
+ //
+ //   Please contact CableLabs if you need additional information or
+ //   have any questions.
+ //
+ //       CableLabs
+ //       858 Coal Creek Cir
+ //       Louisville, CO 80027-9750
+ //       303 661-9100
+ // COPYRIGHT_END
+
+/*
+ * Description:     Tests the speed with which the virtual machine executes decision-making
+ *                  instructions.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.caffeinemark;
+
+// TODO: investigate very short time of execution of host.
+// CHECKSTYLE.OFF: .*
+public class LogicAtom
+{
+    public boolean initialize(int i)
+    {
+        if(i != 0)
+            wIterationCount = i;
+        return true;
+    }
+
+    public int execute()
+    {
+        boolean flag7 = true;
+        boolean flag8 = true;
+        boolean flag9 = true;
+        boolean flag10 = true;
+        boolean flag11 = true;
+        boolean flag12 = true;
+        boolean flag6 = true;
+        boolean flag = true;
+        boolean flag1 = true;
+        boolean flag2 = true;
+        boolean flag3 = true;
+        boolean flag4 = true;
+        boolean flag5 = true;
+        flag7 = true;
+        flag8 = true;
+        flag9 = true;
+        flag10 = true;
+        flag11 = true;
+        flag12 = true;
+        for(int i = 0; i < wIterationCount; i++)
+            if((flag || flag1) && (flag2 || flag3) && (flag4 || flag5 || flag6))
+            {
+                flag7 = !flag7;
+                flag8 = !flag8;
+                flag9 = !flag9;
+                flag10 = !flag10;
+                flag11 = !flag11;
+                flag12 = !flag12;
+                flag = !flag;
+                flag1 = !flag1;
+                flag2 = !flag2;
+                flag3 = !flag3;
+                flag4 = !flag4;
+                flag5 = !flag5;
+                flag = !flag;
+                flag1 = !flag1;
+                flag2 = !flag2;
+                flag3 = !flag3;
+                flag4 = !flag4;
+                flag5 = !flag5;
+            }
+
+        flag = true;
+        flag1 = false;
+        flag2 = true;
+        flag3 = false;
+        flag4 = true;
+        flag5 = false;
+        for(int j = 0; j < wIterationCount; j++)
+            if((flag || flag1) && (flag2 || flag3) && (flag4 || flag5 || flag6))
+            {
+                flag = !flag;
+                flag1 = !flag1;
+                flag2 = !flag2;
+                flag3 = !flag3;
+                flag4 = !flag4;
+                flag5 = !flag5;
+                flag7 = !flag7;
+                flag8 = !flag8;
+                flag9 = !flag9;
+                flag10 = !flag10;
+                flag11 = !flag11;
+                flag12 = !flag12;
+                flag7 = !flag7;
+                flag8 = !flag8;
+                flag9 = !flag9;
+                flag10 = !flag10;
+                flag11 = !flag11;
+                flag12 = !flag12;
+            }
+
+        return !flag7 ? 1 : 0;
+    }
+
+    public String testName()
+    {
+        return new String("Logic");
+    }
+
+    public LogicAtom()
+    {
+        wIterationCount = 1200;
+    }
+
+    public void setLocal()
+    {
+    }
+
+    public int cleanUp()
+    {
+        return 0;
+    }
+
+    public int defaultMagnification()
+    {
+        return 3813;
+    }
+
+    public void setRemote()
+    {
+    }
+
+    public int wIterationCount;
+    // CHECKSTYLE.ON: .*
+
+  private static int PREDEFINED_ITERATION_COUNT = 500000;
+
+  public void timeLogicAtom(int iters) {
+    initialize(PREDEFINED_ITERATION_COUNT);
+    for (int i = 0; i < iters; i++) {
+      execute();
+    }
+  }
+
+  public boolean verifyLogicAtom() {
+    initialize(PREDEFINED_ITERATION_COUNT);
+    int expected = 0;
+    int found = execute();
+
+    if (found != expected) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] argv) {
+    int rc = 0;
+    LogicAtom obj = new LogicAtom();
+
+    final long before = System.currentTimeMillis();
+    obj.timeLogicAtom(80);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyLogicAtom()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/caffeinemark/LogicAtom: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/LoopAtom.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/LoopAtom.java
new file mode 100644
index 0000000..076b66d
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/LoopAtom.java
@@ -0,0 +1,181 @@
+/*
+ * This software is available under multiple licenses at
+ * https://community.cablelabs.com/svn/OCAPRI/trunk/ri/RI_Stack/apps/vm_perf_test/src/com/tvworks/plateval/caffeinemark/LoopAtom.java
+ * and we redistribute it under the BSD 2-clause License
+ */
+
+ // COPYRIGHT_BEGIN
+ //  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
+ //
+ //  Copyright (C) 2008-2013, Cable Television Laboratories, Inc.
+ //
+ //  This software is available under multiple licenses:
+ //
+ //  (1) BSD 2-clause
+ //   Redistribution and use in source and binary forms, with or without modification, are
+ //   permitted provided that the following conditions are met:
+ //        .Redistributions of source code must retain the above copyright notice, this list
+ //             of conditions and the following disclaimer.
+ //        .Redistributions in binary form must reproduce the above copyright notice, this list of
+ //             conditions and the following disclaimer in the documentation and/or other materials
+ //             provided with the distribution.
+ //   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ //   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ //   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ //   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ //   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ //   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ //   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ //   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ //   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ //   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ //   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ //
+ //  (2) GPL Version 2
+ //   This program is free software; you can redistribute it and/or modify
+ //   it under the terms of the GNU General Public License as published by
+ //   the Free Software Foundation, version 2. This program is distributed
+ //   in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ //   even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ //   PURPOSE. See the GNU General Public License for more details.
+ //
+ //   You should have received a copy of the GNU General Public License along
+ //   with this program.If not, see<http:www.gnu.org/licenses/>.
+ //
+ //  (3)CableLabs License
+ //   If you or the company you represent has a separate agreement with CableLabs
+ //   concerning the use of this code, your rights and obligations with respect
+ //   to this code shall be as set forth therein. No license is granted hereunder
+ //   for any other purpose.
+ //
+ //   Please contact CableLabs if you need additional information or
+ //   have any questions.
+ //
+ //       CableLabs
+ //       858 Coal Creek Cir
+ //       Louisville, CO 80027-9750
+ //       303 661-9100
+ // COPYRIGHT_END
+
+/*
+ * Description:     The loop test uses sorting and sequence generation as to measure compiler
+ *                  optimization of loops.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.caffeinemark;
+
+// CHECKSTYLE.OFF: .*
+public class LoopAtom
+{
+    public boolean initialize(int i)
+    {
+        if(i != 0)
+            FIBCOUNT = i;
+        fibs = new int[FIBCOUNT];
+        return true;
+    }
+
+    public int execute()
+    {
+        fibs[0] = 1;
+        for(int i = 1; i < FIBCOUNT; i++)
+            fibs[i] = fibs[i - 1] + i;
+
+        int j1 = 0;
+        int k1 = 0;
+        for(int j = 0; j < FIBCOUNT; j++)
+        {
+            for(int k = 1; k < FIBCOUNT; k++)
+            {
+                int l = FIBCOUNT + dummy;
+                j1 += l;
+                k1 += 2;
+                if(fibs[k - 1] < fibs[k])
+                {
+                    int i1 = fibs[k - 1];
+                    fibs[k - 1] = fibs[k];
+                    fibs[k] = i1;
+                }
+            }
+
+        }
+
+        sum1 = j1;
+        sum2 = k1;
+        return fibs[0];
+    }
+
+    public String testName()
+    {
+        return new String("Loop");
+    }
+
+    public LoopAtom()
+    {
+        dummy = 12;
+        FIBCOUNT = 64;
+    }
+
+    public void setLocal()
+    {
+    }
+
+    public int cleanUp()
+    {
+        return 0;
+    }
+
+    public int defaultMagnification()
+    {
+        return 2692;
+    }
+
+    public void setRemote()
+    {
+    }
+
+    public int dummy;
+    public int FIBCOUNT;
+    public int sum1;
+    public int sum2;
+    public int fibs[];
+    // CHECKSTYLE.ON: .*
+
+  private static int PREDEFINED_FIB_COUNT = 1000;
+
+  public void timeLoopAtom(int iters) {
+    initialize(PREDEFINED_FIB_COUNT);
+    for (int i = 0; i < iters; i++) {
+      execute();
+    }
+  }
+
+  public boolean verifyLoopAtom() {
+    initialize(PREDEFINED_FIB_COUNT);
+    int expected = 499501;
+    int found = execute();
+
+    if (found != expected) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] argv) {
+    int rc = 0;
+    LoopAtom obj = new LoopAtom();
+
+    final long before = System.currentTimeMillis();
+    obj.timeLoopAtom(120);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyLoopAtom()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/caffeinemark/LoopAtom: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/MethodAtom.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/MethodAtom.java
new file mode 100644
index 0000000..9372036
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/MethodAtom.java
@@ -0,0 +1,185 @@
+/*
+ * This software is available under multiple licenses at
+ * https://community.cablelabs.com/svn/OCAPRI/trunk/ri/RI_Stack/apps/vm_perf_test/src/com/tvworks/plateval/caffeinemark/MethodAtom.java
+ * and we redistribute it under the BSD 2-clause License
+ */
+
+ // COPYRIGHT_BEGIN
+ //  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
+ //
+ //  Copyright (C) 2008-2013, Cable Television Laboratories, Inc.
+ //
+ //  This software is available under multiple licenses:
+ //
+ //  (1) BSD 2-clause
+ //   Redistribution and use in source and binary forms, with or without modification, are
+ //   permitted provided that the following conditions are met:
+ //        .Redistributions of source code must retain the above copyright notice, this list
+ //             of conditions and the following disclaimer.
+ //        .Redistributions in binary form must reproduce the above copyright notice, this list of
+ //             conditions and the following disclaimer in the documentation and/or other materials
+ //             provided with the distribution.
+ //   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ //   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ //   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ //   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ //   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ //   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ //   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ //   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ //   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ //   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ //   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ //
+ //  (2) GPL Version 2
+ //   This program is free software; you can redistribute it and/or modify
+ //   it under the terms of the GNU General Public License as published by
+ //   the Free Software Foundation, version 2. This program is distributed
+ //   in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ //   even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ //   PURPOSE. See the GNU General Public License for more details.
+ //
+ //   You should have received a copy of the GNU General Public License along
+ //   with this program.If not, see<http:www.gnu.org/licenses/>.
+ //
+ //  (3)CableLabs License
+ //   If you or the company you represent has a separate agreement with CableLabs
+ //   concerning the use of this code, your rights and obligations with respect
+ //   to this code shall be as set forth therein. No license is granted hereunder
+ //   for any other purpose.
+ //
+ //   Please contact CableLabs if you need additional information or
+ //   have any questions.
+ //
+ //       CableLabs
+ //       858 Coal Creek Cir
+ //       Louisville, CO 80027-9750
+ //       303 661-9100
+ // COPYRIGHT_END
+
+/*
+ * Description:     The Method test executes recursive function calls to see how well the VM handles
+ *                  method calls.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.caffeinemark;
+
+// CHECKSTYLE.OFF: .*
+public class MethodAtom
+{
+
+    public MethodAtom()
+    {
+        wIterationCount = 100;
+    }
+
+    public int arithmeticSeries(int i)
+    {
+        if(i == 0)
+            return 0;
+        else
+            return i + arithmeticSeries(i - 1);
+    }
+
+    public boolean initialize(int i)
+    {
+        if(i != 0)
+            wIterationCount = i;
+        return true;
+    }
+
+    public int execute()
+    {
+        int j = 0;
+        for(int i = 0; i < wIterationCount; i++)
+        {
+            int k = arithmeticSeries(i);
+            int l = notInlineableSeries(i);
+            if(k > l)
+                j += l;
+            else
+                j += k;
+        }
+
+        return j;
+    }
+
+    public String testName()
+    {
+        return new String("Method");
+    }
+
+    public void setLocal()
+    {
+    }
+
+    public int cleanUp()
+    {
+        return 0;
+    }
+
+    public int defaultMagnification()
+    {
+        return 3728;
+    }
+
+    public int notInlineableSeries(int i)
+    {
+        int j = i;
+        depthCount++;
+        if(i == 0)
+            return j;
+        if((j & 1) != 0)
+            j += notInlineableSeries(i - 1);
+        else
+            j += 1 + notInlineableSeries(i - 1);
+        return j;
+    }
+
+    public void setRemote()
+    {
+    }
+
+    public int depthCount;
+    public int wIterationCount;
+    // CHECKSTYLE.ON: .*
+
+  private static int PREDEFINED_ITER_COUNT = 2000;
+
+  public void timeMethodAtom(int iters) {
+    initialize(PREDEFINED_ITER_COUNT);
+    for (int i = 0; i < iters; i++) {
+      execute();
+    }
+  }
+
+  public boolean verifyMethodAtom() {
+    initialize(PREDEFINED_ITER_COUNT);
+    int expected = 1333333000;
+    int found = execute();
+
+    if (found != expected) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] argv) {
+    int rc = 0;
+    MethodAtom obj = new MethodAtom();
+
+    final long before = System.currentTimeMillis();
+    obj.timeMethodAtom(9);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyMethodAtom()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/caffeinemark/MethodAtom: " + (after - before));
+    System.exit(rc);
+  }
+
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/SieveAtom.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/SieveAtom.java
new file mode 100644
index 0000000..2b23453
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/SieveAtom.java
@@ -0,0 +1,172 @@
+/*
+ * This software is available under multiple licenses at
+ * https://community.cablelabs.com/svn/OCAPRI/trunk/ri/RI_Stack/apps/vm_perf_test/src/com/tvworks/plateval/caffeinemark/SieveAtom.java
+ * and we redistribute it under the BSD 2-clause License
+ */
+
+ // COPYRIGHT_BEGIN
+ //  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
+ //
+ //  Copyright (C) 2008-2013, Cable Television Laboratories, Inc.
+ //
+ //  This software is available under multiple licenses:
+ //
+ //  (1) BSD 2-clause
+ //   Redistribution and use in source and binary forms, with or without modification, are
+ //   permitted provided that the following conditions are met:
+ //        .Redistributions of source code must retain the above copyright notice, this list
+ //             of conditions and the following disclaimer.
+ //        .Redistributions in binary form must reproduce the above copyright notice, this list of
+ //             conditions and the following disclaimer in the documentation and/or other materials
+ //             provided with the distribution.
+ //   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ //   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ //   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ //   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ //   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ //   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ //   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ //   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ //   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ //   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ //   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ //
+ //  (2) GPL Version 2
+ //   This program is free software; you can redistribute it and/or modify
+ //   it under the terms of the GNU General Public License as published by
+ //   the Free Software Foundation, version 2. This program is distributed
+ //   in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ //   even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ //   PURPOSE. See the GNU General Public License for more details.
+ //
+ //   You should have received a copy of the GNU General Public License along
+ //   with this program.If not, see<http:www.gnu.org/licenses/>.
+ //
+ //  (3)CableLabs License
+ //   If you or the company you represent has a separate agreement with CableLabs
+ //   concerning the use of this code, your rights and obligations with respect
+ //   to this code shall be as set forth therein. No license is granted hereunder
+ //   for any other purpose.
+ //
+ //   Please contact CableLabs if you need additional information or
+ //   have any questions.
+ //
+ //       CableLabs
+ //       858 Coal Creek Cir
+ //       Louisville, CO 80027-9750
+ //       303 661-9100
+ // COPYRIGHT_END
+
+/*
+ * Description:     The classic sieve of eratosthenes finds prime numbers.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.caffeinemark;
+
+// CHECKSTYLE.OFF: .*
+public class SieveAtom
+{
+
+    public SieveAtom()
+    {
+        wMaxCandidate = 512;
+    }
+
+    public boolean initialize(int i)
+    {
+        if(i != 0)
+            wMaxCandidate = i;
+        wPrimes = new int[wMaxCandidate];
+        return true;
+    }
+
+    public int execute()
+    {
+        int j = 1;
+        boolean flag1 = false;
+        wPrimes[0] = 1;
+        wPrimes[1] = 2;
+        j = 2;
+        for(int i = 3; i < wMaxCandidate; i++)
+        {
+            int k = 1;
+            boolean flag;
+            for(flag = true; k < j && flag; k++)
+                if(wPrimes[k] > 0 && wPrimes[k] <= i / 2 && i % wPrimes[k] == 0)
+                    flag = false;
+
+            if(flag)
+            {
+                j++;
+                wPrimes[j - 1] = i;
+            }
+        }
+
+        return j;
+    }
+
+    public String testName()
+    {
+        return new String("Sieve");
+    }
+
+    public void setLocal()
+    {
+    }
+
+    public int cleanUp()
+    {
+        return 0;
+    }
+
+    public int defaultMagnification()
+    {
+        return 2771;
+    }
+
+    public void setRemote()
+    {
+    }
+
+    public int wPrimes[];
+    public int wMaxCandidate;
+    // CHECKSTYLE.ON: .*
+
+  private static int PREDEFINED_MAX_CANDIDATE = 10000;
+
+  public void timeSieveAtom(int iters) {
+    initialize(PREDEFINED_MAX_CANDIDATE);
+    for (int i = 0; i < iters; i++) {
+      execute();
+    }
+  }
+
+  public boolean verifySieveAtom() {
+    initialize(PREDEFINED_MAX_CANDIDATE);
+    int expected = 1230;
+    int found = execute();
+
+    if (found != expected) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] argv) {
+    int rc = 0;
+    SieveAtom obj = new SieveAtom();
+
+    final long before = System.currentTimeMillis();
+    obj.timeSieveAtom(90);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifySieveAtom()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/caffeinemark/SieveAtom: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/StringAtom.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/StringAtom.java
new file mode 100644
index 0000000..8ebe0cd
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/caffeinemark/StringAtom.java
@@ -0,0 +1,168 @@
+/*
+ * This software is available under multiple licenses at
+ * https://community.cablelabs.com/svn/OCAPRI/trunk/ri/RI_Stack/apps/vm_perf_test/src/com/tvworks/plateval/caffeinemark/StringAtom.java
+ * and we redistribute it under the BSD 2-clause License
+ */
+
+ // COPYRIGHT_BEGIN
+ //  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
+ //
+ //  Copyright (C) 2008-2013, Cable Television Laboratories, Inc.
+ //
+ //  This software is available under multiple licenses:
+ //
+ //  (1) BSD 2-clause
+ //   Redistribution and use in source and binary forms, with or without modification, are
+ //   permitted provided that the following conditions are met:
+ //        .Redistributions of source code must retain the above copyright notice, this list
+ //             of conditions and the following disclaimer.
+ //        .Redistributions in binary form must reproduce the above copyright notice, this list of
+ //             conditions and the following disclaimer in the documentation and/or other materials
+ //             provided with the distribution.
+ //   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ //   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ //   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ //   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ //   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ //   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ //   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ //   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ //   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ //   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ //   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ //
+ //  (2) GPL Version 2
+ //   This program is free software; you can redistribute it and/or modify
+ //   it under the terms of the GNU General Public License as published by
+ //   the Free Software Foundation, version 2. This program is distributed
+ //   in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ //   even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ //   PURPOSE. See the GNU General Public License for more details.
+ //
+ //   You should have received a copy of the GNU General Public License along
+ //   with this program.If not, see<http:www.gnu.org/licenses/>.
+ //
+ //  (3)CableLabs License
+ //   If you or the company you represent has a separate agreement with CableLabs
+ //   concerning the use of this code, your rights and obligations with respect
+ //   to this code shall be as set forth therein. No license is granted hereunder
+ //   for any other purpose.
+ //
+ //   Please contact CableLabs if you need additional information or
+ //   have any questions.
+ //
+ //       CableLabs
+ //       858 Coal Creek Cir
+ //       Louisville, CO 80027-9750
+ //       303 661-9100
+ // COPYRIGHT_END
+
+/*
+ * Description:     The string test conducts a list of operations on strings and string buffers.
+ * Main Focus:      TODO
+ *
+ */
+
+package art_benchmarks.caffeinemark;
+
+// CHECKSTYLE.OFF: .*
+public class StringAtom
+{
+
+    public StringAtom()
+    {
+        wIterationCount = 50;
+    }
+
+    public boolean initialize(int i)
+    {
+        if(i != 0)
+            wIterationCount = i;
+        sPattern1 = "one ";
+        sPattern2 = "two ";
+        sPattern3 = "three ";
+        return true;
+    }
+
+    public int execute()
+    {
+        stringbuffer.setLength(0);
+        stringbuffer.append("Test");
+        for(int j = 0; j < wIterationCount; j++)
+            stringbuffer.append(sPattern1).append(sPattern2).append(sPattern3);
+
+        stringbuffer.append("four");
+        for(int k = 0; k < wIterationCount; k++)
+        {
+            int i = stringbuffer.toString().indexOf("four", k * 65);
+        }
+
+        return stringbuffer.length();
+    }
+
+    public String testName()
+    {
+        return new String("String");
+    }
+
+    public void setLocal()
+    {
+    }
+
+    public int cleanUp()
+    {
+        return 0;
+    }
+
+    public int defaultMagnification()
+    {
+        return 2771;
+    }
+
+    public void setRemote()
+    {
+    }
+
+    StringBuffer stringbuffer = new StringBuffer();
+    public int wIterationCount;
+    public String sPattern1;
+    public String sPattern2;
+    public String sPattern3;
+    // CHECKSTYLE.ON: .*
+
+  private static int PREDEFINED_ITER_COUNT = 500;
+
+  public void timeStringAtom(int iters) {
+    initialize(PREDEFINED_ITER_COUNT);
+    for (int i = 0; i < iters; i++) {
+      execute();
+    }
+  }
+
+  public boolean verifyStringAtom() {
+    initialize(PREDEFINED_ITER_COUNT);
+    int expected = 7008;
+    int found = execute();
+
+    if (found != expected) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] argv) {
+    int rc = 0;
+    StringAtom obj = new StringAtom();
+
+    final long before = System.currentTimeMillis();
+    obj.timeStringAtom(50);
+    final long after = System.currentTimeMillis();
+
+    if (!obj.verifyStringAtom()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/caffeinemark/StringAtom: " + (after - before));
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/jit_aot/Invoke.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/jit_aot/Invoke.java
new file mode 100644
index 0000000..8c0343c
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/jit_aot/Invoke.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2016 Linaro Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This benchmark is inspired by benchmarks/caffeinemark.
+ * Original benchmark implements a recursion method which calls itself with invoke-virtual.
+ *
+ * This behavior can be different on JIT and AOT mode, because:
+ * - JIT mode can optimize invoke-virtual with inline cache mechanism.
+ * - AOT mode has no such optimization.
+ *
+ * This benchmark exposes such difference between ART JIT and AOT mode.
+ */
+
+package art_benchmarks.jit_aot;
+
+public class Invoke {
+
+  public int recursionInvokeVirtual(int i) {
+    if (i == 0) {
+      return 0;
+    } else {
+      return i + recursionInvokeVirtual(i - 1);
+    }
+  }
+
+  public static int recursionInvokeStatic(int i) {
+    if (i == 0) {
+      return 0;
+    } else {
+      return i + recursionInvokeStatic(i - 1);
+    }
+  }
+
+  public final int recursionInvokeFinal(int i) {
+    if (i == 0) {
+      return 0;
+    } else {
+      return i + recursionInvokeFinal(i - 1);
+    }
+  }
+
+  private int recursionInvokePrivate(int i) {
+    if (i == 0) {
+      return 0;
+    } else {
+      return i + recursionInvokePrivate(i - 1);
+    }
+  }
+
+  private static final int recursion_depth = 1000;
+
+  public void timeRecursionInvokeVirtual(int iters) {
+    for (int i = 0; i < iters; i++) {
+      recursionInvokeVirtual(recursion_depth);
+    }
+  }
+
+  public void timeRecursionInvokeStatic(int iters) {
+    for (int i = 0; i < iters; i++) {
+      recursionInvokeStatic(recursion_depth);
+    }
+  }
+
+  public void timeRecursionInvokeFinal(int iters) {
+    for (int i = 0; i < iters; i++) {
+      recursionInvokeFinal(recursion_depth);
+    }
+  }
+
+  public void timeRecursionInvokePrivate(int iters) {
+    for (int i = 0; i < iters; i++) {
+      recursionInvokePrivate(recursion_depth);
+    }
+  }
+
+  public boolean verify() {
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Invoke obj = new Invoke();
+
+    final long before = System.currentTimeMillis();
+    obj.timeRecursionInvokeVirtual(1000);
+    obj.timeRecursionInvokeStatic(1000);
+    obj.timeRecursionInvokeFinal(1000);
+    obj.timeRecursionInvokePrivate(1000);
+    final long after = System.currentTimeMillis();
+    if (!obj.verify()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/jit_aot/Invoke: " + (after - before));
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/jit_aot/LoadCheck.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/jit_aot/LoadCheck.java
new file mode 100644
index 0000000..1d6f192
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/jit_aot/LoadCheck.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2016 Linaro Limited.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This benchmark is inspired by benchmarksgame/fastaredux.java.
+ * Original benchmark implements a Random class which is a random double generator,
+ * and is heavily used by another class in its inner calculation.
+ *
+ * This behavior can be very unfriendly to ART AOT because:
+ * Random is a user defined class. Currently in AOT mode,
+ * ART cannot assume this class is always loaded,
+ * thus ART AOT compiler has to generate LoadClass check before invoking Random.next() method.
+ * Since Random.next() is called inside a loop of a hot function addLine(),
+ * the LoadClass check overhead causes this benchmark runs twice slower
+ * in AOT mode compared to JIT mode.
+ *
+ * In interpreter + JIT mode, JIT compiler can assume that a user defined class is always loaded
+ * during previous interpretation stage, thus it avoid generating LoadClass check.
+ *
+ * This benchmark exposes such difference between ART JIT and AOT mode.
+ */
+
+package art_benchmarks.jit_aot;
+
+public class LoadCheck {
+  static final class Random {
+    static final int IM = 139968;
+    static final int IA = 3877;
+    static final int IC = 29573;
+    static final double LOOKUP_SCALE = 4 * 1024 - 1;
+    static final double SCALE = LOOKUP_SCALE / IM;
+    static int last = 42;
+
+    static double next() {
+      return SCALE * (last = (last * IA + IC) % IM);
+    }
+  }
+
+  static final int IM = 139968;
+  static final int IA = 3877;
+  static final int IC = 29573;
+  static final double LOOKUP_SCALE = 4 * 1024 - 1;
+  static final double SCALE = LOOKUP_SCALE / IM;
+  static int last = 42;
+
+  public double sum;
+
+  static double nextRandDouble() {
+    return SCALE * (last = (last * IA + IC) % IM);
+  }
+
+  public void randomSumInvokeStaticMethod(int val) {
+    sum = (double)val;
+    for (int i = 0; i < 10000; i++) {
+      sum += nextRandDouble();
+    }
+  }
+
+  public void randomSumInvokeUserClass(int val) {
+    sum = (double)val;
+    for (int i = 0; i < 10000; i++) {
+      sum += Random.next();
+    }
+  }
+
+  private static final int loop_size = 10000;
+
+  public void timeRandomSumInvokeStaticMethod(int iters) {
+    for (int i = 0; i < iters; i++) {
+      randomSumInvokeStaticMethod(loop_size);
+    }
+  }
+
+  public void timeRandomSumInvokeUserClass(int iters) {
+    for (int i = 0; i < iters; i++) {
+      randomSumInvokeUserClass(loop_size);
+    }
+  }
+
+  public boolean verify() {
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    LoadCheck obj = new LoadCheck();
+
+    final long before = System.currentTimeMillis();
+    obj.timeRandomSumInvokeStaticMethod(10000);
+    obj.timeRandomSumInvokeUserClass(10000);
+    final long after = System.currentTimeMillis();
+    if (!obj.verify()) {
+      rc++;
+    }
+    System.out.println("art_benchmarks/jit_aot/LoadCheck: " + (after - before));
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/math/AccessNBody.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/AccessNBody.java
new file mode 100644
index 0000000..1f9305c
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/AccessNBody.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/access-nbody.js
+ *
+ * Description:     N-body simulation of a galaxy composed out of a four planets and the sun.
+ * Main Focus:      Floating-point operations.
+ *
+ */
+
+/* The Great Computer Language Shootout
+   http://shootout.alioth.debian.org/
+   contributed by Isaac Gouy */
+
+// http://benchmarksgame.alioth.debian.org/license.html  (BSD 3-clause license)
+// See NOTICE file for license.
+
+package art_benchmarks.math;
+
+import java.lang.Math;
+import java.lang.System;
+
+public class AccessNBody {
+  private static final double ACCESS_NBODY_EXPECTED = 1.4677045000258846;
+  private static final double DAYS_PER_YEAR = 365.24;
+  private static final double SOLAR_MASS = 4 * Math.PI * Math.PI;
+
+  private class Body {
+    public double x;
+    public double y;
+    public double z;
+    public double vx;
+    public double vy;
+    public double vz;
+    public double mass;
+
+    Body(double x, double y, double z, double vx, double vy, double vz, double mass) {
+      this.x = x;
+      this.y = y;
+      this.z = z;
+      this.vx = vx;
+      this.vy = vy;
+      this.vz = vz;
+      this.mass = mass;
+    }
+
+    void offsetMomentum(double px, double py, double pz) {
+      this.vx = -px / SOLAR_MASS;
+      this.vy = -py / SOLAR_MASS;
+      this.vz = -pz / SOLAR_MASS;
+    }
+
+  }
+
+  private class NBodySystem {
+    private Body[] bodies;
+    private double px;
+    private double py;
+    private double pz;
+
+    NBodySystem(Body[] bodies) {
+      this.bodies = bodies;
+
+      for (int i = 0; i < bodies.length; i++) {
+        Body currentBody = this.bodies[i];
+        double mass = currentBody.mass;
+        px += currentBody.vx * mass;
+        py += currentBody.vy * mass;
+        pz += currentBody.vz * mass;
+      }
+      this.bodies[0].offsetMomentum(px, py, pz);
+    }
+
+    void advance(double dt) {
+      double dx;
+      double dy;
+      double dz;
+      double distance;
+      double mag;
+
+      for (int i = 0; i < bodies.length; i++) {
+        Body bodyI = this.bodies[i];
+        for (int j = i + 1; j < bodies.length; j++) {
+          Body bodyJ = this.bodies[j];
+          dx = bodyI.x - bodyJ.x;
+          dy = bodyI.y - bodyJ.y;
+          dz = bodyI.z - bodyJ.z;
+
+          distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+          mag = dt / (distance * distance * distance);
+          bodyI.vx -= dx * bodyJ.mass * mag;
+          bodyI.vy -= dy * bodyJ.mass * mag;
+          bodyI.vz -= dz * bodyJ.mass * mag;
+
+          bodyJ.vx += dx * bodyI.mass * mag;
+          bodyJ.vy += dy * bodyI.mass * mag;
+          bodyJ.vz += dz * bodyI.mass * mag;
+        }
+      }
+
+      for (int i = 0; i < bodies.length; i++) {
+        Body body = this.bodies[i];
+        body.x += dt * body.vx;
+        body.y += dt * body.vy;
+        body.z += dt * body.vz;
+      }
+    }
+
+    double energy() {
+      double dx;
+      double dy;
+      double dz;
+      double distance;
+      double e = 0.0;
+
+      for (int i = 0; i < bodies.length; i++) {
+        Body bodyI = this.bodies[i];
+
+        e += 0.5 * bodyI.mass
+            * (bodyI.vx * bodyI.vx + bodyI.vy * bodyI.vy + bodyI.vz * bodyI.vz);
+
+        for (int j = i + 1; j < bodies.length; j++) {
+          Body bodyJ = this.bodies[j];
+
+          dx = bodyI.x - bodyJ.x;
+          dy = bodyI.y - bodyJ.y;
+          dz = bodyJ.z - bodyJ.z;
+          distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+          e -= (bodyI.mass * bodyJ.mass) / distance;
+        }
+      }
+      return e;
+    }
+  }
+
+  private Body jupiter() {
+    return new Body(
+        4.84143144246472090e+00,
+        -1.16032004402742839e+00,
+        -1.03622044471123109e-01,
+        1.66007664274403694e-03 * DAYS_PER_YEAR,
+        7.69901118419740425e-03 * DAYS_PER_YEAR,
+        -6.90460016972063023e-05 * DAYS_PER_YEAR,
+        9.54791938424326609e-04 * SOLAR_MASS);
+  }
+
+  private Body saturn() {
+    return new Body(
+        8.34336671824457987e+00,
+        4.12479856412430479e+00,
+        -4.03523417114321381e-01,
+        -2.76742510726862411e-03 * DAYS_PER_YEAR,
+        4.99852801234917238e-03 * DAYS_PER_YEAR,
+        2.30417297573763929e-05 * DAYS_PER_YEAR,
+        2.85885980666130812e-04 * SOLAR_MASS);
+  }
+
+  private Body uranus() {
+    return new Body(
+        1.28943695621391310e+01,
+        -1.51111514016986312e+01,
+        -2.23307578892655734e-01,
+        2.96460137564761618e-03 * DAYS_PER_YEAR,
+        2.37847173959480950e-03 * DAYS_PER_YEAR,
+        -2.96589568540237556e-05 * DAYS_PER_YEAR,
+        4.36624404335156298e-05 * SOLAR_MASS);
+  }
+
+  private Body neptune() {
+    return new Body(
+         1.53796971148509165e+01,
+         -2.59193146099879641e+01,
+         1.79258772950371181e-01,
+         2.68067772490389322e-03 * DAYS_PER_YEAR,
+         1.62824170038242295e-03 * DAYS_PER_YEAR,
+         -9.51592254519715870e-05 * DAYS_PER_YEAR,
+         5.15138902046611451e-05 * SOLAR_MASS);
+  }
+
+  private Body sun() {
+    return new Body(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+  }
+
+  private double simulateGalaxy() {
+    double output = 0.0;
+    Body[] bodies = { sun(), jupiter(), saturn(), uranus(), neptune() };
+    NBodySystem galaxy = new NBodySystem(bodies);
+
+    for (int i = 3; i <= 24; i *= 2) {
+      output += galaxy.energy();
+      for (int j = 0; j < i * 100; j++) {
+        galaxy.advance(0.01);
+      }
+      output += galaxy.energy();
+    }
+    return output;
+  }
+
+  public void timeAccessNBody(int iters) {
+    for (int i = 0; i < iters; i++) {
+      simulateGalaxy();
+    }
+  }
+
+  public boolean verify() {
+    final double output = simulateGalaxy();
+    return output == ACCESS_NBODY_EXPECTED;
+  }
+
+  public static void main(String[] argv) {
+    AccessNBody obj = new AccessNBody();
+    final long before = System.currentTimeMillis();
+    obj.timeAccessNBody(200);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/math/AccessNBody: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathCordic.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathCordic.java
new file mode 100644
index 0000000..2024381
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathCordic.java
@@ -0,0 +1,122 @@
+/*
+ * Ported to java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/math-cordic.js
+ *
+ * Copyright (C) Rich Moore.  All rights reserved.
+ * Copyright (C) 2015 Linaro Limited. For the port to Java
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Description:     A simple and efficient algorithm used to calculate
+ *                  trigonometric cos and sin functions using additions,
+ *                  subtractions and bitshifts.
+ * Main Focus:      Bitshifts, Floating-Point operations.
+ *
+ */
+
+package art_benchmarks.math;
+
+import java.lang.System;
+
+public class MathCordic {
+  private static double[] ANGLES;
+  private static final double AG_CONST = 0.6072529350;
+  private static final double CORDIC_EXPECTED = 10362.570468755888;
+  private static final double RAD_CONST = 0.017453;
+  private static final double TARGET_CONST = 28.027;
+  private static final double X_CONST = 65536.0;
+
+  private static double fixedMul(double x) {
+    return x * X_CONST;
+  }
+
+  private static double fixedDiv(double x) {
+    return x / X_CONST;
+  }
+
+  private static double deg2rad(double x) {
+    return x * RAD_CONST;
+  }
+
+  static {
+    ANGLES = new double[] {
+        fixedMul(45.0), fixedMul(26.565), fixedMul(14.0362), fixedMul(7.12502),
+        fixedMul(3.57633), fixedMul(1.78991), fixedMul(0.895174), fixedMul(0.447614),
+        fixedMul(0.223811), fixedMul(0.111906), fixedMul(0.055953), fixedMul(0.027977) };
+  }
+
+  private double cordicSinCos(double target) {
+    double x;
+    double y;
+    double targetAngle;
+    double currentAngle;
+
+    x = fixedMul(AG_CONST);     /* AG_CONST * cos(0) */
+    y = 0.0;                    /* AG_CONST * sin(0) */
+    currentAngle = 0.0;
+    targetAngle = fixedMul(target);
+
+    for (int i = 0; i < ANGLES.length; i++) {
+      double newX;
+      if (targetAngle > currentAngle) {
+        newX = x - ((long)y >> i);
+        y = ((long)x >> i) + y;
+        x = newX;
+        currentAngle += ANGLES[i];
+      } else {
+        newX = x + ((long)y >> i);
+        y = -((long)x >> i) + y;
+        x = newX;
+        currentAngle -= ANGLES[i];
+      }
+    }
+
+    return fixedDiv(x) * fixedDiv(y);
+  }
+
+  public void timeMathCordic(int iters) {
+    for (int i = 0; i < iters; i++) {
+      for (int j = 0; j < 25000; j++) {
+        cordicSinCos(TARGET_CONST);
+      }
+    }
+  }
+
+  public boolean verify() {
+    double cordicOutput = 0.0;
+    for (int i = 0; i < 25000; i++) {
+      cordicOutput += cordicSinCos(TARGET_CONST);
+    }
+    return cordicOutput == CORDIC_EXPECTED;
+  }
+
+  public static void main(String[] argv) {
+    MathCordic obj = new MathCordic();
+    final long before = System.currentTimeMillis();
+    obj.timeMathCordic(175);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/math/MathCordic: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathPartialSums.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathPartialSums.java
new file mode 100644
index 0000000..9e6f2ba
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathPartialSums.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/math-partial-sums.js
+ *
+ * Description:     Partial sum calculation of a series using Math().pow(),
+ *                  Math.sin() and Math.cos().
+ * Main Focus:      Floating-Point operations, Math.[pow(), sin(), cos()].
+ *
+ */
+
+// The Computer Language Shootout
+// http://shootout.alioth.debian.org/
+// contributed by Isaac Gouy
+
+// http://benchmarksgame.alioth.debian.org/license.html  (BSD 3-clause license)
+// See NOTICE file for license.
+
+package art_benchmarks.math;
+
+import java.lang.Math;
+import java.lang.System;
+
+public class MathPartialSums {
+  private static final double PARTIAL_SUMS_EXPECTED = 33.97380678948515;
+
+  private static double partialSums(int n) {
+    double a1;
+    double a2;
+    double a3;
+    double a4;
+    double a5;
+    double a6;
+    double a7;
+    double a8;
+    double a9;
+    double k2;
+    double k3;
+    double sk;
+    double ck;
+    double twothirds = 2.0 / 3.0;
+    double alt = -1.0;
+
+    a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = 0.0;
+    for (int k = 1; k <= n; k++) {
+      k2 = k * k;
+      k3 = k2 * k;
+      sk = Math.sin(k);
+      ck = Math.cos(k);
+      alt = -alt;
+
+      a1 += Math.pow(twothirds, k - 1);
+      a2 += Math.pow(k, -0.5);
+      a3 += 1.0 / (k * (k + 1.0));
+      a4 += 1.0 / (k3 * sk * sk);
+      a5 += 1.0 / (k3 * ck * ck);
+      a6 += 1.0 / k;
+      a7 += 1.0 / k2;
+      a8 += alt / k;
+      a9 += alt / (2 * k - 1);
+    }
+    return a6 + a7 + a8 + a9;
+  }
+
+  public void timeMathPartialSums(int iters) {
+    for (int i = 0; i < iters; i++) {
+      for (int j = 1024; j <= 5000; j *= 2) {
+        partialSums(j);
+      }
+    }
+  }
+
+  public boolean verify() {
+    double partialSumsOutput = 0.0;
+
+    for (int i = 1024; i <= 5000; i *= 2) {
+      partialSumsOutput += partialSums(i);
+    }
+    return partialSumsOutput == PARTIAL_SUMS_EXPECTED;
+  }
+
+  public static void main(String[] argv) {
+    MathPartialSums obj = new MathPartialSums();
+    final long before = System.currentTimeMillis();
+    obj.timeMathPartialSums(140);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/math/MathPartial: " + (after - before));
+  }
+}
+
+
+
+
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathSpectralNorm.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathSpectralNorm.java
new file mode 100644
index 0000000..103f4b0
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/math/MathSpectralNorm.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. Ported from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/math-spectral-norm.js
+ *
+ * Description:     Martrix spectral norm calculation.
+ * Main Focus:      Floating-Point operations.
+ *
+ */
+
+// The Great Computer Language Shootout
+// http://shootout.alioth.debian.org/
+//
+// contributed by Ian Osgood
+
+// http://benchmarksgame.alioth.debian.org/license.html  (BSD 3-clause license)
+// See NOTICE file for license.
+
+package art_benchmarks.math;
+
+import java.lang.Math;
+import java.lang.System;
+
+public class MathSpectralNorm {
+  private static final double SPECTRAL_NORM_EXPECTED = 5.086694231303284d;
+
+  private double aa(int i, int j) {
+    return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1);
+  }
+
+  private void au(double[] u, double[] v) {
+    for (int i = 0; i < u.length; ++i) {
+      double t = 0.0;
+      for (int j = 0; j < u.length; ++j) {
+        t += aa(i, j) * u[j];
+      }
+      v[i] = t;
+    }
+  }
+
+  private void atu(double[] u, double[] v) {
+    for (int i = 0; i < u.length; ++i) {
+      double t = 0.0;
+      for (int j = 0; j < u.length; ++j) {
+        t += aa(j, i) * u[j];
+      }
+      v[i] = t;
+    }
+  }
+
+  private void atAu(double[] u, double[] v, double[] w) {
+    au(u, w);
+    atu(w, v);
+  }
+
+  double spectralNorm(int n) {
+    double[] u = new double[n];
+    double[] v = new double[n];
+    double[] w = new double[n];
+    double vv;
+    double vBv;
+
+    vv = vBv = 0.0;
+    for (int i = 0; i < n; ++i) {
+      u[i] = 1.0;
+    }
+
+    for (int i = 0; i < 10; ++i) {
+      atAu(u, v, w);
+      atAu(v, u, w);
+    }
+
+    for (int i = 0; i < n; ++i) {
+      vBv += u[i] * v[i];
+      vv += v[i] * v[i];
+    }
+    return Math.sqrt(vBv / vv);
+  }
+
+  public void timeMathSpectralNorm(int iters) {
+    for (int i = 0; i < iters; i++) {
+      for (int j = 6; j <= 48; j *= 2) {
+        spectralNorm(j);
+      }
+    }
+  }
+
+  public boolean verify() {
+    double spectralNormOutput = 0.0;
+    for (int i = 6; i <= 48; i *= 2) {
+      spectralNormOutput += spectralNorm(i);
+    }
+    return spectralNormOutput == SPECTRAL_NORM_EXPECTED;
+  }
+
+  public static void main(String[] argv) {
+    MathSpectralNorm obj = new MathSpectralNorm();
+    final long before = System.currentTimeMillis();
+    obj.timeMathSpectralNorm(360);
+    final long after = System.currentTimeMillis();
+    obj.verify();
+    System.out.println("art_benchmarks/math/MathSpectralNorm: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/Base64.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/Base64.java
new file mode 100644
index 0000000..b5a1165
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/Base64.java
@@ -0,0 +1,168 @@
+/*
+ * encode and decode methods from:
+ *  https://en.wikipedia.org/wiki/Base64#Sample_Implementation_in_Java
+ *  Available under the Creative Commons Attribution-ShareAlike License.
+ *  http://creativecommons.org/licenses/by-sa/3.0/
+ *  Modifiication: added test code
+ */
+
+/*
+ * Description:     Uses a Base64 MIME implementation to check for regressions
+                    in loops, array access, load/store, and string manipulation.
+ * Main Focus:      General operations related to Base64 encoding/decoding.
+ * Secondary Focus: Array access, load/store, string manipulation.
+ *
+ */
+
+package art_benchmarks.micro;
+
+import java.lang.StringBuilder;
+import java.lang.System;
+import java.util.Random;
+
+public class Base64 {
+  private static Random rnd = new Random();
+  private static final int ENC_Length = 64;
+  private static final int NUM_Encodings = 16;
+  private static String[] randomStrings = new String[NUM_Encodings];
+  private static String[] randomBase64 = new String[NUM_Encodings];
+  private static String[] encodeResults = new String[NUM_Encodings];
+  private static String[] decodeResults = new String[NUM_Encodings];
+  private static final String codes =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  private static char base64Pad = '=';
+
+  static {
+    generateRandomStrings();
+    generateRandomBase64();
+  }
+
+  private static void generateRandomStrings() {
+    for (int i = 0; i < NUM_Encodings; i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 0; j < ENC_Length; j++) {
+        sb.append(Character.valueOf((char)rnd.nextInt()));
+      }
+      randomStrings[i] = sb.toString();
+    }
+  }
+
+  private static void generateRandomBase64() {
+    for (int i = 0; i < NUM_Encodings; i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 0; j < ENC_Length; j++) {
+        sb.append(codes.charAt(rnd.nextInt(codes.length() - 1)));
+      }
+      randomBase64[i] = sb.toString();
+    }
+  }
+
+  private static String encode(String str) {
+    byte[] in = str.getBytes();
+    StringBuffer out = new StringBuffer((in.length * 4) / 3);
+    int b;
+    for (int i = 0; i < in.length; i += 3)  {
+      b = (in[i] & 0xFC) >> 2;
+      out.append(codes.charAt(b));
+      b = (in[i] & 0x03) << 4;
+      if (i + 1 < in.length)      {
+        b |= (in[i + 1] & 0xF0) >> 4;
+        out.append(codes.charAt(b));
+        b = (in[i + 1] & 0x0F) << 2;
+        if (i + 2 < in.length)  {
+          b |= (in[i + 2] & 0xC0) >> 6;
+          out.append(codes.charAt(b));
+          b = in[i + 2] & 0x3F;
+          out.append(codes.charAt(b));
+        } else {
+          out.append(codes.charAt(b));
+          out.append('=');
+        }
+      } else {
+        out.append(codes.charAt(b));
+        out.append("==");
+      }
+    }
+
+    return out.toString();
+  }
+
+  private static byte[] decode(String input)    {
+    if (input.length() % 4 != 0)    {
+      System.err.println("Invalid base64 input");
+      return null;
+    }
+    int eqPos = input.indexOf('=');
+    int len = input.length();
+    byte[] decoded =
+      new byte[((len * 3) / 4) - (eqPos > 0 ? (len - eqPos) : 0)];
+    char[] inChars = input.toCharArray();
+    int j = 0;
+    int[] b = new int[4];
+    for (int i = 0; i < inChars.length; i += 4)     {
+      b[0] = codes.indexOf(inChars[i]);
+      b[1] = codes.indexOf(inChars[i + 1]);
+      b[2] = codes.indexOf(inChars[i + 2]);
+      b[3] = codes.indexOf(inChars[i + 3]);
+      decoded[j++] = (byte) ((b[0] << 2) | (b[1] >> 4));
+      if (b[2] < 64)      {
+        decoded[j++] = (byte) ((b[1] << 4) | (b[2] >> 2));
+        if (b[3] < 64)  {
+          decoded[j++] = (byte) ((b[2] << 6) | b[3]);
+        }
+      }
+    }
+    return decoded;
+  }
+
+  public void timeEncode(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int j = 0; j < NUM_Encodings; j++) {
+        encodeResults[j] = encode(randomStrings[j]);
+      }
+    }
+  }
+
+  public void timeDecode(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int j = 0; j < NUM_Encodings; j++) {
+        decodeResults[j] = new String(decode(randomBase64[j]));
+      }
+    }
+  }
+
+  public boolean verifyEncode() {
+    boolean result = true;
+    result &= encode("Don't panic.").equals(
+        "RG9uJ3QgcGFuaWMu");
+    result &= encode("Time is an illusion.").equals(
+        "VGltZSBpcyBhbiBpbGx1c2lvbi4=");
+    result &= encode("Don't talk to me about life.").equals(
+        "RG9uJ3QgdGFsayB0byBtZSBhYm91dCBsaWZlLg==");
+    result &= encode("Ford... you're turning into a penguin.").equals(
+        "Rm9yZC4uLiB5b3UncmUgdHVybmluZyBpbnRvIGEgcGVuZ3Vpbi4=");
+    return result;
+  }
+
+  public boolean verifyDecode() {
+    boolean result = true;
+    result &= new String(decode("RG9uJ3QgcGFuaWMu")).equals(
+        "Don't panic.");
+    result &= new String(decode("VGltZSBpcyBhbiBpbGx1c2lvbi4=")).equals(
+        "Time is an illusion.");
+    result &= new String(decode("RG9uJ3QgdGFsayB0byBtZSBhYm91dCBsaWZlLg==")).equals(
+        "Don't talk to me about life.");
+    result &= new String(decode("Rm9yZC4uLiB5b3UncmUgdHVybmluZyBpbnRvIGEgcGVuZ3Vpbi4=")).equals(
+        "Ford... you're turning into a penguin.");
+    return result;
+  }
+
+  public static void main(String[] args) {
+    Base64 b = new Base64();
+    long before = System.currentTimeMillis();
+    b.timeEncode(1300);
+    b.timeDecode(1300);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/Base64: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/BitfieldRotate.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/BitfieldRotate.java
new file mode 100644
index 0000000..1f3041d
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/BitfieldRotate.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2000-2015 The Legion of the Bouncy Castle Inc. (http://www.bouncycastle.org)
+ *
+ * Modifications copyright (c) 2015 Linaro Limited.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * Description:     Check for regressions effecting Bouncy Castle SHA1Digest processing.
+ * Main Focus:      Bitfield rotations.
+ * Secondary Focus: Loop optimizations.
+ */
+
+package art_benchmarks.micro;
+
+public class BitfieldRotate {
+  private static final String SOURCE_Text = "That though I loved them for their faults\n" +
+                                            "As much as for their good,\n" +
+                                            "My friends were enemies on stilts\n" +
+                                            "With their heads in a cunning cloud.\n";
+
+  private int h1;
+  private int h2;
+  private int h3;
+  private int h4;
+  private int h5;
+  private int[] x = new int[80];
+  private int xOff;
+
+  //
+  // Additive constants
+  //
+  private static final int    y1 = 0x5a827999;
+  private static final int    y2 = 0x6ed9eba1;
+  private static final int    y3 = 0x8f1bbcdc;
+  private static final int    y4 = 0xca62c1d6;
+
+  private int ffunc(
+      int    u,
+      int    v,
+      int    w) {
+    return ((u & v) | ((~u) & w));
+  }
+
+  private int hfunc(
+      int    u,
+      int    v,
+      int    w) {
+    return (u ^ v ^ w);
+  }
+
+  private int gfunc(
+      int    u,
+      int    v,
+      int    w) {
+    return ((u & v) | (u & w) | (v & w));
+  }
+
+  protected void processBlock() {
+    //
+    // expand 16 word block into 80 word block.
+    //
+    for (int i = 16; i < 80; i++) {
+      int t = x[i - 3] ^ x[i - 8] ^ x[i - 14] ^ x[i - 16];
+      x[i] = t << 1 | t >>> 31;
+    }
+
+    //
+    // set up working variables.
+    //
+    int     a = h1;
+    int     b = h2;
+    int     c = h3;
+    int     d = h4;
+    int     e = h5;
+
+    //
+    // round 1
+    //
+    int idx = 0;
+
+    for (int j = 0; j < 4; j++) {
+      // E = rotateLeft(a, 5) + ffunc(b, c, d) + E + x[idx++] + y1
+      // B = rotateLeft(b, 30)
+      e += (a << 5 | a >>> 27) + ffunc(b, c, d) + x[idx++] + y1;
+      b = b << 30 | b >>> 2;
+
+      d += (e << 5 | e >>> 27) + ffunc(a, b, c) + x[idx++] + y1;
+      a = a << 30 | a >>> 2;
+
+      c += (d << 5 | d >>> 27) + ffunc(e, a, b) + x[idx++] + y1;
+      e = e << 30 | e >>> 2;
+
+      b += (c << 5 | c >>> 27) + ffunc(d, e, a) + x[idx++] + y1;
+      d = d << 30 | d >>> 2;
+
+      a += (b << 5 | b >>> 27) + ffunc(c, d, e) + x[idx++] + y1;
+      c = c << 30 | c >>> 2;
+    }
+
+    //
+    // round 2
+    //
+    for (int j = 0; j < 4; j++) {
+      // E = rotateLeft(a, 5) + hfunc(b, c, d) + E + x[idx++] + y2
+      // B = rotateLeft(b, 30)
+      e += (a << 5 | a >>> 27) + hfunc(b, c, d) + x[idx++] + y2;
+      b = b << 30 | b >>> 2;
+
+      d += (e << 5 | e >>> 27) + hfunc(a, b, c) + x[idx++] + y2;
+      a = a << 30 | a >>> 2;
+
+      c += (d << 5 | d >>> 27) + hfunc(e, a, b) + x[idx++] + y2;
+      e = e << 30 | e >>> 2;
+
+      b += (c << 5 | c >>> 27) + hfunc(d, e, a) + x[idx++] + y2;
+      d = d << 30 | d >>> 2;
+
+      a += (b << 5 | b >>> 27) + hfunc(c, d, e) + x[idx++] + y2;
+      c = c << 30 | c >>> 2;
+    }
+
+    //
+    // round 3
+    //
+    for (int j = 0; j < 4; j++) {
+      // E = rotateLeft(a, 5) + gfunc(b, c, d) + E + x[idx++] + y3
+      // B = rotateLeft(b, 30)
+      e += (a << 5 | a >>> 27) + gfunc(b, c, d) + x[idx++] + y3;
+      b = b << 30 | b >>> 2;
+
+      d += (e << 5 | e >>> 27) + gfunc(a, b, c) + x[idx++] + y3;
+      a = a << 30 | a >>> 2;
+
+      c += (d << 5 | d >>> 27) + gfunc(e, a, b) + x[idx++] + y3;
+      e = e << 30 | e >>> 2;
+
+      b += (c << 5 | c >>> 27) + gfunc(d, e, a) + x[idx++] + y3;
+      d = d << 30 | d >>> 2;
+
+      a += (b << 5 | b >>> 27) + gfunc(c, d, e) + x[idx++] + y3;
+      c = c << 30 | c >>> 2;
+    }
+
+    //
+    // round 4
+    //
+    for (int j = 0; j <= 3; j++) {
+      // E = rotateLeft(a, 5) + hfunc(b, c, d) + E + x[idx++] + y4
+      // B = rotateLeft(b, 30)
+      e += (a << 5 | a >>> 27) + hfunc(b, c, d) + x[idx++] + y4;
+      b = b << 30 | b >>> 2;
+
+      d += (e << 5 | e >>> 27) + hfunc(a, b, c) + x[idx++] + y4;
+      a = a << 30 | a >>> 2;
+
+      c += (d << 5 | d >>> 27) + hfunc(e, a, b) + x[idx++] + y4;
+      e = e << 30 | e >>> 2;
+
+      b += (c << 5 | c >>> 27) + hfunc(d, e, a) + x[idx++] + y4;
+      d = d << 30 | d >>> 2;
+
+      a += (b << 5 | b >>> 27) + hfunc(c, d, e) + x[idx++] + y4;
+      c = c << 30 | c >>> 2;
+    }
+
+    h1 += a;
+    h2 += b;
+    h3 += c;
+    h4 += d;
+    h5 += e;
+
+    //
+    // reset start of the buffer.
+    //
+    xOff = 0;
+    for (int i = 0; i < 16; i++) {
+      x[i] = 0;
+    }
+  }
+
+  public void timeSHA1DigestProcessBlock(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      h1 = h2 = h3 = h4 = h5 = 0;
+      processBlock();
+    }
+  }
+
+  public boolean verifySHa1DigestProcessBlock() {
+    byte[] buf = SOURCE_Text.getBytes();
+    for (int i = 0; i < 80; i++) {
+      x[i] = buf[i];
+    }
+    processBlock();
+    return h1 == 1347341312 &&
+           h2 == -1669350125 &&
+           h3 == -362661148 &&
+           h4 == 1604346378 &&
+           h5 == -833338986;
+  }
+
+  /**
+   * Integer rotate right patterns.
+   */
+
+  int resultIntegerRightRegVCSubV;
+  int resultIntegerRightRegVNegV;
+
+  public static int rotateIntegerRightRegVCSubV(int value, int distance) {
+    return (value >>> distance) | (value << (32 - distance));
+  }
+
+  public static int rotateIntegerRightRegVNegV(int value, int distance) {
+    return (value >>> distance) | (value << -distance);
+  }
+
+  public void timeIntegerRotateRight(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int distance = 0; distance < Integer.SIZE; distance++) {
+        resultIntegerRightRegVCSubV += rotateIntegerRightRegVCSubV(0xCAFEBABE, distance);
+        resultIntegerRightRegVNegV += rotateIntegerRightRegVNegV(0xCAFEBABE, distance);
+      }
+    }
+  }
+
+  public boolean verifyIntegerRotateRight() {
+    return (rotateIntegerRightRegVCSubV(0xCAFEBABE, 16) == 0xBABECAFE) &&
+           (rotateIntegerRightRegVNegV(0xCAFEBABE, -4) == 0xAFEBABEC);
+  }
+
+  /**
+   * Integer rotate left patterns.
+   */
+
+  int resultIntegerLeftRegCSubVV;
+  int resultIntegerLeftRegNegVV;
+
+  public static int rotateIntegerLeftRegCSubVV(int value, int distance) {
+    return (value >>> (32 - distance)) | (value << distance);
+  }
+
+  public static int rotateIntegerLeftRegNegVV(int value, int distance) {
+    return (value >>> -distance) | (value << distance);
+  }
+
+  public void timeIntegerRotateLeft(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int distance = 0; distance < Integer.SIZE; distance++) {
+        resultIntegerLeftRegCSubVV += rotateIntegerLeftRegCSubVV(0xCAFEBABE, distance);
+        resultIntegerLeftRegNegVV += rotateIntegerLeftRegNegVV(0xCAFEBABE, distance);
+      }
+    }
+  }
+
+  public boolean verifyIntegerRotateLeft() {
+    return (rotateIntegerLeftRegCSubVV(0xCAFEBABE, 4) == 0xAFEBABEC) &&
+           (rotateIntegerLeftRegNegVV(0xCAFEBABE, -4) == 0xECAFEBAB);
+  }
+
+  /**
+   * Long rotate right patterns.
+   */
+
+  int resultLongRightRegVCSubV;
+  int resultLongRightRegVNegV;
+
+  public static long rotateLongRightRegVCSubV(long value, int distance) {
+    return (value >>> distance) | (value << (64 - distance));
+  }
+
+  public static long rotateLongRightRegVNegV(long value, int distance) {
+    return (value >>> distance) | (value << -distance);
+  }
+
+  public void timeLongRotateRight(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int distance = 0; distance < Long.SIZE; distance++) {
+        resultLongRightRegVCSubV += rotateLongRightRegVCSubV(0xCAFEBABEBAADF00DL, distance);
+        resultLongRightRegVNegV += rotateLongRightRegVNegV(0xCAFEBABEBAADF00DL, distance);
+      }
+    }
+  }
+
+  public boolean verifyLongRotateRight() {
+    return (rotateLongRightRegVCSubV(0xCAFEBABEBAADF00DL, 32) == 0xBAADF00DCAFEBABEL) &&
+           (rotateLongRightRegVNegV(0xCAFEBABEBAADF00DL, -16) == 0xBABEBAADF00DCAFEL);
+  }
+
+  /**
+   * Long rotate left patterns.
+   */
+
+  int resultLongLeftRegCSubVV;
+  int resultLongLeftRegNegVV;
+
+  public static long rotateLongLeftRegCSubVV(long value, int distance) {
+    return (value >>> (64 - distance)) | (value << distance);
+  }
+
+  public static long rotateLongLeftRegNegVV(long value, int distance) {
+    return (value >>> -distance) | (value << distance);
+  }
+
+  public void timeLongRotateLeft(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int distance = 0; distance < Long.SIZE; distance++) {
+        resultLongLeftRegCSubVV += rotateLongLeftRegCSubVV(0xCAFEBABEBAADF00DL, distance);
+        resultLongLeftRegNegVV += rotateLongLeftRegNegVV(0xCAFEBABEBAADF00DL, distance);
+      }
+    }
+  }
+
+  public boolean verifyLongRotateLeft() {
+    return (rotateLongLeftRegCSubVV(0xCAFEBABEBAADF00DL, 4) == 0xAFEBABEBAADF00DCL) &&
+           (rotateLongLeftRegNegVV(0xCAFEBABEBAADF00DL, -16) == 0xF00DCAFEBABEBAADL);
+  }
+
+  public static void main(String[] args) {
+    BitfieldRotate br = new BitfieldRotate();
+    long before = System.currentTimeMillis();
+    br.timeSHA1DigestProcessBlock(300000);
+    br.timeIntegerRotateRight(300000);
+    br.timeIntegerRotateLeft(300000);
+    br.timeLongRotateRight(300000);
+    br.timeLongRotateLeft(300000);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/BitfieldRotate: " + (after - before));
+  }
+}
+
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/ControlFlowRecursive.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/ControlFlowRecursive.java
new file mode 100644
index 0000000..a5c03df
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/ControlFlowRecursive.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2015, Linaro Limited. Ported to Java from:
+ *  https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/controlflow-recursive.js
+ * and added Tarai.
+ *
+ * Description:     A control flow recursive micro benchmark case.
+ */
+
+
+// The Computer Language Shootout
+// http://shootout.alioth.debian.org/
+// contributed by Isaac Gouy
+
+// http://benchmarksgame.alioth.debian.org/license.html  (BSD 3-clause license)
+// See NOTICE file for license.
+
+package art_benchmarks.micro;
+
+public class ControlFlowRecursive {
+  private int result = 0;
+  private final int expected = 57775;
+
+  private int ack(int m, int n) {
+    if (m == 0) {
+      return n + 1;
+    }
+    if (n == 0) {
+      return ack(m - 1, 1);
+    }
+    return ack(m - 1, ack(m, n - 1));
+  }
+
+  private int fib(int n) {
+    if (n < 2) {
+      return 1;
+    }
+    return fib(n - 2) + fib(n - 1);
+  }
+
+  private int tak(int x, int y, int z) {
+    if (y >= x) {
+      return z;
+    }
+    return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y));
+  }
+
+  private int tarai(int x, int y, int z) {
+    if (y >= x) {
+      return y;
+    }
+    return tarai(tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y));
+  }
+
+  public void timeTak(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 3; i <= 5; i++) {
+        tak(3 * i + 3, 2 * i + 2, i + 1);
+      }
+    }
+  }
+
+  public void timeTarai(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 3; i <= 5; i++) {
+        tarai(3 * i + 3, 2 * i + 2, i + 1);
+      }
+    }
+  }
+
+  public void timeControlFlowRecursive(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      result = 0;
+      for (int i = 3; i <= 5; i++) {
+        result += ack(3, i);
+        result += fib(17 + i);
+        result += tak(3 * i + 3, 2 * i + 2, i + 1);
+      }
+    }
+  }
+  /**
+   * Verify
+   **/
+
+  public boolean verifyTakTarai() {
+    int i = 5;
+    int expected = 25;
+    int found = tak(3 * i + 3, 2 * i + 2, i + 1) + tarai(3 * i + 3, 2 * i + 2, i + 1);
+
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Called by the framework to assert the benchmarks have done the right thing.
+   **/
+  public boolean verifyControlFlowRecursive() {
+    return result == expected;
+  }
+
+  /**
+   * *NOT* called by the framework by default, provided for direct use only.
+   **/
+  public static void main(String[] args) {
+    int rc = 0;
+    long start;
+    long end;
+    ControlFlowRecursive obj = new ControlFlowRecursive();
+
+    start = System.currentTimeMillis();
+    obj.timeControlFlowRecursive(600);
+    end = System.currentTimeMillis();
+    System.out.println(
+        "art_benchmarks/micro/ControlFlowRecursive.ControlFlowRecursive: " + (end - start));
+
+    start = System.currentTimeMillis();
+    obj.timeTak(2000);
+    end = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/ControlFlowRecursive.Tak: " + (end - start));
+
+    start = System.currentTimeMillis();
+    obj.timeTarai(10);
+    end = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/ControlFlowRecursive.Tarai: " + (end - start));
+
+    if (!obj.verifyTakTarai() || !obj.verifyControlFlowRecursive()) {
+      rc++;
+    }
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/Exceptions.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/Exceptions.java
new file mode 100644
index 0000000..ada4183
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/Exceptions.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2016 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Exceptions code utilization.
+ * Main Focus:
+ *
+ */
+
+package art_benchmarks.micro;
+
+public class Exceptions {
+
+  private int[] smallArray = new int[1];
+  private static final int ARITHM_DOUBLE_ITERS = 20000;
+
+  /**
+   * Three following examples do the same arithmetics on double, but
+   *   - arithmDouble:               just does calculations
+   *   - arirhmDoubleException:      does calculations but has a try-catch which never fires.
+   *   - arirhmDoubleExceptionFires: does calculations but has a try-catch which always fires.
+   */
+  private int arithmDoubleExceptionFires(int n) {
+    double x = 1.0 * (double)n;
+    double y = 2.0 * (double)n;
+    double z = 3.0 * (double)n;
+    double expr = 0.0;
+    int a = 0;
+
+    for (int i = 0; i < ARITHM_DOUBLE_ITERS; i++) {
+      expr += x + y + z * x + y * y + x * z;
+      try {
+        a = smallArray[1];
+      } catch (Exception e) {
+      }
+    }
+
+    return (int)expr + a + (int)x + (int)y + (int)z;
+  }
+
+  private int arithmDoubleException(int n) {
+    double x = 1.0 * (double)n;
+    double y = 2.0 * (double)n;
+    double z = 3.0 * (double)n;
+    double expr = 0.0;
+    int a = 0;
+
+    for (int i = 0; i < ARITHM_DOUBLE_ITERS; i++) {
+      expr += x + y + z * x + y * y + x * z;
+      try {
+        a = smallArray[0];
+      } catch (Exception e) {
+      }
+    }
+
+    return (int)expr + a + (int)x + (int)y + (int)z;
+  }
+
+  private int arithmDouble(int n) {
+    double x = 1.0 * (double)n;
+    double y = 2.0 * (double)n;
+    double z = 3.0 * (double)n;
+    double expr = 0.0;
+    int a = 0;
+
+    for (int i = 0; i < ARITHM_DOUBLE_ITERS; i++) {
+      expr += x + y + z * x + y * y + x * z;
+      a = smallArray[0];
+    }
+
+    return (int)expr + a + (int)x + (int)y + (int)z;
+  }
+
+  public void timeArithmDoubleException(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      arithmDoubleException(i);
+    }
+  }
+
+  public void timeArithmDoubleExceptionFires(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      arithmDoubleExceptionFires(i);
+    }
+  }
+
+  public void timeArithmDouble(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      arithmDouble(i);
+    }
+  }
+
+  public boolean verify() {
+    final int expected = 20600060;
+    return (arithmDouble(10) == expected) &&
+           (arithmDoubleException(10) == expected) &&
+           (arithmDoubleExceptionFires(10) == expected);
+  }
+
+  private static final int TIME_FUNCTIONS_ITERS = 1000;
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Exceptions obj = new Exceptions();
+    long before = System.currentTimeMillis();
+    obj.timeArithmDoubleExceptionFires(10);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/Exceptions.arithmDoubleExceptionFires: "
+                       + (after - before));
+
+    before = System.currentTimeMillis();
+    obj.timeArithmDoubleException(TIME_FUNCTIONS_ITERS);
+    after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/Exceptions.arithmDoubleException: " + (after - before));
+
+    before = System.currentTimeMillis();
+    obj.timeArithmDouble(TIME_FUNCTIONS_ITERS);
+    after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/Exceptions.arithmDouble: " + (after - before));
+
+    if (!obj.verify()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/HashMapBench.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/HashMapBench.java
new file mode 100644
index 0000000..0e2a5a7
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/HashMapBench.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2015, Linaro Limited. Ported to Java from:
+ *  http://browserbench.org/JetStream/sources/hash-map.js
+ *
+ * Description:   A benchmark case for hash map
+ */
+
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE below for additional
+ *  information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/******* NOTICE *********
+
+ Apache Harmony
+ Copyright 2006, 2010 The Apache Software Foundation.
+
+ This product includes software developed at
+ The Apache Software Foundation (http://www.apache.org/).
+
+ Portions of Apache Harmony were originally developed by
+ Intel Corporation and are licensed to the Apache Software
+ Foundation under the "Software Grant and Corporate Contribution
+ License Agreement" and for which the following copyright notices
+ apply
+ (C) Copyright 2005 Intel Corporation
+ (C) Copyright 2005-2006 Intel Corporation
+ (C) Copyright 2006 Intel Corporation
+
+
+ The following copyright notice(s) were affixed to portions of the code
+ with which this file is now or was at one time distributed
+ and are placed here unaltered.
+
+ (C) Copyright 1997,2004 International Business Machines Corporation.
+ All rights reserved.
+
+ (C) Copyright IBM Corp. 2003.
+
+
+ This software contains code derived from UNIX V7, Copyright(C)
+ Caldera International Inc.
+
+ ************************/
+
+package art_benchmarks.micro;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class HashMapBench {
+
+  private static final int COUNT = 5000;
+  private static final int resultExpect = 1050000;
+  private static final long keySumExpect = 12497500;
+  private static final int valueSumExpect = 210000;
+  private int result = 0;
+  private long keySum = 0;
+  private int valueSum = 0;
+
+  private Map<Integer, Integer> map = new HashMap<Integer, Integer>();
+
+  public void timeTestHashMap(int iters) {
+    for (int i = 0; i < iters; i++) {
+      for (int j = 0; j < COUNT; j++) {
+        map.put(j, 42);
+      }
+
+      result = 0;
+      for (int k = 0; k < 5; k++) {
+        for (int j = 0; j < COUNT; j++) {
+          result += map.get(j);
+        }
+      }
+
+      keySum = 0;
+      valueSum = 0;
+      for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+        keySum += entry.getKey();
+        valueSum += entry.getValue();
+      }
+    }
+  }
+
+  /**
+   * Verify
+   **/
+
+  /**
+   * Called by the framework to assert the benchmarks have done the right thing.
+   **/
+  public boolean verify() {
+    boolean verified = true;
+
+    if (result != resultExpect) {
+      System.out.println("ERROR: Expected result " + resultExpect + " but found " + result);
+      verified = false;
+    }
+
+    if (keySum != keySumExpect) {
+      System.out.println("ERROR: Expected keySum " + keySumExpect + " but found " + keySum);
+      verified = false;
+    }
+
+    if (valueSum != valueSumExpect) {
+      System.out.println("ERROR: Expected valueSum " + valueSumExpect + " but found " + valueSum);
+      verified = false;
+    }
+
+    return verified;
+  }
+
+  /**
+   * *NOT* called by the framework by default, provided for direct use only.
+   **/
+  public static void main(String[] args) {
+    HashMapBench obj = new HashMapBench();
+    long before = System.currentTimeMillis();
+    obj.timeTestHashMap(100);
+
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/HashMapBench: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/PrefetchLoopedArrayAccess.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/PrefetchLoopedArrayAccess.java
new file mode 100644
index 0000000..df7862d
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/PrefetchLoopedArrayAccess.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Tracks performance of looped array access to Java Objects.
+ *                  BitSet is an arbitrary choice. 1024 pool and update list
+ *                  sizes showed benefits when prefetching 8 references ahead
+ *                  during looped array access. Other benchmarks for different
+ *                  and mixed Object sizes would be beneficial.
+ * Main Focus:      Looped array access to semi-random memory access patterns.
+ * Secondary Focus:
+ *
+ */
+
+package art_benchmarks.micro;
+
+import java.util.BitSet;
+import java.util.Random;
+
+public class PrefetchLoopedArrayAccess {
+
+  private static final Random rnd = new Random(0);
+  private static final int POOL_Size = 1024;
+  private static final int UPDATE_Size = 1024;
+
+  private BitSet[] bits;
+  private BitSet[] updateList;
+
+  {
+    initBitSets();
+    initUpdateList();
+  }
+
+  private void initUpdateList() {
+    updateList = new BitSet[UPDATE_Size];
+    for (int i = 0; i < UPDATE_Size; i++) {
+      updateList[i] = bits[rnd.nextInt(POOL_Size)];
+    }
+  }
+
+  private void initBitSets() {
+    bits = new BitSet[POOL_Size];
+    for (int i = 0; i < POOL_Size; i++) {
+      bits[i] = new BitSet();
+    }
+  }
+
+  private void updateBitSets() {
+    for (int i = 0; i < UPDATE_Size; i++) {
+      updateList[i].set(7);
+    }
+  }
+
+  public void timeRun(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      updateBitSets();
+    }
+  }
+
+  public static void main(String[] args) {
+    PrefetchLoopedArrayAccess obj = new PrefetchLoopedArrayAccess();
+    long before = System.currentTimeMillis();
+    obj.timeRun(22000);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/PrefetchLoopedArrayAccess: " + (after - before));
+  }
+
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/ShifterOperand.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/ShifterOperand.java
new file mode 100644
index 0000000..790d57c
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/ShifterOperand.java
@@ -0,0 +1,819 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package art_benchmarks.micro;
+
+
+/*
+ * Description: Tests around binary operations taking shifts or type conversions
+ * as inputs that can be merged into the shifter operand.
+ *
+ * Main Focus: shifter operand
+ *
+ * Secondary Focus: instruction scheduling
+ *
+ * Some comments in this file assume that shift or extend operations are merged
+ * into the shifter operand of the binary operations using them.
+ */
+
+// We declare many temporary local variables with similar names. Avoid the extra
+// lines that would be required with one declaration per line.
+// CHECKSTYLE.OFF: MultipleVariableDeclarations
+
+public class ShifterOperand {
+  public static int timeIntSingleUseLatency1(int iterations) {
+    int t1 = 0;
+    for (int iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+      t1 |= iter >> 1;
+      t1 &= iter << 2;
+      t1 ^= iter >>> 3;
+      t1 += (byte)iter;
+      t1 -= (char)iter;
+      t1 += (short)iter;
+    }
+    return t1;
+  }
+
+  public static boolean verifyIntSingleUseLatency1() {
+    final int expected = 14;
+    int found = timeIntSingleUseLatency1(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  // The `ThreadN` suffix indicates that the loop contains `N` independent
+  // computation threads that execute (almost exactly) the same thing.  The
+  // multiple threads allow for instruction scheduling to kick in.
+  public static int timeIntSingleUseLatency1Thread2(int iterations) {
+    int t1 = 0, t2 = 1;
+    for (int iter1 = 0, iter2 = 1;
+         iter1 < iterations;
+         iter1++, iter2++) {
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+
+      // Computation thread 1.
+      t1 |= iter1 >> 1;
+      t1 &= iter1 << 2;
+      t1 ^= iter1 >>> 3;
+      t1 += (byte)iter1;
+      t1 -= (char)iter1;
+      t1 += (short)iter1;
+
+      // Computation thread 2.
+      t2 |= iter2 >> 1;
+      t2 &= iter2 << 2;
+      t2 ^= iter2 >>> 3;
+      t2 += (byte)iter2;
+      t2 -= (char)iter2;
+      t2 += (short)iter2;
+    }
+    return t1;
+  }
+
+  public static boolean verifyIntSingleUseLatency1Thread2() {
+    final int expected = 14;
+    int found = timeIntSingleUseLatency1Thread2(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeIntSingleUseLatency1Thread3(int iterations) {
+    int t1 = 0, t2 = 1, t3 = 2;
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+
+    for (int iter1 = 0, iter2 = 1, iter3 = 2;
+         iter1 < iterations;
+         iter1++, iter2++, iter3++) {
+      // Computation thread 1.
+      t1 |= iter1 >> 1;
+      t1 &= iter1 << 2;
+      t1 ^= iter1 >>> 3;
+      t1 += (byte)iter1;
+      t1 -= (char)iter1;
+      t1 += (short)iter1;
+
+      // Computation thread 2.
+      t2 |= iter2 >> 1;
+      t2 &= iter2 << 2;
+      t2 ^= iter2 >>> 3;
+      t2 += (byte)iter2;
+      t2 -= (char)iter2;
+      t2 += (short)iter2;
+
+      // Computation thread 3.
+      t3 |= iter3 >> 1;
+      t3 &= iter3 << 2;
+      t3 ^= iter3 >>> 3;
+      t3 += (byte)iter3;
+      t3 -= (char)iter3;
+      t3 += (short)iter3;
+    }
+    return t1;
+  }
+
+  public static boolean verifyIntSingleUseLatency1Thread3() {
+    final int expected = 14;
+    int found = timeIntSingleUseLatency1Thread3(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeIntSingleUseLatency1Thread4(int iterations) {
+    int t1 = 0, t2 = 1, t3 = 2, t4 = 3;
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+
+    for (int iter1 = 0, iter2 = 1, iter3 = 2, iter4 = 3;
+         iter1 < iterations;
+         iter1++, iter2++, iter3++, iter4++) {
+      // Computation thread 1.
+      t1 |= iter1 >> 1;
+      t1 &= iter1 << 2;
+      t1 ^= iter1 >>> 3;
+      t1 += (byte)iter1;
+      t1 -= (char)iter1;
+      t1 += (short)iter1;
+
+      // Computation thread 2.
+      t2 |= iter2 >> 1;
+      t2 &= iter2 << 2;
+      t2 ^= iter2 >>> 3;
+      t2 += (byte)iter2;
+      t2 -= (char)iter2;
+      t2 += (short)iter2;
+
+      // Computation thread 3.
+      t3 |= iter3 >> 1;
+      t3 &= iter3 << 2;
+      t3 ^= iter3 >>> 3;
+      t3 += (byte)iter3;
+      t3 -= (char)iter3;
+      t3 += (short)iter3;
+
+      // Computation thread 4.
+      t4 |= iter4 >> 1;
+      t4 &= iter4 << 2;
+      t4 ^= iter4 >>> 3;
+      t4 += (byte)iter4;
+      t4 -= (char)iter4;
+      t4 += (short)iter4;
+    }
+    return t1;
+  }
+
+  public static boolean verifyIntSingleUseLatency1Thread4() {
+    final int expected = 14;
+    int found = timeIntSingleUseLatency1Thread4(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeIntSingleUseLatency2(int iterations) {
+    int t1 = 0, t2 = 0;
+    for (int iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are used two instructions after being produced.
+      t1 |= iter >> 1;
+      t2 &= iter << 2;
+      t1 ^= iter >>> 3;
+      t2 += (byte)iter;
+      t1 -= (char)iter;
+      t2 += (short)iter;
+    }
+    return t1 | t2;
+  }
+
+  public static boolean verifyIntSingleUseLatency2() {
+    final int expected = -5;
+    int found = timeIntSingleUseLatency2(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeIntSingleUseLatency3(int iterations) {
+    int t1 = 0, t2 = 0, t3 = 0;
+    for (int iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are used three instructions after being produced.
+      t1 |= iter >> 1;
+      t2 &= iter << 2;
+      t3 ^= iter >>> 3;
+      t1 += (byte)iter;
+      t2 -= (char)iter;
+      t3 += (short)iter;
+    }
+    return t1 | t2;
+  }
+
+  public static boolean verifyIntSingleUseLatency3() {
+    final int expected = -1;
+    int found = timeIntSingleUseLatency3(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeIntSingleUseLatencyLoop(int iterations) {
+    int t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0;
+    for (int iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are only used in the next iteration of the loop.
+      t1 |= iter >> 1;
+      t2 &= iter << 2;
+      t3 ^= iter >>> 3;
+      t4 += (byte)iter;
+      t5 -= (char)iter;
+      t6 += (short)iter;
+    }
+    return t1 | t2 | t3 | t4 | t5 | t6;
+  }
+
+  public static boolean verifyIntSingleUseLatencyLoop() {
+    final int expected = -1;
+    int found = timeIntSingleUseLatencyLoop(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeLongSingleUseLatency1(long iterations) {
+    long t1 = 0;
+    for (long iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+      t1 |= iter >> 1;
+      t1 &= iter << 2;
+      t1 ^= iter >>> 3;
+      t1 += (byte)iter;
+      t1 -= (char)iter;
+      t1 += (short)iter;
+    }
+    return t1;
+  }
+
+  public static boolean verifyLongSingleUseLatency1() {
+    long expected = 14;
+    long found = timeLongSingleUseLatency1(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  // The `ThreadN` suffix indicates that the loop contains `N` independent
+  // computation threads that execute (almost exactly) the same thing.  The
+  // multiple threads allow for instruction scheduling to kick in.
+  public static long timeLongSingleUseLatency1Thread2(long iterations) {
+    long t1 = 0, t2 = 1;
+    for (long iter1 = 0, iter2 = 1;
+         iter1 < iterations;
+         iter1++, iter2++) {
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+
+      // Computation thread 1.
+      t1 |= iter1 >> 1;
+      t1 &= iter1 << 2;
+      t1 ^= iter1 >>> 3;
+      t1 += (byte)iter1;
+      t1 -= (char)iter1;
+      t1 += (short)iter1;
+
+      // Computation thread 2.
+      t2 |= iter2 >> 1;
+      t2 &= iter2 << 2;
+      t2 ^= iter2 >>> 3;
+      t2 += (byte)iter2;
+      t2 -= (char)iter2;
+      t2 += (short)iter2;
+    }
+    return t1;
+  }
+
+  public static boolean verifyLongSingleUseLatency1Thread2() {
+    long expected = 14;
+    long found = timeLongSingleUseLatency1Thread2(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeLongSingleUseLatency1Thread3(long iterations) {
+    long t1 = 0, t2 = 1, t3 = 2;
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+
+    for (long iter1 = 0, iter2 = 1, iter3 = 2;
+         iter1 < iterations;
+         iter1++, iter2++, iter3++) {
+      // Computation thread 1.
+      t1 |= iter1 >> 1;
+      t1 &= iter1 << 2;
+      t1 ^= iter1 >>> 3;
+      t1 += (byte)iter1;
+      t1 -= (char)iter1;
+      t1 += (short)iter1;
+
+      // Computation thread 2.
+      t2 |= iter2 >> 1;
+      t2 &= iter2 << 2;
+      t2 ^= iter2 >>> 3;
+      t2 += (byte)iter2;
+      t2 -= (char)iter2;
+      t2 += (short)iter2;
+
+      // Computation thread 3.
+      t3 |= iter3 >> 1;
+      t3 &= iter3 << 2;
+      t3 ^= iter3 >>> 3;
+      t3 += (byte)iter3;
+      t3 -= (char)iter3;
+      t3 += (short)iter3;
+    }
+    return t1;
+  }
+
+  public static boolean verifyLongSingleUseLatency1Thread3() {
+    long expected = 14;
+    long found = timeLongSingleUseLatency1Thread3(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeLongSingleUseLatency1Thread4(long iterations) {
+    long t1 = 0, t2 = 1, t3 = 2, t4 = 3;
+      // Each bitfield operation has a single use.
+      // Results are used one instruction after being produced.
+
+    for (long iter1 = 0, iter2 = 1, iter3 = 2, iter4 = 3;
+         iter1 < iterations;
+         iter1++, iter2++, iter3++, iter4++) {
+      // Computation thread 1.
+      t1 |= iter1 >> 1;
+      t1 &= iter1 << 2;
+      t1 ^= iter1 >>> 3;
+      t1 += (byte)iter1;
+      t1 -= (char)iter1;
+      t1 += (short)iter1;
+
+      // Computation thread 2.
+      t2 |= iter2 >> 1;
+      t2 &= iter2 << 2;
+      t2 ^= iter2 >>> 3;
+      t2 += (byte)iter2;
+      t2 -= (char)iter2;
+      t2 += (short)iter2;
+
+      // Computation thread 3.
+      t3 |= iter3 >> 1;
+      t3 &= iter3 << 2;
+      t3 ^= iter3 >>> 3;
+      t3 += (byte)iter3;
+      t3 -= (char)iter3;
+      t3 += (short)iter3;
+
+      // Computation thread 4.
+      t4 |= iter4 >> 1;
+      t4 &= iter4 << 2;
+      t4 ^= iter4 >>> 3;
+      t4 += (byte)iter4;
+      t4 -= (char)iter4;
+      t4 += (short)iter4;
+    }
+    return t1;
+  }
+
+  public static boolean verifyLongSingleUseLatency1Thread4() {
+    long expected = 14;
+    long found = timeLongSingleUseLatency1Thread4(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeLongSingleUseLatency2(long iterations) {
+    long t1 = 0, t2 = 0;
+    for (long iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are used two instructions after being produced.
+      t1 |= iter >> 1;
+      t2 &= iter << 2;
+      t1 ^= iter >>> 3;
+      t2 += (byte)iter;
+      t1 -= (char)iter;
+      t2 += (short)iter;
+    }
+    return t1 | t2;
+  }
+
+  public static boolean verifyLongSingleUseLatency2() {
+    long expected = -5;
+    long found = timeLongSingleUseLatency2(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeLongSingleUseLatency3(long iterations) {
+    long t1 = 0, t2 = 0, t3 = 0;
+    for (long iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are used three instructions after being produced.
+      t1 |= iter >> 1;
+      t2 &= iter << 2;
+      t3 ^= iter >>> 3;
+      t1 += (byte)iter;
+      t2 -= (char)iter;
+      t3 += (short)iter;
+    }
+    return t1 | t2;
+  }
+
+  public static boolean verifyLongSingleUseLatency3() {
+    long expected = -1;
+    long found = timeLongSingleUseLatency3(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeLongSingleUseLatencyLoop(long iterations) {
+    long t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0;
+    for (long iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has a single use.
+      // Results are only used in the next iteration of the loop.
+      t1 |= iter >> 1;
+      t2 &= iter << 2;
+      t3 ^= iter >>> 3;
+      t4 += (byte)iter;
+      t5 -= (char)iter;
+      t6 += (short)iter;
+    }
+    return t1 | t2 | t3 | t4 | t5 | t6;
+  }
+
+  public static boolean verifyLongSingleUseLatencyLoop() {
+    long expected = -1;
+    long found = timeLongSingleUseLatencyLoop(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeMultipleUsesDifferentPathInt(int iterations) {
+    int res = 0;
+    for (int iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has two uses on different paths.
+      int temp1 = iter >> 1;
+      int temp2 = iter << 2;
+      int temp3 = iter >>> 3;
+      int temp4 = (byte)iter;
+      int temp5 = (char)iter;
+      int temp6 = (short)iter;
+      int temp7 = (int)iter;
+      // The condition is true most of the time, so the branch predictor should
+      // predict it correctly.
+      if (iter > 1) {
+        res += (((((temp1 | temp2) & temp3) ^ temp4) + temp5) - temp6) + temp7;
+      } else {
+        res += (((((temp1 + temp2) | temp3) & temp4) & temp5) + temp6) - temp7;
+      }
+    }
+    return res;
+  }
+
+  public static boolean verifyMultipleUsesDifferentPathInt() {
+    final int expected = 88;
+    int found = timeMultipleUsesDifferentPathInt(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeMultipleUsesDifferentPathLong(int iterations) {
+    long res = 0;
+    for (long iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has two uses on different paths.
+      long temp1 = iter >> 1;
+      long temp2 = iter << 2;
+      long temp3 = iter >>> 3;
+      long temp4 = (byte)iter;
+      long temp5 = (char)iter;
+      long temp6 = (short)iter;
+      long temp7 = (int)iter;
+      // The condition is true most of the time, so the branch predictor should
+      // predict it correctly.
+      if (iter > 1) {
+        res += (((((temp1 | temp2) & temp3) ^ temp4) + temp5) - temp6) + temp7;
+      } else {
+        res += (((((temp1 + temp2) | temp3) & temp4) & temp5) + temp6) - temp7;
+      }
+    }
+    return res;
+  }
+
+  public static boolean verifyMultipleUsesDifferentPathLong() {
+    long expected = 88;
+    long found = timeMultipleUsesDifferentPathLong(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeMultipleSuccessiveUsesSamePathInt(int iterations) {
+    int res = 0;
+    for (int iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has two successive uses on the same path.
+      int temp1 = iter >> 1;
+      res += temp1;
+      res += temp1;
+      int temp2 = iter << 2;
+      res += temp2;
+      res += temp2;
+      int temp3 = iter >>> 3;
+      res += temp3;
+      res += temp3;
+      int temp4 = (byte)iter;
+      res += temp4;
+      res += temp4;
+      int temp5 = (char)iter;
+      res += temp5;
+      res += temp5;
+      int temp6 = (short)iter;
+      res += temp6;
+      res += temp6;
+      int temp7 = (int)iter;
+      res += temp7;
+      res += temp7;
+    }
+    return res;
+  }
+
+  public static boolean verifyMultipleSuccessiveUsesSamePathInt() {
+    final int expected = 764;
+    int found = timeMultipleSuccessiveUsesSamePathInt(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeMultipleSuccessiveUsesSamePathLong(int iterations) {
+    long res = 0;
+    for (long iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has two successive uses on the same path.
+      long temp1 = iter >> 1;
+      res += temp1;
+      res += temp1;
+      long temp2 = iter << 2;
+      res += temp2;
+      res += temp2;
+      long temp3 = iter >>> 3;
+      res += temp3;
+      res += temp3;
+      long temp4 = (byte)iter;
+      res += temp4;
+      res += temp4;
+      long temp5 = (char)iter;
+      res += temp5;
+      res += temp5;
+      long temp6 = (short)iter;
+      res += temp6;
+      res += temp6;
+      long temp7 = (int)iter;
+      res += temp7;
+      res += temp7;
+    }
+    return res;
+  }
+
+  public static boolean verifyMultipleSuccessiveUsesSamePathLong() {
+    long expected = 764;
+    long found = timeMultipleSuccessiveUsesSamePathLong(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static int timeMultipleSeparatedUsesSamePathInt(int iterations) {
+    int res = 0;
+    for (int iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has two separated uses on the same path.
+      int temp1 = iter >> 1;
+      res += temp1;
+      int temp2 = iter << 2;
+      res += temp2;
+      res += temp1;
+      int temp3 = iter >>> 3;
+      res += temp3;
+      res += temp2;
+      int temp4 = (byte)iter;
+      res += temp4;
+      res += temp3;
+      int temp5 = (char)iter;
+      res += temp5;
+      res += temp4;
+      int temp6 = (short)iter;
+      res += temp6;
+      res += temp5;
+      int temp7 = (int)iter;
+      res += temp7;
+      res += temp6;
+      res += temp7;
+    }
+    return res;
+  }
+
+  public static boolean verifyMultipleSeparatedUsesSamePathInt() {
+    final int expected = 764;
+    int found = timeMultipleSeparatedUsesSamePathInt(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static long timeMultipleSeparatedUsesSamePathLong(int iterations) {
+    long res = 0;
+    for (long iter = 0; iter < iterations; iter++) {
+      // Each bitfield operation has two separated uses on the same path.
+      long temp1 = iter >> 1;
+      res += temp1;
+      long temp2 = iter << 2;
+      res += temp2;
+      res += temp1;
+      long temp3 = iter >>> 3;
+      res += temp3;
+      res += temp2;
+      long temp4 = (byte)iter;
+      res += temp4;
+      res += temp3;
+      long temp5 = (char)iter;
+      res += temp5;
+      res += temp4;
+      long temp6 = (short)iter;
+      res += temp6;
+      res += temp5;
+      long temp7 = (int)iter;
+      res += temp7;
+      res += temp6;
+      res += temp7;
+    }
+    return res;
+  }
+
+  public static boolean verifyMultipleSeparatedUsesSamePathLong() {
+    long expected = 764;
+    long found = timeMultipleSeparatedUsesSamePathLong(10);
+    if (expected != found) {
+      System.out.println("ERROR: Expected " + expected + " but found " + found);
+      return false;
+    }
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    int iterations = 100000;
+    long start;
+    long end;
+
+    String prefix = "art_benchmarks/micro/ShifterOperand/";
+
+    // CHECKSTYLE.OFF: LineLength
+    // CHECKSTYLE.OFF: OneStatementPerLine
+    // CHECKSTYLE.OFF: LeftCurly
+    start = System.currentTimeMillis(); timeIntSingleUseLatency1(50000000); end = System.currentTimeMillis();
+    if (!verifyIntSingleUseLatency1()) { rc++; }
+    System.out.println(prefix + "IntSingleUseLatency1: " + (end - start));
+    start = System.currentTimeMillis(); timeIntSingleUseLatency1Thread2(30000000); end = System.currentTimeMillis();
+    if (!verifyIntSingleUseLatency1Thread2()) { rc++; }
+    System.out.println(prefix + "IntSingleUseLatency1Thread2: " + (end - start));
+    start = System.currentTimeMillis(); timeIntSingleUseLatency1Thread3(20000000); end = System.currentTimeMillis();
+    if (!verifyIntSingleUseLatency1Thread3()) { rc++; }
+    System.out.println(prefix + "IntSingleUseLatency1Thread3: " + (end - start));
+    start = System.currentTimeMillis(); timeIntSingleUseLatency1Thread4(15000000); end = System.currentTimeMillis();
+    if (!verifyIntSingleUseLatency1Thread4()) { rc++; }
+    System.out.println(prefix + "IntSingleUseLatency1Thread4: " + (end - start));
+    start = System.currentTimeMillis(); timeIntSingleUseLatency2(40000000); end = System.currentTimeMillis();
+    if (!verifyIntSingleUseLatency2()) { rc++; }
+    System.out.println(prefix + "IntSingleUseLatency2: " + (end - start));
+    start = System.currentTimeMillis(); timeIntSingleUseLatency3(50000000); end = System.currentTimeMillis();
+    if (!verifyIntSingleUseLatency3()) { rc++; }
+    System.out.println(prefix + "IntSingleUseLatency3: " + (end - start));
+    start = System.currentTimeMillis(); timeIntSingleUseLatencyLoop(70000000); end = System.currentTimeMillis();
+    if (!verifyIntSingleUseLatencyLoop()) { rc++; }
+    System.out.println(prefix + "IntSingleUseLatencyLoop: " + (end - start));
+
+    // The `long` versions use the same iteration counts as the `int` versions
+    // above.
+    start = System.currentTimeMillis(); timeLongSingleUseLatency1(50000000); end = System.currentTimeMillis();
+    if (!verifyLongSingleUseLatency1()) { rc++; }
+    System.out.println(prefix + "LongSingleUseLatency1: " + (end - start));
+    start = System.currentTimeMillis(); timeLongSingleUseLatency1Thread2(30000000); end = System.currentTimeMillis();
+    if (!verifyLongSingleUseLatency1Thread2()) { rc++; }
+    System.out.println(prefix + "LongSingleUseLatency1Thread2: " + (end - start));
+    start = System.currentTimeMillis(); timeLongSingleUseLatency1Thread3(20000000); end = System.currentTimeMillis();
+    if (!verifyLongSingleUseLatency1Thread3()) { rc++; }
+    System.out.println(prefix + "LongSingleUseLatency1Thread3: " + (end - start));
+    start = System.currentTimeMillis(); timeLongSingleUseLatency1Thread4(15000000); end = System.currentTimeMillis();
+    if (!verifyLongSingleUseLatency1Thread4()) { rc++; }
+    System.out.println(prefix + "LongSingleUseLatency1Thread4: " + (end - start));
+    start = System.currentTimeMillis(); timeLongSingleUseLatency2(40000000); end = System.currentTimeMillis();
+    if (!verifyLongSingleUseLatency2()) { rc++; }
+    System.out.println(prefix + "LongSingleUseLatency2: " + (end - start));
+    start = System.currentTimeMillis(); timeLongSingleUseLatency3(50000000); end = System.currentTimeMillis();
+    if (!verifyLongSingleUseLatency3()) { rc++; }
+    System.out.println(prefix + "LongSingleUseLatency3: " + (end - start));
+    start = System.currentTimeMillis(); timeLongSingleUseLatencyLoop(70000000); end = System.currentTimeMillis();
+    if (!verifyLongSingleUseLatencyLoop()) { rc++; }
+    System.out.println(prefix + "LongSingleUseLatencyLoop: " + (end - start));
+
+
+    start = System.currentTimeMillis(); timeMultipleUsesDifferentPathInt(50000000); end = System.currentTimeMillis();
+    if (!verifyMultipleUsesDifferentPathInt()) { rc++; }
+    System.out.println(prefix + "MultipleUsesDifferentPathInt: " + (end - start));
+    start = System.currentTimeMillis(); timeMultipleSuccessiveUsesSamePathInt(35000000); end = System.currentTimeMillis();
+    if (!verifyMultipleSuccessiveUsesSamePathInt()) { rc++; }
+    System.out.println(prefix + "MultipleSuccessiveUsesSamePathInt: " + (end - start));
+    start = System.currentTimeMillis(); timeMultipleSeparatedUsesSamePathInt(40000000); end = System.currentTimeMillis();
+    if (!verifyMultipleSeparatedUsesSamePathInt()) { rc++; }
+    System.out.println(prefix + "MultipleSeparatedUsesSamePathInt: " + (end - start));
+
+    // The `long` versions use the same iteration counts as the `int` versions
+    // above.
+    start = System.currentTimeMillis(); timeMultipleUsesDifferentPathLong(50000000); end = System.currentTimeMillis();
+    if (!verifyMultipleUsesDifferentPathLong()) { rc++; }
+    System.out.println(prefix + "MultipleUsesDifferentPathLong: " + (end - start));
+    start = System.currentTimeMillis(); timeMultipleSuccessiveUsesSamePathLong(35000000); end = System.currentTimeMillis();
+    if (!verifyMultipleSuccessiveUsesSamePathLong()) { rc++; }
+    System.out.println(prefix + "MultipleSuccessiveUsesSamePathLong: " + (end - start));
+    start = System.currentTimeMillis(); timeMultipleSeparatedUsesSamePathLong(40000000); end = System.currentTimeMillis();
+    if (!verifyMultipleSeparatedUsesSamePathLong()) { rc++; }
+    System.out.println(prefix + "MultipleSeparatedUsesSamePathLong: " + (end - start));
+    // CHECKSTYLE.ON: LineLength
+    // CHECKSTYLE.ON: OneStatementPerLine
+    // CHECKSTYLE.ON: LeftCurly
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/StringEquals.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/StringEquals.java
new file mode 100644
index 0000000..012c92c
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/StringEquals.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Tracks performance of String.equals when working with
+ *                  cache-limiting amounts of character data. Some prefetch
+ *                  hint investigations have shown a performance gain here.
+ * Main Focus:      Comparison of many, very large (re: L1 cache) strings.
+ * Secondary Focus:
+ *
+ */
+
+/*
+ * TODO:            Test various sizes of strings.
+ * TODO:            Benchmark other cases, like comparing strings of different
+ *                  sizes together (probably the most command case), or similar
+ *                  strings that have a run of equal characters to begin with.
+ */
+
+package art_benchmarks.micro;
+
+import java.lang.StringBuilder;
+import java.util.Random;
+
+public class StringEquals {
+  private static Random rnd = new Random(0);
+  private static final int NUM_Equals = 1024;
+  private static final int STR_Length = 512;
+  private static String[] randomStrings = new String[NUM_Equals];
+  private static Boolean[] equalsResults = new Boolean[NUM_Equals - 1];
+
+  static {
+    generateRandomStrings();
+  }
+
+  private static void generateRandomStrings() {
+    for (int i = 0; i < NUM_Equals; i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 0; j < STR_Length; j++) {
+        sb.append(Character.valueOf((char)(rnd.nextInt(25) + 65)));
+      }
+      randomStrings[i] = sb.toString();
+    }
+  }
+
+  public void timeEquals(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int j = 0; j < NUM_Equals - 1; j++) {
+        equalsResults[j] = randomStrings[j].equals(randomStrings[j + 1]);
+      }
+    }
+  }
+
+  public static void main(String[] args) {
+    StringEquals eq = new StringEquals();
+    long before = System.currentTimeMillis();
+    eq.timeEquals(1500);
+    eq.timeEquals(1500);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/StringEquals: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/StringOps.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/StringOps.java
new file mode 100644
index 0000000..f406161
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/StringOps.java
@@ -0,0 +1,718 @@
+/*
+ * Copyright (C) 2016 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Tracks performance of String intrinsics, Java, and native methods.
+ * Main Focus:      Looped memory compare.
+ * Secondary Focus: Array access.
+ *
+ */
+
+package art_benchmarks.micro;
+
+import java.lang.StringBuilder;
+import java.lang.System;
+import java.util.Random;
+
+public class StringOps {
+
+  private static int RANDOM_STRING_8 = 0;
+  private static int RANDOM_STRING_16 = 1;
+  private static int RANDOM_STRING_32 = 2;
+  private static int RANDOM_STRING_128 = 3;
+  private static int RANDOM_STRING_512 = 4;
+  private static int NUM_LENGTH_TESTS = 5;
+
+  private static char MIN_RANDOM_CHAR = 65;
+  private static char MAX_RANDOM_CHAR = 123;
+  private static char searchChar;
+
+  /* Intentionally use the same seed each time for consistency across benchmark runs. */
+  private static int SAME_SEED = 0;
+
+  /* Random string data. */
+  private static Random rnd = new Random(SAME_SEED);
+  private static String[] stringData = new String[NUM_LENGTH_TESTS];
+
+  /* Same random string data as above for comparing different instances of the same char data. */
+  private static Random rndAlt = new Random(SAME_SEED);
+  private static String[] stringDataAlt = new String[NUM_LENGTH_TESTS];
+
+  /* Benchmark results cache for preventing DCE. */
+  private static boolean[] stringEqualsResults = new boolean[NUM_LENGTH_TESTS];
+  private static boolean[] stringEqualsIgnoreCaseResults = new boolean[NUM_LENGTH_TESTS];
+  private static boolean[] stringContentEqualsResults = new boolean[NUM_LENGTH_TESTS];
+  private static int[] stringCompareToResults = new int[NUM_LENGTH_TESTS];
+  private static int[] stringCompareToIgnoreCaseResults = new int[NUM_LENGTH_TESTS];
+  private static boolean[] stringRegionMatchesResults = new boolean[NUM_LENGTH_TESTS];
+  private static boolean[] stringRegionMatchesIgnoreCaseResults = new boolean[NUM_LENGTH_TESTS];
+  private static char stringCharAtResult;
+  private static int stringIndexOfResult;
+  private static int stringIndexOfAfterResult;
+  private static String[] stringNewStringFromBytesResult = new String[NUM_LENGTH_TESTS];
+  private static String[] stringNewStringFromCharsResult = new String[NUM_LENGTH_TESTS];
+  private static String[] stringNewStringFromStringResult = new String[NUM_LENGTH_TESTS];
+  private static String[] stringGetCharsNoCheckResult = new String[NUM_LENGTH_TESTS];
+
+  private static String generateRandomString(int len, Random rnd) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < len - 1; i++) {
+      /* Compose random string data from upper and lower case english alphabet entries plus a few
+       * harmless characters in-between. */
+      sb.append(Character.valueOf((char)(MIN_RANDOM_CHAR +
+                                         rnd.nextInt(MAX_RANDOM_CHAR - MIN_RANDOM_CHAR))));
+    }
+    sb.append(Character.valueOf(MAX_RANDOM_CHAR));
+    return sb.toString();
+  }
+
+  private static void generateRandomStrings(Random rnd, String[] output) {
+    output[RANDOM_STRING_8] = generateRandomString(8, rnd);
+    output[RANDOM_STRING_16] = generateRandomString(16, rnd);
+    output[RANDOM_STRING_32] = generateRandomString(32, rnd);
+    output[RANDOM_STRING_128] = generateRandomString(128, rnd);
+    output[RANDOM_STRING_512] = generateRandomString(512, rnd);
+  }
+
+  static {
+    searchChar = MAX_RANDOM_CHAR;
+    generateRandomStrings(rnd, stringData);
+    generateRandomStrings(rndAlt, stringDataAlt);
+  }
+
+  /**
+   * String.equals
+   */
+
+  public void timeStringEquals008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsResults[RANDOM_STRING_8]
+        ^= stringData[RANDOM_STRING_8].equals(stringDataAlt[RANDOM_STRING_8]);
+    }
+  }
+
+  public void timeStringEquals016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsResults[RANDOM_STRING_16]
+        ^= stringData[RANDOM_STRING_16].equals(stringDataAlt[RANDOM_STRING_16]);
+    }
+  }
+
+  public void timeStringEquals032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsResults[RANDOM_STRING_32]
+        ^= stringData[RANDOM_STRING_32].equals(stringDataAlt[RANDOM_STRING_32]);
+    }
+  }
+
+  public void timeStringEquals128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsResults[RANDOM_STRING_128]
+        ^= stringData[RANDOM_STRING_128].equals(stringDataAlt[RANDOM_STRING_128]);
+    }
+  }
+
+  public void timeStringEquals512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsResults[RANDOM_STRING_512]
+        ^= stringData[RANDOM_STRING_512].equals(stringDataAlt[RANDOM_STRING_512]);
+    }
+  }
+
+  /**
+   * String.equalsIgnoreCase
+   */
+
+  public void timeStringEqualsIgnoreCase008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsIgnoreCaseResults[RANDOM_STRING_8]
+        ^= stringData[RANDOM_STRING_8].equalsIgnoreCase(
+                stringDataAlt[RANDOM_STRING_8]);
+    }
+  }
+
+  public void timeStringEqualsIgnoreCase016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsIgnoreCaseResults[RANDOM_STRING_16]
+        ^= stringData[RANDOM_STRING_16].equalsIgnoreCase(
+                stringDataAlt[RANDOM_STRING_16]);
+    }
+  }
+
+  public void timeStringEqualsIgnoreCase032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsIgnoreCaseResults[RANDOM_STRING_32]
+        ^= stringData[RANDOM_STRING_32].equalsIgnoreCase(
+                stringDataAlt[RANDOM_STRING_32]);
+    }
+  }
+
+  public void timeStringEqualsIgnoreCase128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsIgnoreCaseResults[RANDOM_STRING_128]
+        ^= stringData[RANDOM_STRING_128].equalsIgnoreCase(
+                stringDataAlt[RANDOM_STRING_128]);
+    }
+  }
+
+  public void timeStringEqualsIgnoreCase512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringEqualsIgnoreCaseResults[RANDOM_STRING_512]
+        ^= stringData[RANDOM_STRING_512].equalsIgnoreCase(
+                stringDataAlt[RANDOM_STRING_512]);
+    }
+  }
+
+  /**
+   * String.contentEquals
+   */
+
+  public void timeStringContentEquals008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringContentEqualsResults[RANDOM_STRING_8]
+        ^= stringData[RANDOM_STRING_8].contentEquals(
+                stringDataAlt[RANDOM_STRING_8]);
+    }
+  }
+
+  public void timeStringContentEquals016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringContentEqualsResults[RANDOM_STRING_16]
+        ^= stringData[RANDOM_STRING_16].contentEquals(
+                stringDataAlt[RANDOM_STRING_16]);
+    }
+  }
+
+  public void timeStringContentEquals032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringContentEqualsResults[RANDOM_STRING_32]
+        ^= stringData[RANDOM_STRING_32].contentEquals(
+                stringDataAlt[RANDOM_STRING_32]);
+    }
+  }
+
+  public void timeStringContentEquals128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringContentEqualsResults[RANDOM_STRING_128]
+        ^= stringData[RANDOM_STRING_128].contentEquals(
+                stringDataAlt[RANDOM_STRING_128]);
+    }
+  }
+
+  public void timeStringContentEquals512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringContentEqualsResults[RANDOM_STRING_512]
+        ^= stringData[RANDOM_STRING_512].contentEquals(
+                stringDataAlt[RANDOM_STRING_512]);
+    }
+  }
+
+  /**
+   * String.compareTo
+   */
+
+  public void timeStringCompareTo008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToResults[RANDOM_STRING_8]
+        += stringData[RANDOM_STRING_8].compareTo(stringDataAlt[RANDOM_STRING_8]);
+    }
+  }
+
+  public void timeStringCompareTo016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToResults[RANDOM_STRING_16]
+        += stringData[RANDOM_STRING_16].compareTo(stringDataAlt[RANDOM_STRING_16]);
+    }
+  }
+
+  public void timeStringCompareTo032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToResults[RANDOM_STRING_32]
+        += stringData[RANDOM_STRING_32].compareTo(stringDataAlt[RANDOM_STRING_32]);
+    }
+  }
+
+  public void timeStringCompareTo128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToResults[RANDOM_STRING_128]
+        += stringData[RANDOM_STRING_128].compareTo(stringDataAlt[RANDOM_STRING_128]);
+    }
+  }
+
+  public void timeStringCompareTo512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToResults[RANDOM_STRING_512]
+        += stringData[RANDOM_STRING_512].compareTo(stringDataAlt[RANDOM_STRING_512]);
+    }
+  }
+
+  /**
+   * String.compareToIgnoreCase
+   */
+
+  public void timeStringCompareToIgnoreCase008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToIgnoreCaseResults[RANDOM_STRING_8]
+        += stringData[RANDOM_STRING_8].compareToIgnoreCase(
+                stringDataAlt[RANDOM_STRING_8]);
+    }
+  }
+
+  public void timeStringCompareToIgnoreCase016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToIgnoreCaseResults[RANDOM_STRING_16]
+        += stringData[RANDOM_STRING_16].compareToIgnoreCase(
+                stringDataAlt[RANDOM_STRING_16]);
+    }
+  }
+
+  public void timeStringCompareToIgnoreCase032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToIgnoreCaseResults[RANDOM_STRING_32]
+        += stringData[RANDOM_STRING_32].compareToIgnoreCase(
+                stringDataAlt[RANDOM_STRING_32]);
+    }
+  }
+
+  public void timeStringCompareToIgnoreCase128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToIgnoreCaseResults[RANDOM_STRING_128]
+        += stringData[RANDOM_STRING_128].compareToIgnoreCase(
+                stringDataAlt[RANDOM_STRING_128]);
+    }
+  }
+
+  public void timeStringCompareToIgnoreCase512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringCompareToIgnoreCaseResults[RANDOM_STRING_512]
+        += stringData[RANDOM_STRING_512].compareToIgnoreCase(
+                stringDataAlt[RANDOM_STRING_512]);
+    }
+  }
+
+  /**
+   * String.regionMatches
+   */
+
+  public void timeStringRegionMatches008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesResults[RANDOM_STRING_8]
+        ^= stringData[RANDOM_STRING_8].regionMatches(
+                0, stringDataAlt[RANDOM_STRING_8], 0, 8);
+    }
+  }
+
+  public void timeStringRegionMatches016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesResults[RANDOM_STRING_16]
+        ^= stringData[RANDOM_STRING_16].regionMatches(
+                0, stringDataAlt[RANDOM_STRING_16], 0, 16);
+    }
+  }
+
+  public void timeStringRegionMatches032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesResults[RANDOM_STRING_32]
+        ^= stringData[RANDOM_STRING_32].regionMatches(
+                0, stringDataAlt[RANDOM_STRING_32], 0, 32);
+    }
+  }
+
+  public void timeStringRegionMatches128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesResults[RANDOM_STRING_128]
+        ^= stringData[RANDOM_STRING_128].regionMatches(
+                0, stringDataAlt[RANDOM_STRING_128], 0, 128);
+    }
+  }
+
+  public void timeStringRegionMatches512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesResults[RANDOM_STRING_512]
+        ^= stringData[RANDOM_STRING_512].regionMatches(
+                0, stringDataAlt[RANDOM_STRING_512], 0, 512);
+    }
+  }
+
+  /**
+   * String.regionMatches
+   */
+
+  public void timeStringRegionMatchesIgnoreCase008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_8]
+        ^= stringData[RANDOM_STRING_8].regionMatches(
+                true, 0, stringDataAlt[RANDOM_STRING_8], 0, 8);
+    }
+  }
+
+  public void timeStringRegionMatchesIgnoreCase016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_16]
+        ^= stringData[RANDOM_STRING_16].regionMatches(
+                true, 0, stringDataAlt[RANDOM_STRING_16], 0, 16);
+    }
+  }
+
+  public void timeStringRegionMatchesIgnoreCase032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_32]
+        ^= stringData[RANDOM_STRING_32].regionMatches(
+                true, 0, stringDataAlt[RANDOM_STRING_32], 0, 32);
+    }
+  }
+
+  public void timeStringRegionMatchesIgnoreCase128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_128]
+        ^= stringData[RANDOM_STRING_128].regionMatches(
+                true, 0, stringDataAlt[RANDOM_STRING_128], 0, 128);
+    }
+  }
+
+  public void timeStringRegionMatchesIgnoreCase512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_512]
+        ^= stringData[RANDOM_STRING_512].regionMatches(
+                true, 0, stringDataAlt[RANDOM_STRING_512], 0, 512);
+    }
+  }
+
+  /**
+   * String.charAt
+   */
+
+  public void timeStringCharAt(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      for (int j = 0; j < 512; j++) {
+        stringCharAtResult = stringData[RANDOM_STRING_512].charAt(j);
+      }
+    }
+  }
+
+  /**
+   * String.indexOf
+   */
+
+  public void timeStringIndexOf008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfResult += stringData[RANDOM_STRING_8].indexOf(searchChar);
+    }
+  }
+
+  public void timeStringIndexOf016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfResult += stringData[RANDOM_STRING_16].indexOf(searchChar);
+    }
+  }
+
+  public void timeStringIndexOf032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfResult += stringData[RANDOM_STRING_32].indexOf(searchChar);
+    }
+  }
+
+  public void timeStringIndexOf128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfResult += stringData[RANDOM_STRING_128].indexOf(searchChar);
+    }
+  }
+
+  public void timeStringIndexOf512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfResult += stringData[RANDOM_STRING_512].indexOf(searchChar);
+    }
+  }
+
+  /**
+   * String.indexOfAfter
+   */
+
+  public void timeStringIndexOfAfter008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfAfterResult += stringData[RANDOM_STRING_8].indexOf(searchChar, 1);
+    }
+  }
+
+  public void timeStringIndexOfAfter016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfAfterResult += stringData[RANDOM_STRING_16].indexOf(searchChar, 1);
+    }
+  }
+
+  public void timeStringIndexOfAfter032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfAfterResult += stringData[RANDOM_STRING_32].indexOf(searchChar, 1);
+    }
+  }
+
+  public void timeStringIndexOfAfter128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfAfterResult += stringData[RANDOM_STRING_128].indexOf(searchChar, 1);
+    }
+  }
+
+  public void timeStringIndexOfAfter512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringIndexOfAfterResult += stringData[RANDOM_STRING_512].indexOf(searchChar, 1);
+    }
+  }
+
+  /**
+   * NewStringFromBytes
+   */
+
+  public void timeStringNewStringFromBytes008(int iterations) {
+    byte[] bytes = stringData[RANDOM_STRING_8].getBytes();
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromBytesResult[RANDOM_STRING_8] = new String(bytes);
+    }
+  }
+
+  public void timeStringNewStringFromBytes016(int iterations) {
+    byte[] bytes = stringData[RANDOM_STRING_16].getBytes();
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromBytesResult[RANDOM_STRING_16] = new String(bytes);
+    }
+  }
+
+  public void timeStringNewStringFromBytes032(int iterations) {
+    byte[] bytes = stringData[RANDOM_STRING_32].getBytes();
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromBytesResult[RANDOM_STRING_32] = new String(bytes);
+    }
+  }
+
+  public void timeStringNewStringFromBytes128(int iterations) {
+    byte[] bytes = stringData[RANDOM_STRING_128].getBytes();
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromBytesResult[RANDOM_STRING_128] = new String(bytes);
+    }
+  }
+
+  public void timeStringNewStringFromBytes512(int iterations) {
+    byte[] bytes = stringData[RANDOM_STRING_512].getBytes();
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromBytesResult[RANDOM_STRING_512] = new String(bytes);
+    }
+  }
+
+  /**
+   * NewStringFromChars
+   */
+
+  public void timeStringNewStringFromChars008(int iterations) {
+    char[] chars = new char[8];
+    stringData[RANDOM_STRING_8].getChars(0, 8, chars, 0);
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromCharsResult[RANDOM_STRING_8] = new String(chars);
+    }
+  }
+
+  public void timeStringNewStringFromChars016(int iterations) {
+    char[] chars = new char[16];
+    stringData[RANDOM_STRING_16].getChars(0, 16, chars, 0);
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromCharsResult[RANDOM_STRING_16] = new String(chars);
+    }
+  }
+
+  public void timeStringNewStringFromChars032(int iterations) {
+    char[] chars = new char[32];
+    stringData[RANDOM_STRING_32].getChars(0, 32, chars, 0);
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromCharsResult[RANDOM_STRING_32] = new String(chars);
+    }
+  }
+
+  public void timeStringNewStringFromChars128(int iterations) {
+    char[] chars = new char[128];
+    stringData[RANDOM_STRING_128].getChars(0, 128, chars, 0);
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromCharsResult[RANDOM_STRING_128] = new String(chars);
+    }
+  }
+
+  public void timeStringNewStringFromChars512(int iterations) {
+    char[] chars = new char[512];
+    stringData[RANDOM_STRING_512].getChars(0, 512, chars, 0);
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromCharsResult[RANDOM_STRING_512] = new String(chars);
+    }
+  }
+
+  /**
+   * NewStringFromString
+   */
+
+  public void timeStringNewStringFromString008(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromStringResult[RANDOM_STRING_8] =
+          new String(stringData[RANDOM_STRING_8]);
+    }
+  }
+
+  public void timeStringNewStringFromString016(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromStringResult[RANDOM_STRING_16] =
+          new String(stringData[RANDOM_STRING_16]);
+    }
+  }
+
+  public void timeStringNewStringFromString032(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromStringResult[RANDOM_STRING_32] =
+          new String(stringData[RANDOM_STRING_32]);
+    }
+  }
+
+  public void timeStringNewStringFromString128(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromStringResult[RANDOM_STRING_128] =
+          new String(stringData[RANDOM_STRING_128]);
+    }
+  }
+
+  public void timeStringNewStringFromString512(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      stringNewStringFromStringResult[RANDOM_STRING_512] =
+          new String(stringData[RANDOM_STRING_512]);
+    }
+  }
+
+  /**
+   * String.getCharsNoCheck
+   */
+
+  public void timeStringGetCharsNoCheck008(int iterations) {
+    char[] chars = new char[8];
+    for (int i = 0; i < iterations; i++) {
+      stringData[RANDOM_STRING_8].getChars(0, 8, chars, 0);
+    }
+    stringGetCharsNoCheckResult[RANDOM_STRING_8] = new String(chars);
+  }
+
+  public void timeStringGetCharsNoCheck016(int iterations) {
+    char[] chars = new char[16];
+    for (int i = 0; i < iterations; i++) {
+      stringData[RANDOM_STRING_16].getChars(0, 16, chars, 0);
+    }
+    stringGetCharsNoCheckResult[RANDOM_STRING_16] = new String(chars);
+  }
+
+  public void timeStringGetCharsNoCheck032(int iterations) {
+    char[] chars = new char[32];
+    for (int i = 0; i < iterations; i++) {
+      stringData[RANDOM_STRING_32].getChars(0, 32, chars, 0);
+    }
+    stringGetCharsNoCheckResult[RANDOM_STRING_32] = new String(chars);
+  }
+
+  public void timeStringGetCharsNoCheck128(int iterations) {
+    char[] chars = new char[128];
+    for (int i = 0; i < iterations; i++) {
+      stringData[RANDOM_STRING_128].getChars(0, 128, chars, 0);
+    }
+    stringGetCharsNoCheckResult[RANDOM_STRING_128] = new String(chars);
+  }
+
+  public void timeStringGetCharsNoCheck512(int iterations) {
+    char[] chars = new char[512];
+    for (int i = 0; i < iterations; i++) {
+      stringData[RANDOM_STRING_512].getChars(0, 512, chars, 0);
+    }
+    stringGetCharsNoCheckResult[RANDOM_STRING_512] = new String(chars);
+  }
+
+  private static final int ITER_COUNT = 22000;
+
+  public static void main(String[] args) {
+    int result = 0;
+    StringOps obj = new StringOps();
+    long before = System.currentTimeMillis();
+    obj.timeStringEquals008(ITER_COUNT);
+    obj.timeStringEquals016(ITER_COUNT);
+    obj.timeStringEquals032(ITER_COUNT);
+    obj.timeStringEquals128(ITER_COUNT);
+    obj.timeStringEquals512(ITER_COUNT);
+    obj.timeStringEqualsIgnoreCase008(ITER_COUNT);
+    obj.timeStringEqualsIgnoreCase016(ITER_COUNT);
+    obj.timeStringEqualsIgnoreCase032(ITER_COUNT);
+    obj.timeStringEqualsIgnoreCase128(ITER_COUNT);
+    obj.timeStringEqualsIgnoreCase512(ITER_COUNT);
+    obj.timeStringContentEquals008(ITER_COUNT);
+    obj.timeStringContentEquals016(ITER_COUNT);
+    obj.timeStringContentEquals032(ITER_COUNT);
+    obj.timeStringContentEquals128(ITER_COUNT);
+    obj.timeStringContentEquals512(ITER_COUNT);
+    obj.timeStringCompareTo008(ITER_COUNT);
+    obj.timeStringCompareTo016(ITER_COUNT);
+    obj.timeStringCompareTo032(ITER_COUNT);
+    obj.timeStringCompareTo128(ITER_COUNT);
+    obj.timeStringCompareTo512(ITER_COUNT);
+    obj.timeStringCompareToIgnoreCase008(ITER_COUNT);
+    obj.timeStringCompareToIgnoreCase016(ITER_COUNT);
+    obj.timeStringCompareToIgnoreCase032(ITER_COUNT);
+    obj.timeStringCompareToIgnoreCase128(ITER_COUNT);
+    obj.timeStringCompareToIgnoreCase512(ITER_COUNT);
+    obj.timeStringRegionMatches008(ITER_COUNT);
+    obj.timeStringRegionMatches016(ITER_COUNT);
+    obj.timeStringRegionMatches032(ITER_COUNT);
+    obj.timeStringRegionMatches128(ITER_COUNT);
+    obj.timeStringRegionMatches512(ITER_COUNT);
+    obj.timeStringRegionMatchesIgnoreCase008(ITER_COUNT);
+    obj.timeStringRegionMatchesIgnoreCase016(ITER_COUNT);
+    obj.timeStringRegionMatchesIgnoreCase032(ITER_COUNT);
+    obj.timeStringRegionMatchesIgnoreCase128(ITER_COUNT);
+    obj.timeStringRegionMatchesIgnoreCase512(ITER_COUNT);
+    obj.timeStringCharAt(ITER_COUNT);
+    obj.timeStringIndexOf008(ITER_COUNT);
+    obj.timeStringIndexOf016(ITER_COUNT);
+    obj.timeStringIndexOf032(ITER_COUNT);
+    obj.timeStringIndexOf128(ITER_COUNT);
+    obj.timeStringIndexOf512(ITER_COUNT);
+    obj.timeStringIndexOfAfter008(ITER_COUNT);
+    obj.timeStringIndexOfAfter016(ITER_COUNT);
+    obj.timeStringIndexOfAfter032(ITER_COUNT);
+    obj.timeStringIndexOfAfter128(ITER_COUNT);
+    obj.timeStringIndexOfAfter512(ITER_COUNT);
+    obj.timeStringNewStringFromBytes008(ITER_COUNT);
+    obj.timeStringNewStringFromBytes016(ITER_COUNT);
+    obj.timeStringNewStringFromBytes032(ITER_COUNT);
+    obj.timeStringNewStringFromBytes128(ITER_COUNT);
+    obj.timeStringNewStringFromBytes512(ITER_COUNT);
+    obj.timeStringNewStringFromChars008(ITER_COUNT);
+    obj.timeStringNewStringFromChars016(ITER_COUNT);
+    obj.timeStringNewStringFromChars032(ITER_COUNT);
+    obj.timeStringNewStringFromChars128(ITER_COUNT);
+    obj.timeStringNewStringFromChars512(ITER_COUNT);
+    obj.timeStringNewStringFromString008(ITER_COUNT);
+    obj.timeStringNewStringFromString016(ITER_COUNT);
+    obj.timeStringNewStringFromString032(ITER_COUNT);
+    obj.timeStringNewStringFromString128(ITER_COUNT);
+    obj.timeStringNewStringFromString512(ITER_COUNT);
+    obj.timeStringGetCharsNoCheck008(ITER_COUNT);
+    obj.timeStringGetCharsNoCheck016(ITER_COUNT);
+    obj.timeStringGetCharsNoCheck032(ITER_COUNT);
+    obj.timeStringGetCharsNoCheck128(ITER_COUNT);
+    obj.timeStringGetCharsNoCheck512(ITER_COUNT);
+
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/StringOps: " + (after - before));
+    System.exit(result);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/SystemArrayCopy.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/SystemArrayCopy.java
new file mode 100644
index 0000000..d88b54a
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/SystemArrayCopy.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2016 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Tracks performance of System.arraycopy intrinsics.
+ * Main Focus:      Looped load store for varying copy lengths.
+ * Secondary Focus:
+ *
+ */
+
+package art_benchmarks.micro;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.StringBuilder;
+import java.lang.System;
+import java.util.Random;
+
+public class SystemArrayCopy {
+
+  private static Random rnd = new Random();
+  private static int ARRAY_COPY_SMALL = 16;
+  private static int ARRAY_COPY_MEDIUM = 128;
+  private static int ARRAY_COPY_LARGE = 1024;
+  private static int MAX_BUFFER_BYTES = 8192;
+  private static int ARRAY_LENGTH = 1024;
+  private static String RANDOM_STRING = generateRandomString(MAX_BUFFER_BYTES);
+  private static char[] cbuf = new char[MAX_BUFFER_BYTES];
+  private static char arrayCopyCharBufferedReadSmallResult;
+  private static char arrayCopyCharBufferedReadMediumResult;
+  private static char arrayCopyCharBufferedReadLargeResult;
+
+  private static String[] stringArray = new String[ARRAY_LENGTH];
+  private static String[] stringArraySmall = new String[ARRAY_LENGTH];
+  private static String[] stringArrayMedium = new String[ARRAY_LENGTH];
+  private static String[] stringArrayLarge = new String[ARRAY_LENGTH];
+
+  private static String generateRandomString(int sz) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < sz; i++) {
+      sb.append(Character.valueOf((char)rnd.nextInt()));
+    }
+    return sb.toString();
+  }
+
+  static {
+    for (int i = 0; i < ARRAY_LENGTH; i++) {
+      stringArray[i] = String.valueOf(i);
+    }
+  }
+
+  private void bufferedReadLoop(char[] cbuf, int copyLength) throws IOException {
+    BufferedReader reader = new BufferedReader(new StringReader(RANDOM_STRING));
+    int offset = 0;
+    String s;
+    /* Read 16Kb RANDOM_STRING in chunks of copyLength chars until EOF */
+    while (offset < MAX_BUFFER_BYTES && (reader.read(cbuf, offset, copyLength)) != -1) {
+      offset += copyLength;
+    }
+  }
+
+  public boolean verify() throws IOException {
+    boolean result = true;
+
+    timeArrayCopySmall(1);
+    for (int i = 0; i < ARRAY_COPY_SMALL; i++) {
+      result &= stringArray[i].equals(stringArraySmall[i]);
+    }
+
+    timeArrayCopyMedium(1);
+    for (int i = 0; i < ARRAY_COPY_MEDIUM; i++) {
+      result &= stringArray[i].equals(stringArrayMedium[i]);
+    }
+
+    timeArrayCopyLarge(1);
+    for (int i = 0; i < ARRAY_COPY_LARGE; i++) {
+      result &= stringArray[i].equals(stringArrayLarge[i]);
+    }
+
+    result &= arrayCopyCharBufferedReadSmallResult == RANDOM_STRING.charAt(MAX_BUFFER_BYTES - 1);
+    result &= arrayCopyCharBufferedReadMediumResult == RANDOM_STRING.charAt(MAX_BUFFER_BYTES - 1);
+    result &= arrayCopyCharBufferedReadLargeResult == RANDOM_STRING.charAt(MAX_BUFFER_BYTES - 1);
+    return result;
+  }
+
+  public void timeArrayCopyCharBufferedReadSmall(int iterations) throws IOException {
+    for (int i = 0; i < iterations; i++) {
+      bufferedReadLoop(cbuf, ARRAY_COPY_SMALL);
+      arrayCopyCharBufferedReadSmallResult = cbuf[MAX_BUFFER_BYTES - 1];
+    }
+  }
+
+  public void timeArrayCopyCharBufferedReadMedium(int iterations) throws IOException {
+    for (int i = 0; i < iterations; i++) {
+      bufferedReadLoop(cbuf, ARRAY_COPY_MEDIUM);
+      arrayCopyCharBufferedReadMediumResult = cbuf[MAX_BUFFER_BYTES - 1];
+    }
+  }
+
+  public void timeArrayCopyCharBufferedReadLarge(int iterations) throws IOException {
+    for (int i = 0; i < iterations; i++) {
+      bufferedReadLoop(cbuf, ARRAY_COPY_LARGE);
+      arrayCopyCharBufferedReadLargeResult = cbuf[MAX_BUFFER_BYTES - 1];
+    }
+  }
+
+  public void timeArrayCopySmall(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      System.arraycopy(stringArray, 0, stringArraySmall, 0, ARRAY_COPY_SMALL);
+    }
+  }
+
+  public void timeArrayCopyMedium(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      System.arraycopy(stringArray, 0, stringArrayMedium, 0, ARRAY_COPY_MEDIUM);
+    }
+  }
+
+  public void timeArrayCopyLarge(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      System.arraycopy(stringArray, 0, stringArrayLarge, 0, ARRAY_COPY_LARGE);
+    }
+  }
+
+  private static final int ITER_COUNT = 4000;
+
+  public static void main(String[] args) {
+    int result = 0;
+    SystemArrayCopy obj = new SystemArrayCopy();
+    final long before = System.currentTimeMillis();
+    try {
+      obj.timeArrayCopySmall(ITER_COUNT);
+      obj.timeArrayCopyMedium(ITER_COUNT);
+      obj.timeArrayCopyLarge(ITER_COUNT);
+
+      obj.timeArrayCopyCharBufferedReadSmall(ITER_COUNT);
+      obj.timeArrayCopyCharBufferedReadMedium(ITER_COUNT);
+      obj.timeArrayCopyCharBufferedReadLarge(ITER_COUNT);
+      if (!obj.verify()) {
+        result++;
+        System.out.println("ERROR: verify() failed.");
+      }
+    } catch (IOException ex) {
+      System.out.println("ERROR: benchmarks/micro/SystemArrayCopy: " + ex.getMessage());
+    }
+    final long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/SystemArrayCopy: " + (after - before));
+    System.exit(result);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/VectorCalc.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/VectorCalc.java
new file mode 100644
index 0000000..42c6cf5
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/VectorCalc.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2015 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Some generic vector operations.
+ * Main Focus:      Boundary checks in loops
+ * Secondary Focus: Array access, load/store.
+ *
+ */
+
+package art_benchmarks.micro;
+
+public class VectorCalc {
+
+  public static final int ARRAY_SIZE = 500;
+  public static final int COEFFICIENT = 2;
+  public static final int MAIN_ITERATIONS = 80000;
+  public int[] array1 = new int[ARRAY_SIZE];
+  public int[] array2 = new int[ARRAY_SIZE];
+  public int[] array3 = new int[ARRAY_SIZE];
+
+  // index : loop induction variable + loop invariable
+  public void setArrayValues(int[] array, int start, int length, int startValue, int step) {
+    for (int i = 0, value = startValue; i < length; ++i, value += step) {
+      array[i + start] = value;
+    }
+  }
+
+  // index : loop induction variable
+  // multiple arrays
+  public void copyArray(int[] dst, int[] src, int start, int length) {
+    for (int i = start, end = start + length; i < end; ++i) {
+      dst[i] = src[i];
+    }
+  }
+
+  // index : loop induction variable + loop invariable
+  // multiple arrays
+  public void scaleProduct(int[] dst, int[] src, int start, int length, int coefficient) {
+    for (int i = 0; i < length; ++i) {
+      dst[i + start] = coefficient * src[i + start];
+    }
+  }
+
+  // index-1 : loop induction variable
+  // index-2 : loop invariable
+  // multiple arrays
+  public void dotProduct(int[] src1, int[] src2, int start, int length, int[] output,
+                         int outputOffset) {
+    for (int i = start, end = start + length; i < end; ++i) {
+      output[outputOffset] += src1[i] * src2[i];
+    }
+  }
+
+  public void timeRun(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      setArrayValues(array1, 0, ARRAY_SIZE, 0, 1);
+      copyArray(array2, array1, 0, ARRAY_SIZE);
+      scaleProduct(array3, array1, 0, ARRAY_SIZE, COEFFICIENT);
+      dotProduct(array2, array3, 0, ARRAY_SIZE, array1, 0);
+    }
+  }
+
+  public boolean verify() {
+    return array1[0] == COEFFICIENT * (ARRAY_SIZE - 1) * ARRAY_SIZE * (2 * ARRAY_SIZE - 1) / 6;
+  }
+
+  public static void main(String[] args) {
+    VectorCalc obj = new VectorCalc();
+    long before = System.currentTimeMillis();
+    obj.timeRun(MAIN_ITERATIONS);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/VectorCalc: " + (after - before));
+  }
+
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/CRC32Bench.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/CRC32Bench.java
new file mode 100644
index 0000000..d70a992
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/CRC32Bench.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2016 Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Simple loops around CRC32 intrinsics.
+ * Main Focus:      CRC32-related intrinsics.
+ */
+
+package art_benchmarks.micro.intrinsics;
+
+import java.util.Random;
+import java.util.zip.CRC32;
+
+public class CRC32Bench {
+  private byte []bytes = new byte[8192];
+  private CRC32 crc32 = new CRC32();
+  private static final int iterCount = 100;
+  private static final int loopSize = 3000;
+
+  public CRC32Bench() {
+    Random rnd = new Random(0);
+    rnd.nextBytes(bytes);
+  }
+
+  public void timeUpdateInt(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      benchUpdateInt();
+    }
+  }
+
+  public void timeUpdateBytes(int iterations) {
+    for (int i = 0; i < iterations; i++) {
+      benchUpdateBytes();
+    }
+  }
+
+  public void benchUpdateInt() {
+    int count = loopSize * 230;
+    crc32.reset();
+    for (int i = 0; i < count; i++) {
+      crc32.update(i);
+    }
+  }
+
+  public void benchUpdateBytes() {
+    crc32.reset();
+
+    for (int i = 0; i < loopSize; i++) {
+      crc32.update(bytes);
+    }
+  }
+
+  public boolean verifyCRC32Bench() {
+    byte []tmp = new String("Linaro ART Team 2016.").getBytes();
+
+    crc32.reset();
+    crc32.update(2016);
+    if (crc32.getValue() != 0x72080DF5L) {
+      return false;
+    }
+
+    crc32.reset();
+    crc32.update(tmp, 0, tmp.length - 1);
+    if (crc32.getValue() != 0x7A7583F7L) {
+      return false;
+    }
+
+    crc32.reset();
+    crc32.update(tmp);
+    if (crc32.getValue() != 0x2D77F07EL) {
+      return false;
+    }
+
+    return true;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    CRC32Bench obj = new CRC32Bench();
+
+    long before = System.currentTimeMillis();
+    obj.timeUpdateInt(iterCount);
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/intrinsics/CRC32Bench/UpdateInt: " + (after - before));
+
+    before = System.currentTimeMillis();
+    obj.timeUpdateBytes(iterCount);
+    after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/intrinsics/CRC32Bench/UpdateBytes: " + (after - before));
+
+    if (!obj.verifyCRC32Bench()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/Intrinsics.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/Intrinsics.java
new file mode 100644
index 0000000..e874a1f
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/Intrinsics.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2015, ARM Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package art_benchmarks.micro.intrinsics;
+
+import java.lang.System;
+import java.util.Random;
+
+public class Intrinsics {
+
+  /* Invoke each intrinsic in question the same no. of times */
+  private static final int NUM_INVOKES = 64;
+
+  /* Random pool size.
+   * Use a power of two to make the modulo operations below fast. */
+  private static final int NUM_RANDS = 1024;
+
+  /* Pre-allocated pool of random integers from [0, Integer.MAX_VALUE) */
+  private static final int[] rand = new int[NUM_RANDS];
+
+  static {
+    // Allocate a pool of random integers to use in benchmarks that
+    // want to try and force branch mispredicts without the overhead
+    // of calling random.nextInt in times code. Same seed every time.
+    Random random = new Random(42L);
+    for (int i = 0; i < NUM_RANDS; i++) {
+      rand[i] = random.nextInt(Integer.MAX_VALUE);
+    }
+  }
+
+  /**
+   * NumberOfLeadingZeros.
+   **/
+
+  private static int[] resultsNumberOfLeadingZerosInteger = new int[NUM_INVOKES];
+  private static int[] resultsNumberOfLeadingZerosLong = new int[NUM_INVOKES];
+  private static int[] resultsNumberOfLeadingZerosIntegerRandom = new int[NUM_INVOKES];
+  private static int[] resultsNumberOfLeadingZerosLongRandom = new int[NUM_INVOKES];
+
+  public void timeNumberOfLeadingZerosInteger(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfLeadingZerosInteger[i] =
+          Integer.numberOfLeadingZeros(0x80000000 >>> i);
+      }
+    }
+  }
+
+  public void timeNumberOfLeadingZerosLong(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfLeadingZerosLong[i] =
+          Long.numberOfLeadingZeros(0x8000000000000000L >>> i);
+      }
+    }
+  }
+
+  public void timeNumberOfLeadingZerosIntegerRandom(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfLeadingZerosIntegerRandom[i] =
+          Integer.numberOfLeadingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]);
+      }
+    }
+  }
+
+  public void timeNumberOfLeadingZerosLongRandom(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfLeadingZerosLongRandom[i] =
+          Long.numberOfLeadingZeros(1 << (rand[i % NUM_RANDS] % Long.SIZE));
+      }
+    }
+  }
+
+  /**
+   * NumberOfTrailingZeros.
+   **/
+
+  private static int[] resultsNumberOfTrailingZerosInteger = new int[NUM_INVOKES];
+  private static int[] resultsNumberOfTrailingZerosLong = new int[NUM_INVOKES];
+  private static int[] resultsNumberOfTrailingZerosIntegerRandom = new int[NUM_INVOKES];
+  private static int[] resultsNumberOfTrailingZerosLongRandom = new int[NUM_INVOKES];
+
+  public void timeNumberOfTrailingZerosInteger(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfTrailingZerosInteger[i] =
+          Integer.numberOfTrailingZeros(0x80000000 >>> i);
+      }
+    }
+  }
+
+  public void timeNumberOfTrailingZerosLong(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfTrailingZerosLong[i] =
+          Long.numberOfTrailingZeros(0x8000000000000000L >>> i);
+      }
+    }
+  }
+
+  public void timeNumberOfTrailingZerosIntegerRandom(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfTrailingZerosIntegerRandom[i] =
+          Integer.numberOfTrailingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]);
+      }
+    }
+  }
+
+  public void timeNumberOfTrailingZerosLongRandom(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsNumberOfTrailingZerosLongRandom[i] =
+          Long.numberOfTrailingZeros(1 << (rand[i % NUM_RANDS] % Long.SIZE));
+      }
+    }
+  }
+
+  /**
+   * BitCount.
+   **/
+
+  // both Integer and Long's bitCount() return int type.
+  private static int[] resultsBitCountInteger = new int[NUM_INVOKES];
+  private static int[] resultsBitCountLong = new int[NUM_INVOKES];
+  private static int[] resultsBitCountIntegerRandom = new int[NUM_INVOKES];
+  private static int[] resultsBitCountLongRandom = new int[NUM_INVOKES];
+
+  public void timeBitCountInteger(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsBitCountInteger[i] = Integer.bitCount(0x1234abcd);
+      }
+    }
+  }
+
+  public void timeBitCountLong(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsBitCountLong[i] = Long.bitCount(0x1234abcd1234abcdL);
+      }
+    }
+  }
+
+  public void timeBitCountIntegerRandom(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsBitCountIntegerRandom[i] = Integer.bitCount(rand[i % NUM_RANDS]);
+      }
+    }
+  }
+
+  public void timeBitCountLongRandom(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsBitCountLongRandom[i] =
+          Long.bitCount((long)rand[i % NUM_RANDS] << 32 + rand[i % NUM_RANDS]);
+      }
+    }
+  }
+
+  /**
+   * RotateRight.
+   **/
+
+  private static int[] resultsRotateRightInteger = new int[NUM_INVOKES];
+  private static int[] resultsRotateRightIntegerConstant = new int[NUM_INVOKES];
+  private static long[] resultsRotateRightLong = new long[NUM_INVOKES];
+  private static long[] resultsRotateRightLongConstant = new long[NUM_INVOKES];
+
+  public void timeRotateRightInteger(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateRightInteger[i] = Integer.rotateRight(0xFF0000DD, i);
+      }
+    }
+  }
+
+  public void timeRotateRightIntegerConstant(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateRightIntegerConstant[i] = Integer.rotateRight(0xFF0000DD, 16);
+      }
+    }
+  }
+
+  public void timeRotateRightLong(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateRightLong[i] = Long.rotateRight(0xBBAAAADDFF0000DDL, i);
+      }
+    }
+  }
+
+  public void timeRotateRightLongConstant(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateRightLongConstant[i] = Long.rotateRight(0xBBAAAADDFF0000DDL, 48);
+      }
+    }
+  }
+
+  /**
+   * RotateLeft.
+   **/
+
+  private static int[] resultsRotateLeftInteger = new int[NUM_INVOKES];
+  private static int[] resultsRotateLeftIntegerConstant = new int[NUM_INVOKES];
+  private static long[] resultsRotateLeftLong = new long[NUM_INVOKES];
+  private static long[] resultsRotateLeftLongConstant = new long[NUM_INVOKES];
+
+  public void timeRotateLeftInteger(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateLeftInteger[i] = Integer.rotateLeft(0xFF0000DD, i);
+      }
+    }
+  }
+
+  public void timeRotateLeftIntegerConstant(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateLeftIntegerConstant[i] = Integer.rotateLeft(0xFF0000DD, 16);
+      }
+    }
+  }
+
+  public void timeRotateLeftLong(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateLeftLong[i] = Long.rotateLeft(0xBBAAAADDFF0000DDL, i);
+      }
+    }
+  }
+
+  public void timeRotateLeftLongConstant(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateLeftLongConstant[i] = Long.rotateLeft(0xBBAAAADDFF0000DDL, 48);
+      }
+    }
+  }
+
+  /**
+   * RotateRandom.
+   **/
+
+  private static int[] resultsRotateRandomInteger = new int[NUM_INVOKES];
+  private static long[] resultsRotateRandomLong = new long[NUM_INVOKES];
+
+  public void timeRotateRandomInteger(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateRandomInteger[i] = (rand[i % NUM_RANDS] % 2 > 0)
+          ? Integer.rotateLeft(0xFF0000DD, rand[i % NUM_RANDS])
+          : Integer.rotateRight(0xFF0000DD, rand[i % NUM_RANDS]);
+      }
+    }
+  }
+
+  public void timeRotateRandomLong(int iterations) {
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        resultsRotateRandomLong[i] = (rand[i % NUM_RANDS] % 2 > 0)
+          ? Long.rotateLeft(0xBBAAAADDFF0000DDL, rand[i % NUM_RANDS])
+          : Long.rotateRight(0xBBAAAADDFF0000DDL, rand[i % NUM_RANDS]);
+      }
+    }
+  }
+
+  /**
+   * Verify.
+   **/
+
+  /**
+   * Called by the framework to assert the benchmarks have done the right thing.
+   **/
+  public boolean verify() {
+    return true;
+  }
+
+  /**
+   * *NOT* called by the framework by default, provided for direct use only.
+   **/
+  public static void main(String[] args) {
+    Intrinsics obj = new Intrinsics();
+    long before = System.currentTimeMillis();
+    obj.timeNumberOfLeadingZerosInteger(100000);
+    obj.timeNumberOfLeadingZerosIntegerRandom(100000);
+    obj.timeNumberOfLeadingZerosLong(100000);
+    obj.timeNumberOfLeadingZerosLongRandom(100000);
+
+    obj.timeNumberOfTrailingZerosInteger(100000);
+    obj.timeNumberOfTrailingZerosIntegerRandom(100000);
+    obj.timeNumberOfTrailingZerosLong(100000);
+    obj.timeNumberOfTrailingZerosLongRandom(100000);
+
+    obj.timeRotateRightInteger(100000);
+    obj.timeRotateRightLong(100000);
+    obj.timeRotateLeftInteger(100000);
+    obj.timeRotateLeftLong(100000);
+
+    obj.timeRotateRandomInteger(100000);
+    obj.timeRotateRandomLong(100000);
+
+    obj.timeBitCountInteger(100000);
+    obj.timeBitCountLong(100000);
+    obj.timeBitCountIntegerRandom(100000);
+    obj.timeBitCountLongRandom(100000);
+
+    long after = System.currentTimeMillis();
+    System.out.println("art_benchmarks/micro/intrinsics/Intrinsics: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/Rounding.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/Rounding.java
new file mode 100644
index 0000000..c2061ca
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/micro/intrinsics/Rounding.java
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2016, Linaro Limited. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Description:     Simple loops around rounding-related intrinsics.
+ * Main Focus:      Rounding-related intrinsics.
+ */
+
+package art_benchmarks.micro.intrinsics;
+
+import java.lang.System;
+import java.util.Random;
+
+public class Rounding {
+  // The java.util.Random only generates random float/double numbers between 0 and 1.
+  // So we implement our own random floating point numbers here,
+  // based on a well known quick and dirty approach.
+  static final class MyRandom extends Random {
+    static int im = 139968;
+    static int ia = 3877;
+    static int ic = 29573;
+    static int seed = 0;
+
+    public double nextDouble() {
+      double scale = 1000.0d / im;
+      seed = (seed * ia + ic) % im;
+      return scale * seed;
+    }
+
+    public float nextFloat() {
+      float scale = 1000.0f / im;
+      seed = (seed * ia + ic) % im;
+      return scale * seed;
+    }
+  }
+
+  /* Invoke each intrinsic in question the same no. of times */
+  private static final int NUM_INVOKES = 64;
+
+  /* Random pool size.
+   * Use a power of two to make the modulo operations below fast. */
+  private static final int NUM_RANDS = 1024;
+
+  /* Pre-allocated pool of random numbers. */
+  private static final float[] rand_float = new float[NUM_RANDS];
+  private static final double[] rand_double = new double[NUM_RANDS];
+
+  private static final float[] rand_pos_float = new float[NUM_RANDS];
+  private static final double[] rand_pos_double = new double[NUM_RANDS];
+
+  private static final float[] rand_neg_float = new float[NUM_RANDS];
+  private static final double[] rand_neg_double = new double[NUM_RANDS];
+
+  // These are written but not read. The computation routines below store their
+  // result to these static variables to ensure the computation code is not
+  // removed by DCE.
+  private static float res_float;
+  private static double res_double;
+  private static int res_int;
+  private static long res_long;
+
+  static {
+    MyRandom rand = new MyRandom();
+
+    for (int i = 0; i < NUM_RANDS; i++) {
+      rand_pos_float[i] = rand.nextFloat();
+      rand_pos_double[i] = rand.nextDouble();
+
+      rand_neg_float[i] = rand.nextFloat() * -1f;
+      rand_neg_double[i] = rand.nextDouble() * -1f;
+
+      if (rand.nextInt() % 2 == 0) {
+        rand_float[i] =  rand_pos_float[i];
+        rand_double[i] = rand_pos_double[i];
+      } else {
+        rand_float[i] =  rand_neg_float[i];
+        rand_double[i] = rand_neg_double[i];
+      }
+    }
+  }
+
+  public void timeRoundPositiveFloat(int iterations) {
+    int res = 0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.round(rand_pos_float[i % NUM_RANDS]);
+      }
+    }
+    res_int = res;
+  }
+
+  public void timeRoundNegativeFloat(int iterations) {
+    int res = 0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.round(rand_neg_float[i % NUM_RANDS]);
+      }
+    }
+    res_int = res;
+  }
+
+  public void timeRoundFloat(int iterations) {
+    int res = 0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.round(rand_float[i % NUM_RANDS]);
+      }
+    }
+    res_int = res;
+  }
+
+  public void timeRoundPositiveDouble(int iterations) {
+    long res = 0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.round(rand_pos_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+  public void timeRoundNegativeDouble(int iterations) {
+    long res = 0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.round(rand_neg_double[i % NUM_RANDS]);
+      }
+    }
+    res_long = res;
+  }
+
+  public void timeRoundDouble(int iterations) {
+    long res = 0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.round(rand_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+  public void timeFloorPositiveFloat(int iterations) {
+    float res = 0.0f;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.floor(rand_pos_float[i % NUM_RANDS]);
+      }
+    }
+    res_float = res;
+  }
+
+  public void timeFloorNegativeFloat(int iterations) {
+    float res = 0.0f;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.floor(rand_neg_float[i % NUM_RANDS]);
+      }
+    }
+    res_float = res;
+  }
+
+  public void timeFloorFloat(int iterations) {
+    float res = 0.0f;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.floor(rand_float[i % NUM_RANDS]);
+      }
+    }
+    res_float = res;
+  }
+
+  public void timeFloorPositiveDouble(int iterations) {
+    double res = 0.0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.floor(rand_pos_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+  public void timeFloorNegativeDouble(int iterations) {
+    double res = 0.0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.floor(rand_neg_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+  public void timeFloorDouble(int iterations) {
+    double res = 0.0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.floor(rand_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+  public void timeCeilPositiveFloat(int iterations) {
+    float res = 0.0f;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.ceil(rand_pos_float[i % NUM_RANDS]);
+      }
+    }
+    res_float = res;
+  }
+
+  public void timeCeilNegativeFloat(int iterations) {
+    float res = 0.0f;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.ceil(rand_neg_float[i % NUM_RANDS]);
+      }
+    }
+    res_float = res;
+  }
+
+  public void timeCeilFloat(int iterations) {
+    float res = 0.0f;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.ceil(rand_float[i % NUM_RANDS]);
+      }
+    }
+    res_float = res;
+  }
+
+  public void timeCeilPositiveDouble(int iterations) {
+    double res = 0.0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.ceil(rand_pos_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+
+  public void timeCeilNegativeDouble(int iterations) {
+    double res = 0.0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.ceil(rand_neg_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+  public void timeCeilDouble(int iterations) {
+    double res = 0.0;
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < NUM_INVOKES; ++i) {
+        res += Math.ceil(rand_double[i % NUM_RANDS]);
+      }
+    }
+    res_double = res;
+  }
+
+  private static final int ITER_COUNT = 100000;
+
+  public static void main(String[] args) {
+    Rounding obj = new Rounding();
+    long before = System.currentTimeMillis();
+
+    obj.timeRoundPositiveFloat(ITER_COUNT);
+    obj.timeRoundNegativeFloat(ITER_COUNT);
+    obj.timeRoundFloat(ITER_COUNT);
+
+    obj.timeRoundPositiveDouble(ITER_COUNT);
+    obj.timeRoundNegativeDouble(ITER_COUNT);
+    obj.timeRoundDouble(ITER_COUNT);
+
+    obj.timeFloorPositiveFloat(ITER_COUNT);
+    obj.timeFloorNegativeFloat(ITER_COUNT);
+    obj.timeFloorFloat(ITER_COUNT);
+
+    obj.timeFloorPositiveDouble(ITER_COUNT);
+    obj.timeFloorNegativeDouble(ITER_COUNT);
+    obj.timeFloorDouble(ITER_COUNT);
+
+    obj.timeCeilPositiveFloat(ITER_COUNT);
+    obj.timeCeilNegativeFloat(ITER_COUNT);
+    obj.timeCeilFloat(ITER_COUNT);
+
+    obj.timeCeilPositiveDouble(ITER_COUNT);
+    obj.timeCeilNegativeDouble(ITER_COUNT);
+    obj.timeCeilDouble(ITER_COUNT);
+
+    obj.timeFloorFloat(ITER_COUNT);
+    obj.timeFloorDouble(ITER_COUNT);
+    obj.timeCeilFloat(ITER_COUNT);
+    obj.timeCeilDouble(ITER_COUNT);
+
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/micro/intrinsics/Rounding: " + (after - before));
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Bubblesort.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Bubblesort.java
new file mode 100644
index 0000000..d419433
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Bubblesort.java
@@ -0,0 +1,99 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Bubblesort {
+
+  private static final int sortelements = 5000;
+  private static final int srtelements = 500;
+
+  private boolean error; // Used as flag for the verify() function.
+  private long seed;
+  private int[] sortlist = new int [sortelements + 1];
+  private int biggest;
+  private int littlest;
+  private int top;
+
+// CHECKSTYLE.OFF: .*
+void Initrand () {
+    seed = 74755L;   /* constant to long WR*/
+}
+
+int Rand () {
+    seed = (seed * 1309L + 13849L) & 65535L;  /* constants to long WR*/
+    return( (int)seed );     /* typecast back to int WR*/
+}
+
+
+    /* Sorts an array using bubblesort */
+
+void bInitarr()	{
+	int i;
+	long temp; /* converted temp to long for 16 bit WR*/
+	Initrand();
+	biggest = 0; littlest = 0;
+	for ( i = 1; i <= srtelements; i++ ) {
+	    temp = Rand();
+	    /* converted constants to long in next stmt, typecast back to int WR*/
+	    sortlist[i] = (int)(temp - (temp/100000L)*100000L - 50000L);
+	    if ( sortlist[i] > biggest ) biggest = sortlist[i];
+	    else if ( sortlist[i] < littlest ) littlest = sortlist[i];
+	}
+}
+
+void Bubble(int run) {
+	int i, j;
+	bInitarr();
+	top=srtelements;
+	
+	while ( top>1 ) {
+		
+		i=1;
+		while ( i<top ) {
+			
+			if ( sortlist[i] > sortlist[i+1] ) {
+				j = sortlist[i];
+				sortlist[i] = sortlist[i+1];
+				sortlist[i+1] = j;
+			}
+			i=i+1;
+		}
+		
+		top=top-1;
+	}
+	if ( (sortlist[1] != littlest) || (sortlist[srtelements] != biggest) )
+	error = true;
+}
+  // CHECKSTYLE.ON: .*
+
+  public static boolean verify_Bubblesort() {
+    Bubblesort obj = new Bubblesort();
+    obj.timeBubble(1);
+    return !obj.error;
+  }
+
+  public void timeBubble(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Bubble(i);
+    }
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Bubblesort obj = new Bubblesort();
+
+    long before = System.currentTimeMillis();
+    obj.timeBubble(1000);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Bubblesort: " + (after - before));
+
+    if (!verify_Bubblesort()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/IntMM.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/IntMM.java
new file mode 100644
index 0000000..a3ca168
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/IntMM.java
@@ -0,0 +1,92 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class IntMM {
+
+  private static final int rowsize = 40;
+
+  // Number of (internal) iterations for IntMM runs as per original benchmark
+  private static final int INTMM_ITERS = 10;
+  private static final int EXPECTED = 300;
+
+  private long seed;
+
+  private int[][] ima = new int[rowsize + 1][rowsize + 1];
+  private int[][] imb = new int[rowsize + 1][rowsize + 1];
+  private int[][] imr = new int[rowsize + 1][rowsize + 1];
+
+// CHECKSTYLE.OFF: .*
+void Initrand () {
+    seed = 74755L;   /* constant to long WR*/
+}
+
+int Rand () {
+    seed = (seed * 1309L + 13849L) & 65535L;  /* constants to long WR*/
+    return( (int)seed );     /* typecast back to int WR*/
+}
+
+
+    /* Multiplies two integer matrices. */
+
+private void Initmatrix (int m[][]) {
+	int temp, i, j;
+	for ( i = 1; i <= rowsize; i++ )
+	    for ( j = 1; j <= rowsize; j++ ) {
+	    temp = Rand();
+		m[i][j] = temp - (temp/120)*120 - 60;
+	}
+}
+
+void Innerproduct( int result[][], int a[][], int b[][], int row, int column) {
+	/* computes the inner product of A[row,*] and B[*,column] */
+	int i;
+	int tmp = 0;
+	for(i = 1; i <= rowsize; i++ ) tmp = tmp+a[row][i]*b[i][column];
+	result[row][column] = tmp;
+  }
+
+void Intmm (int run) {
+    int i, j;
+    Initrand();
+    Initmatrix (ima);
+    Initmatrix (imb);
+    for ( i = 1; i <= rowsize; i++ )
+		for ( j = 1; j <= rowsize; j++ )
+			Innerproduct(imr,ima,imb,i,j);
+}
+  // CHECKSTYLE.ON: .*
+
+  public void timeIntmm(int iters) {
+    for (int i = 0; i < iters; i++) {
+      for (int j = 0; j < INTMM_ITERS; j++) {
+        Intmm(j);
+      }
+    }
+  }
+
+  public static boolean verify_IntMM() {
+    IntMM obj = new IntMM();
+    obj.timeIntmm(1);
+    return obj.imr[INTMM_ITERS][INTMM_ITERS] == EXPECTED;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    IntMM obj = new IntMM();
+
+    long before = System.currentTimeMillis();
+    obj.timeIntmm(120);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/IntMM: " + (after - before));
+
+    if (!verify_IntMM()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Oscar.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Oscar.java
new file mode 100644
index 0000000..14309f3
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Oscar.java
@@ -0,0 +1,191 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Oscar {
+
+  private static final int fftsize = 256;
+  private static final int fftsize2 = 129;
+
+  class Complex {
+    float rp;
+    float ip;
+  }
+
+  private Complex[] z = new Complex [fftsize + 1];
+  private Complex[] w = new Complex [fftsize + 1];
+  private Complex[] e = new Complex [fftsize2 + 1];
+  private float zr;
+  private float zi;
+  private float[] h = new float[26];
+
+  private long seed;  /* converted to long for 16 bit WR*/
+
+  public Oscar() {
+    for (int i = 0; i < z.length; i++) z[i] = new Complex();
+    for (int i = 0; i < e.length; i++) e[i] = new Complex();
+    for (int i = 0; i < w.length; i++) w[i] = new Complex();
+  }
+
+// CHECKSTYLE.OFF: .*
+float Cos (float x) {
+/* computes cos of x (x in radians) by an expansion */
+int i, factor;
+float    result, power;
+
+   result = 1.0f;
+   factor = 1;
+   power = x;
+   for ( i = 2; i <= 10; i++ ) {
+      factor = factor * i;  power = power*x;
+      if ( (i & 1) == 0 )  {
+        if ( (i & 3) == 0 ) result = result + power/factor;
+		else result = result - power/factor;
+      }
+   }
+   return (result);
+}
+
+int Min0( int arg1, int arg2) {
+    if ( arg1 < arg2 ) 	return (arg1);
+    else  return (arg2);
+}
+
+int Uniform11(int iy) {
+    return (4855 * iy + 1731) & 8191;
+} /* uniform */ 
+
+void Exptab(int n, Complex e[]) { /* exptab */
+    float theta, divisor;
+    int i, j, k, l, m;
+
+    theta = 3.1415926536f;
+    divisor = 4.0f;
+    for ( i=1; i <= 25; i++ ) {
+		h[i] = 1/(2*Cos( theta/divisor ));
+		divisor = divisor + divisor;
+	}
+
+    m = n / 2 ;
+    l = m / 2 ;
+    j = 1 ;
+    e[1].rp = 1.0f;
+    e[1].ip = 0.0f;
+    e[l+1].rp = 0.0f;
+    e[l+1].ip = 1.0f;
+    e[m+1].rp = -1.0f;
+    e[m+1].ip = 0.0f;
+
+    do {
+		i = l / 2 ;
+		k = i ;
+	
+		do {
+		    e[k+1].rp = h[j]*(e[k+i+1].rp+e[k-i+1].rp) ;
+		    e[k+1].ip = h[j]*(e[k+i+1].ip+e[k-i+1].ip) ;
+		    k = k+l ;
+		} while ( k <= m );
+	
+		j = Min0( j+1, 25);
+		l = i ;
+	} while ( l > 1 );
+
+} /* exptab */
+
+void Fft( int n, Complex z[], Complex w[], Complex e[], float sqrinv) {
+    int i, j, k, l, m, index;
+    m = n / 2 ;
+    l = 1 ;
+
+    do {
+		k = 0 ;
+		j = l ;
+		i = 1 ;
+	
+		do {
+	
+		    do {
+			w[i+k].rp = z[i].rp+z[m+i].rp ;
+			w[i+k].ip = z[i].ip+z[m+i].ip ;
+			w[i+j].rp = e[k+1].rp*(z[i].rp-z[i+m].rp)
+			-e[k+1].ip*(z[i].ip-z[i+m].ip) ;
+			w[i+j].ip = e[k+1].rp*(z[i].ip-z[i+m].ip)
+			+e[k+1].ip*(z[i].rp-z[i+m].rp) ;
+			i = i+1 ;
+		    } while ( i <= j );
+	
+		    k = j ;
+		    j = k+l ;
+		} while ( j <= m );
+	
+		/*z = w ;*/ index = 1;
+		do {
+		    z[index].rp = w[index].rp;
+		    z[index].ip = w[index].ip;
+		    index = index+1;
+		} while ( index <= n );
+		l = l+l ;
+    } while ( l <= m );
+
+    for ( i = 1; i <= n; i++ ){
+		z[i].rp = sqrinv*z[i].rp ;
+		z[i].ip = -sqrinv*z[i].ip;
+	}
+
+}
+
+void Oscar() { /* oscar */
+	int i;
+	Exptab(fftsize,e) ;
+	seed = 5767 ;
+	for ( i = 1; i <= fftsize; i++ ) {
+	    seed = Uniform11( (int)seed ); /* typecast seed for 16 bit WR*/
+		zr = seed / 8192.0f;
+	    seed = Uniform11( (int)seed ); /* typecast seed for 16 bit WR*/
+		zi = seed / 8192.0f;
+	    z[i].rp = 20.0f*zr - 10.0f;
+	    z[i].ip = 20.0f*zi - 10.0f;
+	}
+	for ( i = 1; i <= 20; i++ ) {
+	   Fft(fftsize,z,w,e,0.0625f) ;
+	}
+} /* oscar */
+  // CHECKSTYLE.ON: .*
+
+  public void timeOscar(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Oscar();
+    }
+  }
+
+  public static boolean verify_Oscar() {
+    Oscar obj = new Oscar();
+    obj.timeOscar(1);
+    // We know for a fact that z[256] = {-9.150383 -0.920413}
+    // So its rp must be between -9.150f and -9.151f, otherwise it is an error.
+    boolean error = obj.z[256].rp < -9.151f || -9.150f < obj.z[256].rp;
+    // And its ip must be between -.920f and -921f, otherwise it is also an error.
+    error = error || (obj.z[256].ip < -.921f || -.920f < obj.z[256].ip);
+    // verify() returns 0 when there is no error.
+    return !error;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Oscar obj = new Oscar();
+
+    long before = System.currentTimeMillis();
+    obj.timeOscar(600);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Oscar: " + (after - before));
+
+    if (!verify_Oscar()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Perm.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Perm.java
new file mode 100644
index 0000000..9966208
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Perm.java
@@ -0,0 +1,85 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Perm {
+
+  private static final int permrange = 10;
+
+  private boolean error;
+
+  /* Perm */
+  private int[] permarray = new int [permrange + 1];
+  /* converted pctr to unsigned int for 16 bit WR*/
+  private int  pctr;
+
+// CHECKSTYLE.OFF: .*
+    /* Permutation program, heavily recursive, written by Denny Brown. */
+void Swap ( int a[], int ai,  int b[], int bi ) {
+	int t;
+	t = a[ai];  a[ai] = b[bi];  b[bi] = t;
+}
+
+void Initialize () {
+	int i;
+	for ( i = 1; i <= 7; i++ ) {
+	    permarray[i]=i-1;
+	}
+}
+
+void Permute (int n) {   /* permute */
+	int k;
+	pctr = pctr + 1;
+	if ( n!=1 )  {
+	    Permute(n-1);
+	    for ( k = n-1; k >= 1; k-- ) {
+			Swap(permarray, n, permarray, k);
+			Permute(n-1);
+			Swap(permarray, n, permarray, k);
+		}
+    }
+}     /* permute */
+
+void Perm ()    {   /* Perm */
+    int i;
+    pctr = 0;
+    for ( i = 1; i <= 5; i++ ) {
+		Initialize();
+		Permute(7);
+	}
+    if ( pctr != 43300 )
+	error = true;
+}     /* Perm */
+  // CHECKSTYLE.ON: .*
+
+  public void timePerm(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Perm();
+    }
+  }
+
+  public static boolean verify_Perm() {
+    Perm obj = new Perm();
+    obj.timePerm(1);
+    return !obj.error;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Perm obj = new Perm();
+
+    long before = System.currentTimeMillis();
+    obj.timePerm(500);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Perm: " + (after - before));
+
+    if (!verify_Perm()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Puzzle.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Puzzle.java
new file mode 100644
index 0000000..d449905
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Puzzle.java
@@ -0,0 +1,143 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Puzzle {
+
+  private static final int size = 511;
+  private static final int classmax = 3;
+  private static final int typemax = 12;
+  private static final int d = 8;
+
+  public int error = 0;
+
+    /* puzzle */
+  private int[] piececount = new int [classmax + 1];
+  private int[] cls = new int [typemax + 1];
+  private int[] piecemax = new int [typemax + 1];
+  private boolean[] puzzl = new boolean [size + 1];
+  private boolean[][] p = new boolean [typemax + 1][size + 1];
+  private int n;
+  private int kount;
+
+// CHECKSTYLE.OFF: .*
+boolean Fit (int i, int j) {
+	int k;
+	for ( k = 0; k <= piecemax[i]; k++ )
+	    if ( p[i][k] ) if ( puzzl[j+k] ) return (false);
+	return (true);
+}
+
+int Place (int i, int j) {
+	int k;
+	for ( k = 0; k <= piecemax[i]; k++ ) if ( p[i][k] ) puzzl[j+k] = true;
+	piececount[cls[i]] = piececount[cls[i]] - 1;
+	for ( k = j; k <= size; k++ ) if ( ! puzzl[k] ) return (k);
+	return (0);
+}
+
+void Remove (int i, int j) {
+	int k;
+	for ( k = 0; k <= piecemax[i]; k++ ) if ( p[i][k] ) puzzl[j+k] = false;
+	piececount[cls[i]] = piececount[cls[i]] + 1;
+}
+
+boolean Trial (int j) {
+	int i, k;
+	kount = kount + 1;
+	for ( i = 0; i <= typemax; i++ )
+	    if ( piececount[cls[i]] != 0 )
+		if ( Fit (i, j) ) {
+		    k = Place (i, j);
+		    if ( Trial(k) || (k == 0) )return (true);
+			else Remove (i, j);
+		}
+	return (false);
+}
+
+void Puzzle ()  {
+    int i, j, k, m;
+    for ( m = 0; m <= size; m++ ) puzzl[m] = true;
+    for( i = 1; i <= 5; i++ )for( j = 1; j <= 5; j++ )for( k = 1; k <= 5; k++ )	puzzl[i+d*(j+d*k)] = false;
+    for( i = 0; i <= typemax; i++ )for( m = 0; m<= size; m++ ) p[i][m] = false;
+    for( i = 0; i <= 3; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 0; k++ ) p[0][i+d*(j+d*k)] = true;
+    cls[0] = 0;
+    piecemax[0] = 3+d*1+d*d*0;
+    for( i = 0; i <= 1; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 3; k++ )	p[1][i+d*(j+d*k)] = true;
+    cls[1] = 0;
+    piecemax[1] = 1+d*0+d*d*3;
+    for( i = 0; i <= 0; i++ )for( j = 0; j <= 3; j++ )for( k = 0; k <= 1; k++ )	p[2][i+d*(j+d*k)] = true;
+    cls[2] = 0;
+    piecemax[2] = 0+d*3+d*d*1;
+    for( i = 0; i <= 1; i++ )for( j = 0; j <= 3; j++ )for( k = 0; k <= 0; k++ )	p[3][i+d*(j+d*k)] = true;
+    cls[3] = 0;
+    piecemax[3] = 1+d*3+d*d*0;
+    for( i = 0; i <= 3; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 1; k++ )	p[4][i+d*(j+d*k)] = true;
+    cls[4] = 0;
+    piecemax[4] = 3+d*0+d*d*1;
+    for( i = 0; i <= 0; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 3; k++ )	p[5][i+d*(j+d*k)] = true;
+    cls[5] = 0;
+    piecemax[5] = 0+d*1+d*d*3;
+    for( i = 0; i <= 2; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 0; k++ )	p[6][i+d*(j+d*k)] = true;
+    cls[6] = 1;
+    piecemax[6] = 2+d*0+d*d*0;
+    for( i = 0; i <= 0; i++ )for( j = 0; j <= 2; j++ )for( k = 0; k <= 0; k++ )	p[7][i+d*(j+d*k)] = true;
+    cls[7] = 1;
+    piecemax[7] = 0+d*2+d*d*0;
+    for( i = 0; i <= 0; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 2; k++ )	p[8][i+d*(j+d*k)] = true;
+    cls[8] = 1;
+    piecemax[8] = 0+d*0+d*d*2;
+    for( i = 0; i <= 1; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 0; k++ )	p[9][i+d*(j+d*k)] = true;
+    cls[9] = 2;
+    piecemax[9] = 1+d*1+d*d*0;
+    for( i = 0; i <= 1; i++ )for( j = 0; j <= 0; j++ )for( k = 0; k <= 1; k++ )	p[10][i+d*(j+d*k)] = true;
+    cls[10] = 2;
+    piecemax[10] = 1+d*0+d*d*1;
+    for( i = 0; i <= 0; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 1; k++ )	p[11][i+d*(j+d*k)] = true;
+    cls[11] = 2;
+    piecemax[11] = 0+d*1+d*d*1;
+    for( i = 0; i <= 1; i++ )for( j = 0; j <= 1; j++ )for( k = 0; k <= 1; k++ )	p[12][i+d*(j+d*k)] = true;
+    cls[12] = 3;
+    piecemax[12] = 1+d*1+d*d*1;
+    piececount[0] = 13;
+    piececount[1] = 3;
+    piececount[2] = 1;
+    piececount[3] = 1;
+    m = 1+d*(1+d*1);
+    kount = 0;
+    if ( Fit(0, m) ) n = Place(0, m);
+    else error = 1;
+    if ( ! Trial(n) ) error = 2;
+    else if ( kount != 2005 ) error = 3;
+}
+  // CHECKSTYLE.ON: .*
+
+  public void timePuzzle(int iters) {
+    for (int i = 0; i < iters; i++) Puzzle();
+  }
+
+  public static boolean verify_Puzzle() {
+    Puzzle obj = new Puzzle();
+    obj.timePuzzle(1);
+    return obj.error == 0;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Puzzle obj = new Puzzle();
+
+    long before = System.currentTimeMillis();
+    obj.timePuzzle(125);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Puzzle: " + (after - before));
+
+    if (!verify_Puzzle()) {
+      rc = obj.error;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Queens.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Queens.java
new file mode 100644
index 0000000..b257cec
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Queens.java
@@ -0,0 +1,97 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Queens {
+
+  /* Since the original benchmark uses these to calculate indices,
+   * it is not appropriate to use pure booleans, and we use the constants below:
+   */
+  private static final int FALSE = 0;
+  private static final int TRUE = 1;
+
+  private boolean error;
+  private int q = FALSE;
+
+  private int[] a = new int [9];
+  private int[] b = new int[17];
+  private int[] c = new int [15];
+  private int[] x = new int [9];
+
+// CHECKSTYLE.OFF: .*
+void Try(int i, int a[], int b[], int c[], int x[]) {
+	int     j;
+	j = 0;
+	q = FALSE;
+	while ( (q == FALSE) && (j != 8) ) {
+		j = j + 1;
+		q = FALSE;
+		if ( b[j] != FALSE && a[i+j] != FALSE && c[i-j+7] != FALSE ) {
+			x[i] = j;
+		    b[j] = FALSE;
+		    a[i+j] = FALSE;
+		    c[i-j+7] = FALSE;
+		    if ( i < 8 ) {
+		    	Try(i+1,a,b,c,x);
+				if ( q ==FALSE ) {
+					b[j] = TRUE;
+				    a[i+j] = TRUE;
+				    c[i-j+7] = TRUE;
+				}
+			}
+		    else q = TRUE;
+	    }
+	}
+}
+
+void Doit () {
+	int i;
+	i = 0 - 7;
+	while ( i <= 16 ) {
+		if ( (i >= 1) && (i <= 8) ) a[i] = TRUE;
+	    if ( i >= 2 ) b[i] = TRUE;
+	    if ( i <= 7 ) c[i+7] = TRUE;
+	    i = i + 1;
+	}
+
+	Try(1, b, a, c, x);
+	if ( q == FALSE ) error = true;
+}
+
+void Queens (int run) {
+    int i;
+    for ( i = 1; i <= 50; i++ ) Doit();
+}
+  // CHECKSTYLE.ON: .*
+
+  public void timeQueens(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Queens(i);
+    }
+  }
+
+  public static boolean verify_Queens() {
+    Queens obj = new Queens();
+    obj.timeQueens(1);
+    return !obj.error;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Queens obj = new Queens();
+
+    long before = System.currentTimeMillis();
+    obj.timeQueens(1000);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Queens: " + (after - before));
+
+    if (!verify_Queens()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Quicksort.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Quicksort.java
new file mode 100644
index 0000000..68b7a4e
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Quicksort.java
@@ -0,0 +1,102 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Quicksort {
+
+  /* Bubble, Quick */
+  private static final int sortelements = 5000;
+  private static final int srtelements = 500;
+
+  private boolean error;
+  long seed;
+
+  int[] sortlist = new int [sortelements + 1];
+  int biggest;
+  int littlest;
+  int inttop;
+
+// CHECKSTYLE.OFF: .*
+void Initrand () {
+    seed = 74755L;   /* constant to long WR*/
+}
+
+int Rand () {
+    seed = (seed * 1309L + 13849L) & 65535L;  /* constants to long WR*/
+    return( (int)seed );     /* typecast back to int WR*/
+}
+
+    /* Sorts an array using quicksort */
+void Initarr() {
+	int i; /* temp */
+	long temp;  /* made temp a long for 16 bit WR*/
+	Initrand();
+	biggest = 0; littlest = 0;
+	for ( i = 1; i <= sortelements; i++ ) {
+	    temp = Rand();
+	    /* converted constants to long in next stmt, typecast back to int WR*/
+	    sortlist[i] = (int)(temp - (temp/100000L)*100000L - 50000L);
+	    if ( sortlist[i] > biggest ) biggest = sortlist[i];
+	    else if ( sortlist[i] < littlest ) littlest = sortlist[i];
+	}
+}
+
+void Quicksort( int a[], int l, int r) {
+	/* quicksort the array A from start to finish */
+	int i,j,x,w;
+
+	i=l; j=r;
+	x=a[(l+r) / 2];
+	do {
+	    while ( a[i]<x ) i = i+1;
+	    while ( x<a[j] ) j = j-1;
+	    if ( i<=j ) {
+			w = a[i];
+			a[i] = a[j];
+			a[j] = w;
+			i = i+1;    j= j-1;
+		}
+	} while ( i<=j );
+	if ( l <j ) Quicksort(a,l,j);
+	if ( i<r ) Quicksort(a,i,r);
+}
+
+
+void Quick (int run) {
+    Initarr();
+    Quicksort(sortlist,1,sortelements);
+    if ( (sortlist[1] != littlest) || (sortlist[sortelements] != biggest) )	error = true;
+}
+  // CHECKSTYLE.ON: .*
+
+  public void timeQuicksort(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Quick(i);
+    }
+  }
+
+  public static boolean verify_Quicksort() {
+    Quicksort obj = new Quicksort();
+    obj.timeQuicksort(1);
+    return !obj.error;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Quicksort obj = new Quicksort();
+
+    long before = System.currentTimeMillis();
+    obj.timeQuicksort(1200);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Quicksort: " + (after - before));
+
+    if (!verify_Quicksort()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/RealMM.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/RealMM.java
new file mode 100644
index 0000000..321e773
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/RealMM.java
@@ -0,0 +1,87 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class RealMM {
+
+  private static final int rowsize = 40;
+
+  private double[][] rma = new double [rowsize + 1][rowsize + 1];
+  private double[][] rmb = new double [rowsize + 1][rowsize + 1];
+  private double[][] rmr = new double [rowsize + 1][rowsize + 1];
+
+  long seed;
+
+// CHECKSTYLE.OFF: .*
+void Initrand () {
+    seed = 74755L;   /* constant to long WR*/
+}
+
+int Rand () {
+    seed = (seed * 1309L + 13849L) & 65535L;  /* constants to long WR*/
+    return( (int)seed );     /* typecast back to int WR*/
+}
+
+
+    /* Multiplies two real matrices. */
+
+void rInitmatrix ( double m[][] ) {
+	int temp, i, j;
+	for ( i = 1; i <= rowsize; i++ )
+	    for ( j = 1; j <= rowsize; j++ ) {
+	    	temp = Rand();
+			m[i][j] = (double)(temp - (temp/120)*120 - 60)/3;
+        }
+}
+
+void rInnerproduct(double result[][], double a[][], double b[][], int row, int column) {
+	/* computes the inner product of A[row,*] and B[*,column] */
+	int i;
+	result[row][column] = 0.0f;
+	for (i = 1; i<=rowsize; i++) result[row][column] = result[row][column]+a[row][i]*b[i][column];
+}
+
+void Mm (int run)    {
+    int i, j;
+    Initrand();
+    rInitmatrix (rma);
+    rInitmatrix (rmb);
+    for ( i = 1; i <= rowsize; i++ )
+		for ( j = 1; j <= rowsize; j++ ) 
+			rInnerproduct(rmr,rma,rmb,i,j);
+}
+  // CHECKSTYLE.ON: .*
+
+  public void timeRealMM(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Mm(i);
+    }
+  }
+
+  public static boolean verify_RealMM() {
+    RealMM obj = new RealMM();
+    obj.timeRealMM(1);
+    // Expected obj.rmr[1][1] value: -775.9999999999999
+    boolean error = obj.rmr[1][1] < -776.000f || -775.999f < obj.rmr[1][1];
+    return !error;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    RealMM obj = new RealMM();
+
+    long before = System.currentTimeMillis();
+    obj.timeRealMM(800);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/RealMM: " + (after - before));
+
+    if (!verify_RealMM()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Towers.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Towers.java
new file mode 100644
index 0000000..972919c
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Towers.java
@@ -0,0 +1,147 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Towers {
+
+  private static final int maxcells = 18;
+
+  private static final int stackrange = 3;
+
+  private boolean error;
+
+  class Element {
+    int discsize;
+    int next;
+  }
+
+  int[] stack = new int[stackrange + 1];
+  Element[] cellspace = new Element[maxcells + 1];
+  int freelist;
+  int movesdone;
+
+  public Towers() {
+    for (int i = 0; i < cellspace.length; i++) {
+      cellspace[i] = new Element();
+    }
+  }
+
+// CHECKSTYLE.OFF: .*
+void Error (String emsg) 	{
+  error = true;
+}
+
+
+void Makenull (int s) {
+	stack[s]=0;
+}
+
+int Getelement () {
+	int temp = 0;  /* force init of temp WR*/
+	if ( freelist>0 ) {
+	    temp = freelist;
+	    freelist = cellspace[freelist].next;
+	}
+	else 
+	    Error("out of space   ");
+	return (temp);
+}
+
+void Push(int i, int s)	{
+	boolean errorfound=false;
+	int localel;
+	if ( stack[s] > 0 )
+		if ( cellspace[stack[s]].discsize<=i ) {
+			errorfound=true;
+			Error("disc size error");
+		}
+	if ( ! errorfound )	{
+		localel=Getelement();
+		cellspace[localel].next=stack[s];
+		stack[s]=localel;
+		cellspace[localel].discsize=i;
+	}
+}
+
+void Init (int s, int n) {
+	int discctr;
+	Makenull(s);
+	for ( discctr = n; discctr >= 1; discctr-- )
+	    Push(discctr,s);
+}
+
+int Pop (int s)	{
+	int temp, temp1;
+	if ( stack[s] > 0 ) {
+		temp1 = cellspace[stack[s]].discsize;
+		temp = cellspace[stack[s]].next;
+		cellspace[stack[s]].next=freelist;
+		freelist=stack[s];
+		stack[s]=temp;
+		return (temp1);
+	}
+	else
+		Error("nothing to pop ");
+	return 0;
+}
+
+void Move (int s1, int s2) {
+	Push(Pop(s1),s2);
+	movesdone=movesdone+1;
+}
+
+void tower(int i, int j, int k) {
+	int other;
+	if ( k==1 ) Move(i,j);
+	else {
+	    other=6-i-j;
+	    tower(i,other,k-1);
+	    Move(i,j);
+	    tower(other,j,k-1);
+	}
+}
+
+void Towers ()    { /* Towers */
+    int i;
+    for ( i=1; i <= maxcells; i++ ) cellspace[i].next=i-1;
+    freelist=maxcells;
+    Init(1,14);
+    Makenull(2);
+    Makenull(3);
+    movesdone=0;
+    tower(1,2,14);
+    if ( movesdone != 16383 ) error = true;
+} /* Towers */
+  // CHECKSTYLE.ON: .*
+
+  public void timeTowers(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Towers();
+    }
+  }
+
+  public static boolean verify_Towers() {
+    Towers obj = new Towers();
+    obj.timeTowers(1);
+    return !obj.error;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Towers obj = new Towers();
+
+    long before = System.currentTimeMillis();
+    obj.timeTowers(500);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Towers: " + (after - before));
+
+    if (!verify_Towers()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Treesort.java b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Treesort.java
new file mode 100644
index 0000000..b38dde5
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/art_benchmarks/stanford/Treesort.java
@@ -0,0 +1,125 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package art_benchmarks.stanford;
+
+public class Treesort {
+
+  private static final int sortelements = 5000;
+  private static final int srtelements = 500;
+
+  private boolean error;
+
+  private long seed;
+
+  private int[] sortlist = new int [sortelements + 1];
+  private int biggest;
+  private int littlest;
+  private int top;
+
+  class Node {
+    Node left;
+    Node right;
+    int val;
+  }
+
+  Node tree;
+
+// CHECKSTYLE.OFF: .*
+void Initrand () {
+    seed = 74755L;   /* constant to long WR*/
+}
+
+int Rand () {
+    seed = (seed * 1309L + 13849L) & 65535L;  /* constants to long WR*/
+    return( (int)seed );     /* typecast back to int WR*/
+}
+
+
+
+    /* Sorts an array using treesort */
+
+void tInitarr() {
+	int i;
+	long temp;  /* converted temp to long for 16 bit WR*/
+	Initrand();
+	biggest = 0; littlest = 0;
+	for ( i = 1; i <= sortelements; i++ ) {
+	    temp = Rand(); 
+	    /* converted constants to long in next stmt, typecast back to int WR*/
+	    sortlist[i] = (int)(temp - (temp/100000L)*100000L - 50000L);
+	    if ( sortlist[i] > biggest ) biggest = sortlist[i];
+	    else if ( sortlist[i] < littlest ) littlest = sortlist[i];
+	}
+}
+
+void CreateNode (Node t, int n) {
+		t = new Node();
+		t.val = n;
+}
+
+void Insert(int n, Node t) {
+	/* insert n into tree */
+	if ( n > t.val ) 
+		if ( t.left == null ) CreateNode(t.left,n);
+		else Insert(n,t.left);
+	else if ( n < t.val )
+		if ( t.right == null ) CreateNode(t.right,n);
+		else Insert(n,t.right);
+}
+
+
+boolean Checktree(Node p) {
+    /* check by inorder traversal */
+    boolean result;
+    result = true;
+	if ( p.left != null ) 
+	   if ( p.left.val <= p.val ) result=false;
+	   else result = Checktree(p.left) && result;
+	if ( p.right != null )
+	   if ( p.right.val >= p.val ) result = false;
+	   else result = Checktree(p.right) && result;
+	return( result);
+} /* checktree */
+
+void Trees(int run) {
+    int i;
+    tInitarr();
+    tree = new Node();
+    tree.left = null; tree.right=null; tree.val=sortlist[1];
+    for ( i = 2; i <= sortelements; i++ )
+		Insert(sortlist[i],tree);
+    if ( ! Checktree(tree) ) error = true;
+}
+  // CHECKSTYLE.ON: .*
+
+  public void timeTreesort(int iters) {
+    for (int i = 0; i < iters; i++) {
+      Trees(i);
+    }
+  }
+
+  public static boolean verify_Treesort() {
+    Treesort obj = new Treesort();
+    obj.timeTreesort(1);
+    return !obj.error;
+  }
+
+  public static void main(String[] args) {
+    int rc = 0;
+    Treesort obj = new Treesort();
+
+    long before = System.currentTimeMillis();
+    obj.timeTreesort(2500);
+    long after = System.currentTimeMillis();
+
+    System.out.println("art_benchmarks/stanford/Treesort: " + (after - before));
+
+    if (!obj.verify_Treesort()) {
+      rc++;
+    }
+
+    System.exit(rc);
+  }
+}
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Interceptor.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Interceptor.java
new file mode 100644
index 0000000..7285318
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Interceptor.java
@@ -0,0 +1,34 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+public class Interceptor extends PrintStream
+{
+
+  public static String outputTxt = "";
+
+  public Interceptor(OutputStream out)
+  {
+    super(out, true);
+  }
+  @Override
+  public void print(String s)
+  {//do what ever you like
+    outputTxt = outputTxt + s;
+    super.print(s);
+  }
+
+  @Override
+  public void println(String s)
+  {//do what ever you like
+    outputTxt = outputTxt + s + "\n";
+    super.print(s);
+  }
+
+  public static void clear(){
+    outputTxt = "";
+  }
+}
\ No newline at end of file
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java
index 60e9891..ce191b7 100644
--- a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java
@@ -1,5 +1,6 @@
 package org.linaro.iasenov.benchmarkframework;
 
+import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.ProgressDialog;
@@ -29,11 +30,17 @@ import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
 import android.widget.AdapterView;
 import android.widget.ArrayAdapter;
+import android.widget.BaseAdapter;
 import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.GridView;
 import android.widget.ListView;
 import android.widget.NumberPicker;
+import android.widget.RelativeLayout;
 import android.widget.TextView;
 import android.widget.Toast;
 
@@ -60,10 +67,11 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
     private Button mStartAutoButton;
     private Button mSaveButton;
     private Button mInfo;
-    private ListView mListView;
+    private Button mShowHideDispay;
+    //private ListView mListView;
     private TextView mDisplayDetails;
     private static TextView mToolbarRepeatIndicator;
-    public ArrayAdapter listAdapter;
+    //public ArrayAdapter listAdapter;
     ProgressDialog progressDialog;
 
     private String mSelectedTest = "";
@@ -74,7 +82,7 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
     public static String PACKAGE_NAME;
     private List<String> mAllTests;
     private ArrayList selectedClassTests;
-    final String[] classNameTestItems = new String[8];
+    final String[] classNameTestItems = new String[15];
 
     private static String KEY_REPEAT_NUMBER = "repeat-number";
     private static String KEY_FILE_FORMAT = "file-format";
@@ -118,6 +126,15 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
     public static String mStep;
     public static String mFrom;
 
+
+    //*************************
+    private int count;
+
+    private boolean[] testselection;
+    private MyAdapter mGridViewAdapter;
+    int pixMin;
+    public GridView mListViewGrid;
+
     //**********************************************************************************************
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -158,7 +175,8 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
         mInfo = (Button) findViewById(R.id.infoButton);
         mInfo.setOnClickListener(this);
 
-        mListView = (ListView) findViewById(R.id.tests_list_view);
+        mShowHideDispay = (Button) findViewById(R.id.showHideDisplay);
+        mShowHideDispay.setOnClickListener(this);
 
         mDisplayDetails = (TextView) findViewById(R.id.displayDetails);
         DisplayMetrics metrics = new DisplayMetrics();
@@ -169,7 +187,7 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
         pixWide = metrics.widthPixels;
         testDone = 0;
 
-        int pixMin = pixWide;
+        pixMin = pixWide;
         if (pixHigh < pixMin) pixMin = pixHigh;
 
         mDisplayDetails.setTextSize(TypedValue.COMPLEX_UNIT_PX, getPixels(pixMin));
@@ -206,8 +224,16 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
         classNameTestItems[6] = "Test7";
         classNameTestItems[7] = "Test8";
 
+        classNameTestItems[8] = "Test9";
+        classNameTestItems[9] = "Test10";
+        classNameTestItems[10] = "Test11";
+        classNameTestItems[11] = "Test12";
+        classNameTestItems[12] = "Test13";
+        classNameTestItems[13] = "Test14";
+        classNameTestItems[14] = "Test15";
+
 
-        String[] displayNames = new String[8];
+        String[] displayNames = new String[15];
         displayNames[0] = "MemSpeed";
         displayNames[1] = "RandMem";
         displayNames[2] = "Linaro-Libc-Bench";
@@ -217,26 +243,45 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
         displayNames[6] = "Iozone";
         displayNames[7] = "Bonnie++";
 
-        listAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_checked, displayNames);
-        mListView.setAdapter(listAdapter);
-        mListView.setChoiceMode(2); //multiple choice
+        displayNames[8] = "Algorithm(ART)";
+        displayNames[9] = "BMsGame(ART)";
+        displayNames[10] = "Caffeine(ART)";
+        displayNames[11] = "Jit-aot(ART)";
+        displayNames[12] = "Math(ART)";
+        displayNames[13] = "Micro(ART)";
+        displayNames[14] = "Stanford(ART)";
 
-        mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
-            @Override
-            public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
 
-                if (mListView.isItemChecked(i)) {
-                    numberOfCheckedTests++;
-                } else {
-                    numberOfCheckedTests--;
-                }
-            }
-        });
+
+        //*******************GridView*******************
+        this.count = displayNames.length;
+        this.testselection = new boolean[count];
+
+        mListViewGrid = (GridView) findViewById(R.id.listGrid);
+        mGridViewAdapter = new MyAdapter(displayNames);
+        mListViewGrid.setAdapter(mGridViewAdapter);
+        //**********************************************
 
         IS_SHELL_CONTROL = false;
         //Check if shell control is used for tests
-        isShellControl();
 
+
+        //This fix issue with NullPointer on mListViewGrid(invoke isShellControl() when mListViewGrid layout is already inflate)
+
+        mListViewGrid.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
+            @SuppressLint("NewApi")
+            @Override
+            public void onGlobalLayout() {
+                //At this point the layout is complete and the
+                //dimensions of myView and any child views are known.
+                Log.i(TAG, "onGlobalLayout");
+                mListViewGrid.getViewTreeObserver().removeOnGlobalLayoutListener(this);
+                isShellControl();
+            }
+        });
+
+
+        //isShellControl();
     }
     //**********************************************************************************************
 
@@ -265,6 +310,8 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
     @Override
     public void onClick(View v) {
 
+        Log.i(TAG,"numberOfCheckedTests: " + numberOfCheckedTests);
+
         if (v.getId() == R.id.startButton && numberOfCheckedTests > 0) {
             isAuto = false;
             isSelected = true;
@@ -301,6 +348,18 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
                     "<br><br> - <font color=\"#6A996A\">Device info</font>";
 
             createAlertDialog("Help", info, false);
+        } else if(v.getId() == R.id.showHideDisplay){
+            //Log.i(TAG,"showHideDisplay");
+            if(mDisplayDetails.getVisibility() == View.GONE){
+                //Log.i(TAG,"set visible");
+                mDisplayDetails.setVisibility(View.VISIBLE);
+                ((Button)v).setText("HIDE DISPLAY");
+
+            }else{
+                mDisplayDetails.setVisibility(View.GONE);
+                ((Button)v).setText("SHOW DISPLAY");
+                //Log.i(TAG, "set gone");
+            }
         }
     }
 
@@ -408,6 +467,7 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
     }
 
 
+
     //**********************************************************************************************
     //Save "mDisplayDetails" text to file
     //**********************************************************************************************
@@ -516,16 +576,15 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
 
 
         if (isAuto) {
-            for (int i = 0; i < mListView.getCount(); i++) {
-                mAllTests.add((mListView.getItemAtPosition(i)).toString());
+            for (int i = 0; i < mListViewGrid.getCount(); i++) {
+                mAllTests.add((mGridViewAdapter.getTextByPosition(i)).toString());
             }
         }
 
         if (isSelected) {
-            for (int i = 0; i < mListView.getCount(); i++) {
-
-                if (mListView.isItemChecked(i)) {
-                    mAllTests.add((mListView.getItemAtPosition(i)).toString());
+            for (int i = 0; i < mListViewGrid.getCount(); i++) {
+                if (testselection[i]) {
+                    mAllTests.add((mGridViewAdapter.getTextByPosition(i)));
                     selectedClassTests.add(classNameTestItems[i]);
                 }
             }
@@ -879,19 +938,31 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
 
             int mActivePosition = 0;
 
-            mListView.clearChoices();
-            listAdapter.notifyDataSetChanged();
+
 
             for (String className : classNameTestItems) {
                 for (String selected : testsFromShell) {
+                    if (className.equals(selected)) {
+                        //Click on the current test
+                        mGridViewAdapter.removeCheckAtPosition(mActivePosition, mListViewGrid);
+                    }
+
+                }
+                mActivePosition++;
+            }
+
 
+            mActivePosition = 0;
+
+            mGridViewAdapter.notifyDataSetChanged();
+
+            for (String className : classNameTestItems) {
+                for (String selected : testsFromShell) {
                     if (className.equals(selected)) {
                         //Click on the current test
-                        mListView.performItemClick(
-                                mListView.getAdapter().getView(mActivePosition, null, null),
-                                mActivePosition,
-                                mListView.getAdapter().getItemId(mActivePosition));
+                        mGridViewAdapter.performItemClick(mActivePosition,mListViewGrid);
                     }
+
                 }
                 mActivePosition++;
             }
@@ -958,57 +1029,6 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
     }
 
     //**********************************************************************************************
-    //Get device information
-    //**********************************************************************************************
-    /*
-    public static String getInfosAboutDevice(Activity a) {
-        String s = "";
-        try {
-            PackageInfo pInfo = a.getPackageManager().getPackageInfo(
-                    a.getPackageName(), PackageManager.GET_META_DATA);
-            s += "\n APP Package Name: " + a.getPackageName();
-            s += "\n APP Version Name: " + pInfo.versionName;
-            s += "\n APP Version Code: " + pInfo.versionCode;
-            s += "\n";
-        } catch (PackageManager.NameNotFoundException e) {
-        }
-        s += "\n OS Version: " + System.getProperty("os.version") + " ("
-                + android.os.Build.VERSION.INCREMENTAL + ")";
-        s += "\n OS API Level: " + android.os.Build.VERSION.SDK;
-        s += "\n Device: " + android.os.Build.DEVICE;
-        s += "\n Model (and Product): " + android.os.Build.MODEL + " ("
-                + android.os.Build.PRODUCT + ")";
-        // TODO add application version!
-
-        // more from
-        // http://developer.android.com/reference/android/os/Build.html :
-        s += "\n Manufacturer: " + android.os.Build.MANUFACTURER;
-        s += "\n Other TAGS: " + android.os.Build.TAGS;
-
-        s += "\n screenWidth: "
-                + a.getWindow().getWindowManager().getDefaultDisplay()
-                .getWidth();
-        s += "\n screenHeigth: "
-                + a.getWindow().getWindowManager().getDefaultDisplay()
-                .getHeight();
-        s += "\n Keyboard available: "
-                + (a.getResources().getConfiguration().keyboard != Configuration.KEYBOARD_NOKEYS);
-
-        s += "\n Trackball available: "
-                + (a.getResources().getConfiguration().navigation == Configuration.NAVIGATION_TRACKBALL);
-        s += "\n SD Card state: " + Environment.getExternalStorageState();
-        Properties p = System.getProperties();
-        Enumeration keys = p.keys();
-        String key = "";
-        while (keys.hasMoreElements()) {
-            key = (String) keys.nextElement();
-            s += "\n > " + key + " = " + (String) p.get(key);
-        }
-
-        return s;
-    }
-    */
-    //**********************************************************************************************
     //Get device information with html tags
     //**********************************************************************************************
     public static String getInfosAboutDeviceHTML(Activity a) {
@@ -1082,6 +1102,7 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
         }
     }
 
+
     //**********************************************************************************************
     //Async task for background test processing
     //**********************************************************************************************
@@ -1128,6 +1149,7 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
                 saveAutoTestResultToFile();
 
                 testDone = 1;
+                //progressDialog.dismiss();
 
             } catch (Exception e) {
                 e.printStackTrace();
@@ -1143,7 +1165,7 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
 
             //Decrement numberOfCheckedTests(need that because test is auto checked previously)
             if(isAuto){
-                numberOfCheckedTests--;
+                //numberOfCheckedTests--;
             }
 
             progressDialog.dismiss();
@@ -1303,18 +1325,28 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
 
                 int mActivePosition = 0;
 
-                mListView.clearChoices();
-                listAdapter.notifyDataSetChanged();
+
+                //Do remove checks here
+                for (String className : classNameTestItems) {
+                    if (className.equals(text[1])) {
+                        //Click on the current test
+                        mGridViewAdapter.removeCheckAtPosition(mActivePosition, mListViewGrid);
+                    }
+
+                    mActivePosition++;
+                }
+
+                mActivePosition = 0;
+
+                mGridViewAdapter.notifyDataSetChanged();
 
                 //Do auto click here
                 for (String className : classNameTestItems) {
                     if (className.equals(text[1])) {
                         //Click on the current test
-                        mListView.performItemClick(
-                                mListView.getAdapter().getView(mActivePosition, null, null),
-                                mActivePosition,
-                                mListView.getAdapter().getItemId(mActivePosition));
+                        mGridViewAdapter.performItemClick(mActivePosition,mListViewGrid);
                     }
+
                     mActivePosition++;
                 }
             }
@@ -1325,6 +1357,137 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe
     //**********************************************************************************************
 
 
+    //**********************************************************************************************
+    //Custom Adapter for GridView
+    //**********************************************************************************************
+    public class MyAdapter extends BaseAdapter {
+
+        private LayoutInflater mInflater;
+        String testsList[];
+
+        public MyAdapter(String testsList[]) {
+            mInflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+            this.testsList = testsList;
+        }
+
+
+        public int getCount() {
+            return count;
+        }
+
+        public Object getItem(int position) {
+            return position;
+        }
+
+        public long getItemId(int position) {
+            return position;
+        }
+
+        public String getTextByPosition(int pos) {
+            return testsList[pos];
+        }
+
+        public View getView(int position, View convertView, ViewGroup parent) {
+
+            ViewHolder holder;
+            if (convertView == null) {
+                holder = new ViewHolder();
+                convertView = mInflater.inflate(
+                        R.layout.listview, null);
+                holder.textview = (TextView) convertView.findViewById(R.id.itemText);
+                holder.checkbox = (CheckBox) convertView.findViewById(R.id.itemCheckBox);
+
+                //holder.textview.setText(testsList[position]);
+                //holder.textview.setTextSize(getPixels(pixMin));
+
+                convertView.setTag(holder);
+                //convertView.setBackgroundResource(R.drawable.grid_items_border);
+            }
+            else {
+                holder = (ViewHolder) convertView.getTag();
+            }
+            holder.checkbox.setId(position);
+            holder.textview.setId(position);
+
+            holder.textview.setText(testsList[position]);
+            holder.textview.setTextSize(getPixels(pixMin));
+
+            holder.checkbox.setOnClickListener(new View.OnClickListener() {
+
+                public void onClick(View v) {
+                    // TODO Auto-generated method stub
+                    CheckBox cb = (CheckBox) v;
+                    int id = cb.getId();
+                    if (testselection[id]) {
+                        cb.setChecked(false);
+                        testselection[id] = false;
+                        numberOfCheckedTests--;
+                        //Log.i(TAG, "uncheck");
+                    } else {
+                        cb.setChecked(true);
+                        testselection[id] = true;
+                        numberOfCheckedTests++;
+                        //Log.i(TAG, "check");
+                    }
+                }
+            });
+
+
+            holder.checkbox.setChecked(testselection[position]);
+            holder.id = position;
+            return convertView;
+        }
+
+
+        public void removeCheckAtPosition(int i, GridView gr) {
+
+            //for(int i = 0; i < getCount(); i++) {
+                ViewGroup gridChild = (ViewGroup) gr.getChildAt(i);
+                int childSize = gridChild.getChildCount();
+                for(int k = 0; k < childSize; k++) {
+                    if( gridChild.getChildAt(k) instanceof CheckBox ) {
+                        CheckBox cb = (CheckBox)gridChild.getChildAt(k);
+                        //Log.i(TAG,""+i);
+                        if (testselection[i]) {
+                            cb.setChecked(false);
+                            testselection[i] = false;
+                            numberOfCheckedTests--;
+                            //Log.i(TAG, "uncheck");
+                        }
+                    }
+                }
+
+            //}
+        }
+
+
+        public void performItemClick(int position, GridView gr){
+
+            ViewGroup gridChild = (ViewGroup) gr.getChildAt(position);
+            int childSize = gridChild.getChildCount();
+            for(int k = 0; k < childSize; k++) {
+                if(gridChild.getChildAt(k) instanceof CheckBox ) {
+                    CheckBox cb = (CheckBox)gridChild.getChildAt(k);
+                    cb.setChecked(true);
+                    testselection[position] = true;
+                    numberOfCheckedTests++;
+                }
+            }
+        }
+
+    //**********************************************************************************************
+    }//MyAdapter
+    //**********************************************************************************************
+
+    class ViewHolder {
+        TextView textview;
+        CheckBox checkbox;
+        int id;
+    //**********************************************************************************************
+    }//ViewHolder
+    //**********************************************************************************************
+
+
 //**********************************************************************************************
 }//MainActivity
 //**********************************************************************************************
\ No newline at end of file
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test10.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test10.java
new file mode 100644
index 0000000..9bf754f
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test10.java
@@ -0,0 +1,333 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.PrintStream;
+
+import art_benchmarks.benchmarksgame.binarytrees;
+import art_benchmarks.benchmarksgame.chameneosredux;
+import art_benchmarks.benchmarksgame.fannkuchredux;
+import art_benchmarks.benchmarksgame.fasta;
+import art_benchmarks.benchmarksgame.fastaredux;
+import art_benchmarks.benchmarksgame.knucleotide;
+import art_benchmarks.benchmarksgame.mandelbrot;
+import art_benchmarks.benchmarksgame.meteor;
+import art_benchmarks.benchmarksgame.nbody;
+import art_benchmarks.benchmarksgame.pidigits;
+import art_benchmarks.benchmarksgame.regexdna;
+import art_benchmarks.benchmarksgame.revcomp;
+import art_benchmarks.benchmarksgame.spectralnorm;
+import art_benchmarks.benchmarksgame.threadring;
+
+
+/**
+ * Created by iasenov on 9/21/16.
+ */
+public class Test10 extends BaseBenchmark{
+
+    private String TAG = "BMsGame(ART)";
+    static boolean  isJavaCanceled = false;
+
+    public String startBenchmark(int count) {
+
+        isJavaCanceled = false;
+
+        version = " BMsGame ";
+        benchmarkName = "Test10";
+        integrationType = "SL";
+
+        long before;
+        long after;
+
+
+        clear();
+
+        //****Redirect System.out and Syste.err****
+        PrintStream stdOut = System.out;
+        PrintStream stdErrt = System.err;
+
+        PrintStream interceptor_stdout = new Interceptor(stdOut);
+        PrintStream interceptor_err = new Interceptor(stdErrt);
+        System.setOut(interceptor_stdout);// just add the interceptor
+        System.setErr(interceptor_err);// just add the interceptor
+        //****Redirect System.out and Syste.err****
+
+        startTest = System.currentTimeMillis();
+
+        if(isJavaCanceled) return "";
+        //***********binarytrees*************
+        int rc = 0;
+        binarytrees obj1 = new binarytrees();
+        before = System.currentTimeMillis();
+        obj1.timeBinaryTrees(30);
+        after = System.currentTimeMillis();
+
+        if (!obj1.verifyBinaryTrees()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/binarytrees: " + (after - before));
+        //System.exit(rc);
+        //***********binarytrees*************
+
+
+        if(isJavaCanceled) return "";
+        //***********chameneosredux*************
+        rc = 0;
+        chameneosredux obj2 = new chameneosredux();
+
+        before = System.currentTimeMillis();
+        obj2.timeChameneosRedux(40);
+        after = System.currentTimeMillis();
+
+        if (!obj2.verifyChameneosRedux()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/chameneosredux: " + (after - before));
+        //System.exit(rc);
+        //***********chameneosredux*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********fannkuchredux*************
+        rc = 0;
+        fannkuchredux obj3 = new fannkuchredux();
+        before = System.currentTimeMillis();
+        obj3.timeFannkuchRedux(1100);
+        after = System.currentTimeMillis();
+
+        if (!obj3.verifyFannkuchRedux()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/fannkuchredux: " + (after - before));
+        //System.exit(rc);
+        //***********fannkuchredux*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********fasta*************
+        rc = 0;
+        fasta obj4 = new fasta();
+
+        before = System.currentTimeMillis();
+        obj4.timeFasta(1700);
+        after = System.currentTimeMillis();
+
+        if (!obj4.verifyFasta()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/fasta: " + (after - before));
+        //System.exit(rc);
+        //***********fasta*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********fastaredux*************
+        rc = 0;
+        fastaredux obj5 = new fastaredux();
+
+        before = System.currentTimeMillis();
+        try {
+            obj5.timeFastaRedux(1700);
+        } catch (IOException e) {
+            e.printStackTrace();
+            System.err.println(e.toString());
+        }
+        after = System.currentTimeMillis();
+
+        try {
+            if (!obj5.verifyFastaRedux()) {
+                rc++;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+            System.err.println(e.toString());
+        }
+        System.out.println("art_benchmarks/benchmarksgame/fastaredux: " + (after - before));
+        //System.exit(rc);
+        //***********fastaredux*************
+
+        if(isJavaCanceled) return "";
+        //***********knucleotide*************
+        rc = 0;
+        knucleotide obj6 = new knucleotide();
+
+        before = System.currentTimeMillis();
+        obj6.timeKnucleotide(9);
+        after = System.currentTimeMillis();
+
+        if (!obj6.verifyKnucleotide()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/knucleotide: " + (after - before));
+        //System.exit(rc);
+        //***********knucleotide*************
+
+        if(isJavaCanceled) return "";
+        //***********mandelbrot*************
+        rc = 0;
+        mandelbrot obj7 = new mandelbrot();
+
+        before = System.currentTimeMillis();
+        obj7.timeMandelbrot(65);
+        after = System.currentTimeMillis();
+
+        if (!obj7.verifyMandelbrot()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/mandelbrot: " + (after - before));
+        //System.exit(rc);
+        //***********mandelbrot*************
+
+        if(isJavaCanceled) return "";
+        //***********meteor*************
+        rc = 0;
+        meteor puzzle = new meteor();
+
+        before = System.currentTimeMillis();
+        puzzle.timeMeteor(1);
+        after = System.currentTimeMillis();
+
+        if (!puzzle.verifyMeteor()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/meteor: " + (after - before));
+        //System.exit(rc);
+        //***********meteor*************
+
+        if(isJavaCanceled) return "";
+        //***********nbody*************
+        rc = 0;
+        nbody obj8 = new nbody();
+
+        before = System.currentTimeMillis();
+        obj8.timeNBody(1000);
+        after = System.currentTimeMillis();
+
+        if (!obj8.verifyNBody()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/nbody: " + (after - before));
+        //System.exit(rc);
+        //***********nbody*************
+
+
+        if(isJavaCanceled) return "";
+        //***********pidigits*************
+        rc = 0;
+        pidigits obj9 = new pidigits();
+
+        before = System.currentTimeMillis();
+        obj9.timePidigits(100);
+        after = System.currentTimeMillis();
+
+        if (!obj9.verifyPidigits()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/pidigits: " + (after - before));
+        //System.exit(rc);
+        //***********pidigits*************
+
+
+        if(isJavaCanceled) return "";
+        //***********regexdna*************
+        try {
+            rc = 0;
+            regexdna obj10 = new regexdna();
+
+            before = System.currentTimeMillis();
+            obj10.timeRegexDna(10);
+            after = System.currentTimeMillis();
+
+            if (!obj10.verifyRegexDna()) {
+                rc++;
+            }
+        }catch(IOException e) {
+            e.printStackTrace();
+            System.err.println(e.toString());
+        }
+        System.out.println("art_benchmarks/benchmarksgame/regexdna: " + (after - before));
+        //System.exit(rc);
+        //***********regexdna*************
+
+
+        if(isJavaCanceled) return "";
+        //***********revcomp*************
+        try {
+            rc = 0;
+            revcomp obj11 = new revcomp();
+
+            before = System.currentTimeMillis();
+            obj11.timeRevComp(400);
+            after = System.currentTimeMillis();
+
+            if (!obj11.verifyRevComp()) {
+                rc++;
+            }
+
+        }catch(Exception e) {
+                e.printStackTrace();
+                System.err.println(e.toString());
+        }
+        System.out.println("art_benchmarks/benchmarksgame/revcomp: " + (after - before));
+        //System.exit(rc);
+        //***********revcomp*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********spectralnorm*************
+        try {
+        rc = 0;
+        spectralnorm obj12 = new spectralnorm();
+
+        before = System.currentTimeMillis();
+        obj12.timeSpectralNorm(100);
+        after = System.currentTimeMillis();
+
+        if (!obj12.verifySpectralNorm()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/benchmarksgame/spectralnorm: " + (after - before));
+        //System.exit(rc);
+        //***********spectralnorm*************
+
+
+         if(isJavaCanceled) return "";
+        //***********threadring*************
+        rc = 0;
+        threadring obj13 = new threadring();
+
+        before = System.currentTimeMillis();
+        obj13.timeThreadRing(2);
+        after = System.currentTimeMillis();
+
+        if (!obj13.verifyThreadRing()) {
+            rc++;
+        }
+        }catch(Exception e) {
+            e.printStackTrace();
+            System.err.println(e.toString());
+        }
+        System.out.println("art_benchmarks/benchmarksgame/threadring: " + (after - before));
+        //System.exit(rc);
+        //***********threadring*************
+
+        xout[2] = Interceptor.outputTxt;
+        Interceptor.clear();
+
+        endTest = System.currentTimeMillis();
+
+        return benchmarkName + ":" + getBenchmarkResult(5, integrationType);
+    }
+
+
+    public boolean stopBenchmark(){
+        isJavaCanceled = true;
+        Log.i(TAG, "stopBenchmark: isJNICanceled");
+        return true;
+    }
+}
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test11.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test11.java
new file mode 100644
index 0000000..0c4a015
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test11.java
@@ -0,0 +1,167 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.PrintStream;
+
+import art_benchmarks.caffeinemark.FloatAtom;
+import art_benchmarks.caffeinemark.LogicAtom;
+import art_benchmarks.caffeinemark.LoopAtom;
+import art_benchmarks.caffeinemark.MethodAtom;
+import art_benchmarks.caffeinemark.SieveAtom;
+import art_benchmarks.caffeinemark.StringAtom;
+
+/**
+ * Created by iasenov on 9/21/16.
+ */
+public class Test11 extends BaseBenchmark{
+
+    private String TAG = "Caffeine(ART)";
+    static boolean  isJavaCanceled = false;
+
+    public String startBenchmark(int count) {
+
+        isJavaCanceled = false;
+
+        version = " Caffeine(ART) ";
+        benchmarkName = "Test11";
+        integrationType = "SL";
+
+        long before;
+        long after;
+
+
+        clear();
+
+        //****Redirect System.out and Syste.err****
+        PrintStream stdOut = System.out;
+        PrintStream stdErrt = System.err;
+
+        PrintStream interceptor_stdout = new Interceptor(stdOut);
+        PrintStream interceptor_err = new Interceptor(stdErrt);
+        System.setOut(interceptor_stdout);// just add the interceptor
+        System.setErr(interceptor_err);// just add the interceptor
+        //****Redirect System.out and Syste.err****
+
+        startTest = System.currentTimeMillis();
+
+
+        if(isJavaCanceled) return "";
+        //***********FloatAtom*************
+        int rc = 0;
+        FloatAtom obj = new FloatAtom();
+
+        before = System.currentTimeMillis();
+        obj.timeFloatAtom(100);
+        after = System.currentTimeMillis();
+
+        if (!obj.verifyFloatAtom()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/caffeinemark/FloatAtom: " + (after - before));
+        //System.exit(rc);
+        //***********FloatAtom*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********LogicAtom*************
+        rc = 0;
+        LogicAtom obj1 = new LogicAtom();
+
+        before = System.currentTimeMillis();
+        obj1.timeLogicAtom(80);
+        after = System.currentTimeMillis();
+
+        if (!obj1.verifyLogicAtom()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/caffeinemark/LogicAtom: " + (after - before));
+        //System.exit(rc);
+        //***********LogicAtom*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********LoopAtom*************
+        rc = 0;
+        LoopAtom obj2 = new LoopAtom();
+
+        before = System.currentTimeMillis();
+        obj2.timeLoopAtom(120);
+        after = System.currentTimeMillis();
+
+        if (!obj2.verifyLoopAtom()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/caffeinemark/LoopAtom: " + (after - before));
+        //System.exit(rc);
+        //***********LoopAtom*************
+
+        if(isJavaCanceled) return "";
+        //***********MethodAtom*************
+        rc = 0;
+        MethodAtom obj3 = new MethodAtom();
+
+        before = System.currentTimeMillis();
+        obj3.timeMethodAtom(9);
+        after = System.currentTimeMillis();
+
+        if (!obj3.verifyMethodAtom()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/caffeinemark/MethodAtom: " + (after - before));
+        //System.exit(rc);
+        //***********MethodAtom*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********SieveAtom*************
+        rc = 0;
+        SieveAtom obj4 = new SieveAtom();
+
+        before = System.currentTimeMillis();
+        obj4.timeSieveAtom(90);
+        after = System.currentTimeMillis();
+
+        if (!obj4.verifySieveAtom()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/caffeinemark/SieveAtom: " + (after - before));
+        //System.exit(rc);
+        //***********SieveAtom*************
+
+
+        if(isJavaCanceled) return "";
+        //***********StringAtom*************
+        rc = 0;
+        StringAtom obj5 = new StringAtom();
+
+        before = System.currentTimeMillis();
+        obj5.timeStringAtom(50);
+        after = System.currentTimeMillis();
+
+        if (!obj5.verifyStringAtom()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/caffeinemark/StringAtom: " + (after - before));
+        //System.exit(rc);
+        //***********StringAtom*************
+
+
+        xout[2] = Interceptor.outputTxt;
+        Interceptor.clear();
+
+        endTest = System.currentTimeMillis();
+
+        return benchmarkName + ":" + getBenchmarkResult(5, integrationType);
+
+    }
+
+    public boolean stopBenchmark(){
+        isJavaCanceled = true;
+        Log.i(TAG, "stopBenchmark: isJNICanceled");
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test12.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test12.java
new file mode 100644
index 0000000..983bf53
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test12.java
@@ -0,0 +1,97 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.PrintStream;
+
+import art_benchmarks.jit_aot.Invoke;
+import art_benchmarks.jit_aot.LoadCheck;
+
+/**
+ * Created by iasenov on 9/21/16.
+ */
+public class Test12 extends BaseBenchmark{
+
+    private String TAG = "Jit-out(ART)";
+    static boolean  isJavaCanceled = false;
+
+    public String startBenchmark(int count) {
+
+        isJavaCanceled = false;
+
+        version = " Jit-out ";
+        benchmarkName = "Test12";
+        integrationType = "SL";
+
+        long before;
+        long after;
+
+
+        clear();
+
+        //****Redirect System.out and Syste.err****
+        PrintStream stdOut = System.out;
+        PrintStream stdErrt = System.err;
+
+        PrintStream interceptor_stdout = new Interceptor(stdOut);
+        PrintStream interceptor_err = new Interceptor(stdErrt);
+        System.setOut(interceptor_stdout);// just add the interceptor
+        System.setErr(interceptor_err);// just add the interceptor
+        //****Redirect System.out and Syste.err****
+
+        startTest = System.currentTimeMillis();
+
+
+        if(isJavaCanceled) return "";
+        //***********Invoke*************
+        int rc = 0;
+        Invoke obj = new Invoke();
+
+        before = System.currentTimeMillis();
+        obj.timeRecursionInvokeVirtual(1000);
+        obj.timeRecursionInvokeStatic(1000);
+        obj.timeRecursionInvokeFinal(1000);
+        obj.timeRecursionInvokePrivate(1000);
+        after = System.currentTimeMillis();
+        if (!obj.verify()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/jit_aot/Invoke: " + (after - before));
+
+        //System.exit(rc);
+        //***********Invoke*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********LoadCheck*************
+        rc = 0;
+        LoadCheck obj1 = new LoadCheck();
+
+        before = System.currentTimeMillis();
+        obj1.timeRandomSumInvokeStaticMethod(10000);
+        obj1.timeRandomSumInvokeUserClass(10000);
+        after = System.currentTimeMillis();
+        if (!obj1.verify()) {
+            rc++;
+        }
+        System.out.println("art_benchmarks/jit_aot/LoadCheck: " + (after - before));
+
+        //System.exit(rc);
+        //***********LoadCheck*************
+
+
+        xout[2] = Interceptor.outputTxt;
+        Interceptor.clear();
+
+        endTest = System.currentTimeMillis();
+
+        return benchmarkName + ":" + getBenchmarkResult(5, integrationType);
+    }
+
+    public boolean stopBenchmark(){
+        isJavaCanceled = true;
+        Log.i(TAG, "stopBenchmark: isJNICanceled");
+        return true;
+    }
+}
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test13.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test13.java
new file mode 100644
index 0000000..660b99f
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test13.java
@@ -0,0 +1,102 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.PrintStream;
+
+import art_benchmarks.math.AccessNBody;
+import art_benchmarks.math.MathCordic;
+import art_benchmarks.math.MathPartialSums;
+import art_benchmarks.math.MathSpectralNorm;
+
+/**
+ * Created by iasenov on 9/21/16.
+ */
+public class Test13 extends BaseBenchmark{
+
+    private String TAG = "Math(ART)";
+    static boolean  isJavaCanceled = false;
+
+    public String startBenchmark(int count) {
+
+        isJavaCanceled = false;
+
+        version = " Math(ART) ";
+        benchmarkName = "Test13";
+        integrationType = "SL";
+
+        long before;
+        long after;
+
+
+        clear();
+
+        //****Redirect System.out and Syste.err****
+        PrintStream stdOut = System.out;
+        PrintStream stdErrt = System.err;
+
+        PrintStream interceptor_stdout = new Interceptor(stdOut);
+        PrintStream interceptor_err = new Interceptor(stdErrt);
+        System.setOut(interceptor_stdout);// just add the interceptor
+        System.setErr(interceptor_err);// just add the interceptor
+        //****Redirect System.out and Syste.err****
+
+        startTest = System.currentTimeMillis();
+
+
+        if(isJavaCanceled) return "";
+        //***********AccessNBody*************
+        AccessNBody obj = new AccessNBody();
+        before = System.currentTimeMillis();
+        obj.timeAccessNBody(200);
+        after = System.currentTimeMillis();
+        obj.verify();
+        System.out.println("art_benchmarks/math/AccessNBody: " + (after - before));
+        //***********AccessNBody*************
+
+        if(isJavaCanceled) return "";
+        //***********MathCordic*************
+        MathCordic obj1 = new MathCordic();
+        before = System.currentTimeMillis();
+        obj1.timeMathCordic(175);
+        after = System.currentTimeMillis();
+        obj1.verify();
+        System.out.println("art_benchmarks/math/MathCordic: " + (after - before));
+        //***********MathCordic*************
+
+        if(isJavaCanceled) return "";
+        //***********MathPartialSums*************
+        MathPartialSums obj2 = new MathPartialSums();
+        before = System.currentTimeMillis();
+        obj2.timeMathPartialSums(140);
+        after = System.currentTimeMillis();
+        obj2.verify();
+        System.out.println("art_benchmarks/math/MathPartial: " + (after - before));
+        //***********MathPartialSums*************
+
+        if(isJavaCanceled) return "";
+        //***********MathSpectralNorm*************
+        MathSpectralNorm obj3 = new MathSpectralNorm();
+        before = System.currentTimeMillis();
+        obj3.timeMathSpectralNorm(360);
+        after = System.currentTimeMillis();
+        obj3.verify();
+        System.out.println("art_benchmarks/math/MathSpectralNorm: " + (after - before));
+        //***********MathSpectralNorm*************
+
+
+
+        xout[2] = Interceptor.outputTxt;
+        Interceptor.clear();
+
+        endTest = System.currentTimeMillis();
+
+        return benchmarkName + ":" + getBenchmarkResult(5, integrationType);
+    }
+
+    public boolean stopBenchmark(){
+        isJavaCanceled = true;
+        Log.i(TAG, "stopBenchmark: isJNICanceled");
+        return true;
+    }
+}
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test14.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test14.java
new file mode 100644
index 0000000..3693a56
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test14.java
@@ -0,0 +1,641 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.PrintStream;
+
+import art_benchmarks.micro.Base64;
+import art_benchmarks.micro.BitfieldRotate;
+import art_benchmarks.micro.ControlFlowRecursive;
+import art_benchmarks.micro.Exceptions;
+import art_benchmarks.micro.HashMapBench;
+import art_benchmarks.micro.PrefetchLoopedArrayAccess;
+import art_benchmarks.micro.StringEquals;
+import art_benchmarks.micro.StringOps;
+import art_benchmarks.micro.SystemArrayCopy;
+import art_benchmarks.micro.VectorCalc;
+import art_benchmarks.micro.intrinsics.CRC32Bench;
+import art_benchmarks.micro.intrinsics.Intrinsics;
+import art_benchmarks.micro.intrinsics.Rounding;
+
+import static art_benchmarks.micro.ShifterOperand.*;
+
+
+/**
+ * Created by iasenov on 9/21/16.
+ */
+public class Test14 extends BaseBenchmark{
+
+    private String TAG = "Micro(ART)";
+    static boolean  isJavaCanceled = false;
+
+    public String startBenchmark(int count) {
+
+        isJavaCanceled = false;
+
+        version = " Micro(ART) ";
+        benchmarkName = "Test14";
+        integrationType = "SL";
+
+        long before;
+        long after;
+
+
+        clear();
+
+        //****Redirect System.out and Syste.err****
+        PrintStream stdOut = System.out;
+        PrintStream stdErrt = System.err;
+
+        PrintStream interceptor_stdout = new Interceptor(stdOut);
+        PrintStream interceptor_err = new Interceptor(stdErrt);
+        System.setOut(interceptor_stdout);// just add the interceptor
+        System.setErr(interceptor_err);// just add the interceptor
+        //****Redirect System.out and Syste.err****
+
+        startTest = System.currentTimeMillis();
+
+
+        if(isJavaCanceled) return "";
+        //***********Intrinsics - CRC32Bench*************
+        int rc = 0;
+        final int iterCount = 100;
+        CRC32Bench obj11 = new CRC32Bench();
+
+
+        if(isJavaCanceled) return "";
+        before = System.currentTimeMillis();
+        obj11.timeUpdateInt(iterCount);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/intrinsics/CRC32Bench/UpdateInt: " + (after - before));
+
+        if(isJavaCanceled) return "";
+        before = System.currentTimeMillis();
+        obj11.timeUpdateBytes(iterCount);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/intrinsics/CRC32Bench/UpdateBytes: " + (after - before));
+
+        if (!obj11.verifyCRC32Bench()) {
+            rc++;
+        }
+        //System.exit(rc);
+        //***********Intrinsics - CRC32Bench*************
+
+        if(isJavaCanceled) return "";
+        //***********Intrinsics - Intrinsics*************
+        Intrinsics obj12 = new Intrinsics();
+        before = System.currentTimeMillis();
+        if(isJavaCanceled) return "";
+        obj12.timeNumberOfLeadingZerosInteger(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeNumberOfLeadingZerosIntegerRandom(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeNumberOfLeadingZerosLong(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeNumberOfLeadingZerosLongRandom(100000);
+        if(isJavaCanceled) return "";
+
+        obj12.timeNumberOfTrailingZerosInteger(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeNumberOfTrailingZerosIntegerRandom(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeNumberOfTrailingZerosLong(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeNumberOfTrailingZerosLongRandom(100000);
+        if(isJavaCanceled) return "";
+
+        obj12.timeRotateRightInteger(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeRotateRightLong(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeRotateLeftInteger(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeRotateLeftLong(100000);
+        if(isJavaCanceled) return "";
+
+        obj12.timeRotateRandomInteger(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeRotateRandomLong(100000);
+        if(isJavaCanceled) return "";
+
+        obj12.timeBitCountInteger(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeBitCountLong(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeBitCountIntegerRandom(100000);
+        if(isJavaCanceled) return "";
+        obj12.timeBitCountLongRandom(100000);
+
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/intrinsics/Intrinsics: " + (after - before));
+        //***********Intrinsics - Intrinsics*************
+
+
+        if(isJavaCanceled) return "";
+        //***********Intrinsics - Rounding*************
+        final int ITER_COUNT_1 = 100000;
+
+        Rounding obj13 = new Rounding();
+        before = System.currentTimeMillis();
+
+        obj13.timeRoundPositiveFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeRoundNegativeFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeRoundFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+
+        obj13.timeRoundPositiveDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeRoundNegativeDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeRoundDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+
+        obj13.timeFloorPositiveFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeFloorNegativeFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeFloorFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+
+        obj13.timeFloorPositiveDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeFloorNegativeDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeFloorDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+
+        obj13.timeCeilPositiveFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeCeilNegativeFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeCeilFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+
+        obj13.timeCeilPositiveDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeCeilNegativeDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeCeilDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+
+        obj13.timeFloorFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeFloorDouble(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeCeilFloat(ITER_COUNT_1);
+        if(isJavaCanceled) return "";
+        obj13.timeCeilDouble(ITER_COUNT_1);
+
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/micro/intrinsics/Rounding: " + (after - before));
+        //***********Intrinsics - Rounding*************
+
+
+
+
+
+
+        if(isJavaCanceled) return "";
+        //***********Base64*************
+        Base64 b = new Base64();
+        before = System.currentTimeMillis();
+        b.timeEncode(1300);
+        b.timeDecode(1300);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/Base64: " + (after - before));
+        //***********Base64*************
+
+        if(isJavaCanceled) return "";
+        //***********BitfieldRotate*************
+        BitfieldRotate br = new BitfieldRotate();
+        before = System.currentTimeMillis();
+        br.timeSHA1DigestProcessBlock(300000);
+        if(isJavaCanceled) return "";
+        br.timeIntegerRotateRight(300000);
+        if(isJavaCanceled) return "";
+        br.timeIntegerRotateLeft(300000);
+        if(isJavaCanceled) return "";
+        br.timeLongRotateRight(300000);
+        if(isJavaCanceled) return "";
+        br.timeLongRotateLeft(300000);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/BitfieldRotate: " + (after - before));
+        //***********BitfieldRotate*************
+
+
+        if(isJavaCanceled) return "";
+        //***********ControlFlowRecursive*************
+        rc = 0;
+        long start;
+        long end;
+        ControlFlowRecursive obj = new ControlFlowRecursive();
+
+        start = System.currentTimeMillis();
+        obj.timeControlFlowRecursive(600);
+        end = System.currentTimeMillis();
+        System.out.println(
+                "art_benchmarks/micro/ControlFlowRecursive.ControlFlowRecursive: " + (end - start));
+        if(isJavaCanceled) return "";
+
+        start = System.currentTimeMillis();
+        obj.timeTak(2000);
+        end = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/ControlFlowRecursive.Tak: " + (end - start));
+        if(isJavaCanceled) return "";
+
+        start = System.currentTimeMillis();
+        obj.timeTarai(10);
+        end = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/ControlFlowRecursive.Tarai: " + (end - start));
+
+        if (!obj.verifyTakTarai() || !obj.verifyControlFlowRecursive()) {
+            rc++;
+        }
+        //System.exit(rc);
+        //***********ControlFlowRecursive*************
+
+
+        if(isJavaCanceled) return "";
+        //***********Exceptions*************
+        rc = 0;
+        final int TIME_FUNCTIONS_ITERS = 1000;
+        Exceptions obj1 = new Exceptions();
+        before = System.currentTimeMillis();
+        obj1.timeArithmDoubleExceptionFires(10);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/Exceptions.arithmDoubleExceptionFires: "
+                + (after - before));
+        if(isJavaCanceled) return "";
+
+        before = System.currentTimeMillis();
+        obj1.timeArithmDoubleException(TIME_FUNCTIONS_ITERS);
+        if(isJavaCanceled) return "";
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/Exceptions.arithmDoubleException: " + (after - before));
+
+        before = System.currentTimeMillis();
+        obj1.timeArithmDouble(TIME_FUNCTIONS_ITERS);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/Exceptions.arithmDouble: " + (after - before));
+
+        if (!obj1.verify()) {
+            rc++;
+        }
+        //System.exit(rc);
+        //***********Exceptions*************
+
+
+        if(isJavaCanceled) return "";
+        //***********HashMapBench*************
+        HashMapBench obj2 = new HashMapBench();
+        before = System.currentTimeMillis();
+        obj2.timeTestHashMap(100);
+
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/HashMapBench: " + (after - before));
+        //***********HashMapBench*************
+
+
+        if(isJavaCanceled) return "";
+        //***********PrefetchLoopedArrayAccess*************
+        PrefetchLoopedArrayAccess obj3 = new PrefetchLoopedArrayAccess();
+        before = System.currentTimeMillis();
+        obj3.timeRun(22000);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/PrefetchLoopedArrayAccess: " + (after - before));
+        //***********PrefetchLoopedArrayAccess*************
+
+        if(isJavaCanceled) return "";
+        //***********ShifterOperand*************
+        rc = 0;
+        int iterations = 100000;
+
+        String prefix = "art_benchmarks/micro/ShifterOperand/";
+
+        // CHECKSTYLE.OFF: LineLength
+        // CHECKSTYLE.OFF: OneStatementPerLine
+        // CHECKSTYLE.OFF: LeftCurly
+        start = System.currentTimeMillis(); timeIntSingleUseLatency1(50000000); end = System.currentTimeMillis();
+        if (!verifyIntSingleUseLatency1()) { rc++; }
+        System.out.println(prefix + "IntSingleUseLatency1: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeIntSingleUseLatency1Thread2(30000000); end = System.currentTimeMillis();
+        if (!verifyIntSingleUseLatency1Thread2()) { rc++; }
+        System.out.println(prefix + "IntSingleUseLatency1Thread2: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeIntSingleUseLatency1Thread3(20000000); end = System.currentTimeMillis();
+        if (!verifyIntSingleUseLatency1Thread3()) { rc++; }
+        System.out.println(prefix + "IntSingleUseLatency1Thread3: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeIntSingleUseLatency1Thread4(15000000); end = System.currentTimeMillis();
+        if (!verifyIntSingleUseLatency1Thread4()) { rc++; }
+        System.out.println(prefix + "IntSingleUseLatency1Thread4: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeIntSingleUseLatency2(40000000); end = System.currentTimeMillis();
+        if (!verifyIntSingleUseLatency2()) { rc++; }
+        System.out.println(prefix + "IntSingleUseLatency2: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeIntSingleUseLatency3(50000000); end = System.currentTimeMillis();
+        if (!verifyIntSingleUseLatency3()) { rc++; }
+        System.out.println(prefix + "IntSingleUseLatency3: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeIntSingleUseLatencyLoop(70000000); end = System.currentTimeMillis();
+        if (!verifyIntSingleUseLatencyLoop()) { rc++; }
+        System.out.println(prefix + "IntSingleUseLatencyLoop: " + (end - start));
+
+        // The `long` versions use the same iteration counts as the `int` versions
+        // above.
+        start = System.currentTimeMillis(); timeLongSingleUseLatency1(50000000); end = System.currentTimeMillis();
+        if (!verifyLongSingleUseLatency1()) { rc++; }
+        System.out.println(prefix + "LongSingleUseLatency1: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeLongSingleUseLatency1Thread2(30000000); end = System.currentTimeMillis();
+        if (!verifyLongSingleUseLatency1Thread2()) { rc++; }
+        System.out.println(prefix + "LongSingleUseLatency1Thread2: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeLongSingleUseLatency1Thread3(20000000); end = System.currentTimeMillis();
+        if (!verifyLongSingleUseLatency1Thread3()) { rc++; }
+        System.out.println(prefix + "LongSingleUseLatency1Thread3: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeLongSingleUseLatency1Thread4(15000000); end = System.currentTimeMillis();
+        if (!verifyLongSingleUseLatency1Thread4()) { rc++; }
+        System.out.println(prefix + "LongSingleUseLatency1Thread4: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeLongSingleUseLatency2(40000000); end = System.currentTimeMillis();
+        if (!verifyLongSingleUseLatency2()) { rc++; }
+        System.out.println(prefix + "LongSingleUseLatency2: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeLongSingleUseLatency3(50000000); end = System.currentTimeMillis();
+        if (!verifyLongSingleUseLatency3()) { rc++; }
+        System.out.println(prefix + "LongSingleUseLatency3: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeLongSingleUseLatencyLoop(70000000); end = System.currentTimeMillis();
+        if (!verifyLongSingleUseLatencyLoop()) { rc++; }
+        System.out.println(prefix + "LongSingleUseLatencyLoop: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeMultipleUsesDifferentPathInt(50000000); end = System.currentTimeMillis();
+        if (!verifyMultipleUsesDifferentPathInt()) { rc++; }
+        System.out.println(prefix + "MultipleUsesDifferentPathInt: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeMultipleSuccessiveUsesSamePathInt(35000000); end = System.currentTimeMillis();
+        if (!verifyMultipleSuccessiveUsesSamePathInt()) { rc++; }
+        System.out.println(prefix + "MultipleSuccessiveUsesSamePathInt: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeMultipleSeparatedUsesSamePathInt(40000000); end = System.currentTimeMillis();
+        if (!verifyMultipleSeparatedUsesSamePathInt()) { rc++; }
+        System.out.println(prefix + "MultipleSeparatedUsesSamePathInt: " + (end - start));
+
+        // The `long` versions use the same iteration counts as the `int` versions
+        // above.
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeMultipleUsesDifferentPathLong(50000000); end = System.currentTimeMillis();
+        if (!verifyMultipleUsesDifferentPathLong()) { rc++; }
+        System.out.println(prefix + "MultipleUsesDifferentPathLong: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeMultipleSuccessiveUsesSamePathLong(35000000); end = System.currentTimeMillis();
+        if (!verifyMultipleSuccessiveUsesSamePathLong()) { rc++; }
+        System.out.println(prefix + "MultipleSuccessiveUsesSamePathLong: " + (end - start));
+
+        if(isJavaCanceled) return "";
+        start = System.currentTimeMillis(); timeMultipleSeparatedUsesSamePathLong(40000000); end = System.currentTimeMillis();
+        if (!verifyMultipleSeparatedUsesSamePathLong()) { rc++; }
+        System.out.println(prefix + "MultipleSeparatedUsesSamePathLong: " + (end - start));
+        // CHECKSTYLE.ON: LineLength
+        // CHECKSTYLE.ON: OneStatementPerLine
+        // CHECKSTYLE.ON: LeftCurly
+
+        //System.exit(rc);
+        //***********ShifterOperand*************
+
+        if(isJavaCanceled) return "";
+        //***********StringEquals*************
+        StringEquals eq = new StringEquals();
+        before = System.currentTimeMillis();
+        eq.timeEquals(1500);
+        eq.timeEquals(1500);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/StringEquals: " + (after - before));
+        //***********StringEquals*************
+
+        if(isJavaCanceled) return "";
+        //***********StringOps*************
+        int result = 0;
+        final int ITER_COUNT = 22000;
+        StringOps obj4 = new StringOps();
+        before = System.currentTimeMillis();
+        obj4.timeStringEquals008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEquals016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEquals032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEquals128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEquals512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEqualsIgnoreCase008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEqualsIgnoreCase016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEqualsIgnoreCase032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEqualsIgnoreCase128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringEqualsIgnoreCase512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringContentEquals008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringContentEquals016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringContentEquals032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringContentEquals128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringContentEquals512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareTo008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareTo016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareTo032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareTo128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareTo512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareToIgnoreCase008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareToIgnoreCase016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareToIgnoreCase032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareToIgnoreCase128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCompareToIgnoreCase512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatches008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatches016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatches032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatches128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatches512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatchesIgnoreCase008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatchesIgnoreCase016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatchesIgnoreCase032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatchesIgnoreCase128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringRegionMatchesIgnoreCase512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringCharAt(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOf008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOf016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOf032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOf128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOf512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOfAfter008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOfAfter016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOfAfter032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOfAfter128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringIndexOfAfter512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromBytes008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromBytes016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromBytes032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromBytes128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromBytes512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromChars008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromChars016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromChars032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromChars128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromChars512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromString008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromString016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromString032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromString128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringNewStringFromString512(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringGetCharsNoCheck008(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringGetCharsNoCheck016(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringGetCharsNoCheck032(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringGetCharsNoCheck128(ITER_COUNT);
+        if(isJavaCanceled) return "";
+        obj4.timeStringGetCharsNoCheck512(ITER_COUNT);
+
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/StringOps: " + (after - before));
+        //System.exit(result);
+        //***********StringOps*************
+
+
+        if(isJavaCanceled) return "";
+        //***********SystemArrayCopy*************
+        result = 0;
+        SystemArrayCopy obj5 = new SystemArrayCopy();
+        before = System.currentTimeMillis();
+        try {
+            obj5.timeArrayCopySmall(ITER_COUNT);
+            if(isJavaCanceled) return "";
+            obj5.timeArrayCopyMedium(ITER_COUNT);
+            if(isJavaCanceled) return "";
+            obj5.timeArrayCopyLarge(ITER_COUNT);
+            if(isJavaCanceled) return "";
+
+            obj5.timeArrayCopyCharBufferedReadSmall(ITER_COUNT);
+            obj5.timeArrayCopyCharBufferedReadMedium(ITER_COUNT);
+            if(isJavaCanceled) return "";
+            obj5.timeArrayCopyCharBufferedReadLarge(ITER_COUNT);
+            if (!obj5.verify()) {
+                result++;
+                System.out.println("ERROR: verify() failed.");
+            }
+        } catch (IOException ex) {
+            System.out.println("ERROR: benchmarks/micro/SystemArrayCopy: " + ex.getMessage());
+        }
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/SystemArrayCopy: " + (after - before));
+        //System.exit(result);
+        //***********SystemArrayCopy*************
+
+
+        if(isJavaCanceled) return "";
+        //***********VectorCalc*************
+        final int MAIN_ITERATIONS = 80000;
+
+        VectorCalc obj6 = new VectorCalc();
+        before = System.currentTimeMillis();
+        obj6.timeRun(MAIN_ITERATIONS);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/micro/VectorCalc: " + (after - before));
+        //***********VectorCalc*************
+
+
+
+        xout[2] = Interceptor.outputTxt;
+        Interceptor.clear();
+
+        endTest = System.currentTimeMillis();
+
+        return benchmarkName + ":" + getBenchmarkResult(5, integrationType);
+    }
+
+    public boolean stopBenchmark(){
+        isJavaCanceled = true;
+        Log.i(TAG, "stopBenchmark: isJNICanceled");
+        return true;
+    }
+}
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test15.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test15.java
new file mode 100644
index 0000000..d9475ef
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test15.java
@@ -0,0 +1,279 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.PrintStream;
+
+import art_benchmarks.stanford.Bubblesort;
+import art_benchmarks.stanford.IntMM;
+import art_benchmarks.stanford.Oscar;
+import art_benchmarks.stanford.Perm;
+import art_benchmarks.stanford.Puzzle;
+import art_benchmarks.stanford.Queens;
+import art_benchmarks.stanford.Quicksort;
+import art_benchmarks.stanford.RealMM;
+import art_benchmarks.stanford.Towers;
+import art_benchmarks.stanford.Treesort;
+
+import static art_benchmarks.stanford.Bubblesort.verify_Bubblesort;
+import static art_benchmarks.stanford.IntMM.verify_IntMM;
+import static art_benchmarks.stanford.Oscar.verify_Oscar;
+import static art_benchmarks.stanford.Perm.verify_Perm;
+import static art_benchmarks.stanford.Puzzle.verify_Puzzle;
+import static art_benchmarks.stanford.Queens.verify_Queens;
+import static art_benchmarks.stanford.Quicksort.verify_Quicksort;
+import static art_benchmarks.stanford.RealMM.verify_RealMM;
+import static art_benchmarks.stanford.Towers.verify_Towers;
+import static art_benchmarks.stanford.Treesort.verify_Treesort;
+
+/**
+ * Created by iasenov on 9/21/16.
+ */
+public class Test15 extends BaseBenchmark{
+
+    private String TAG = "Stanford(ART)";
+    static boolean  isJavaCanceled = false;
+
+    public String startBenchmark(int count) {
+
+        isJavaCanceled = false;
+
+        version = " Stanford(ART) ";
+        benchmarkName = "Test15";
+        integrationType = "SL";
+
+        long before;
+        long after;
+
+
+        clear();
+
+        //****Redirect System.out and Syste.err****
+        PrintStream stdOut = System.out;
+        PrintStream stdErrt = System.err;
+
+        PrintStream interceptor_stdout = new Interceptor(stdOut);
+        PrintStream interceptor_err = new Interceptor(stdErrt);
+        System.setOut(interceptor_stdout);// just add the interceptor
+        System.setErr(interceptor_err);// just add the interceptor
+        //****Redirect System.out and Syste.err****
+
+        startTest = System.currentTimeMillis();
+
+        if(isJavaCanceled) return "";
+        //***********Bubblesort*************
+        int rc = 0;
+        Bubblesort obj = new Bubblesort();
+
+        before = System.currentTimeMillis();
+        obj.timeBubble(1000);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Bubblesort: " + (after - before));
+
+        if (!verify_Bubblesort()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Bubblesort*************
+
+
+        if(isJavaCanceled) return "";
+        //***********IntMM*************
+        rc = 0;
+        IntMM obj1 = new IntMM();
+
+        before = System.currentTimeMillis();
+        obj1.timeIntmm(120);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/IntMM: " + (after - before));
+
+        if (!verify_IntMM()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********IntMM*************
+
+
+        if(isJavaCanceled) return "";
+        //***********Oscar*************
+        rc = 0;
+        Oscar obj2 = new Oscar();
+
+        before = System.currentTimeMillis();
+        obj2.timeOscar(600);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Oscar: " + (after - before));
+
+        if (!verify_Oscar()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Oscar*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********Perm*************
+        rc = 0;
+        Perm obj3 = new Perm();
+
+        before = System.currentTimeMillis();
+        obj3.timePerm(500);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Perm: " + (after - before));
+
+        if (!verify_Perm()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Perm*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********Puzzle*************
+        rc = 0;
+        Puzzle obj4 = new Puzzle();
+
+        before = System.currentTimeMillis();
+        obj4.timePuzzle(125);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Puzzle: " + (after - before));
+
+        if (!verify_Puzzle()) {
+            rc = obj4.error;
+        }
+
+        //System.exit(rc);
+        //***********Puzzle*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********Queens*************
+        rc = 0;
+        Queens obj5 = new Queens();
+
+        before = System.currentTimeMillis();
+        obj5.timeQueens(1000);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Queens: " + (after - before));
+
+        if (!verify_Queens()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Queens*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********Quicksort*************
+        rc = 0;
+        Quicksort obj6 = new Quicksort();
+
+        before = System.currentTimeMillis();
+        obj6.timeQuicksort(1200);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Quicksort: " + (after - before));
+
+        if (!verify_Quicksort()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Quicksort*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********RealMM*************
+        rc = 0;
+        RealMM obj7 = new RealMM();
+
+        before = System.currentTimeMillis();
+        obj7.timeRealMM(800);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/RealMM: " + (after - before));
+
+        if (!verify_RealMM()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********RealMM*************
+
+
+
+        if(isJavaCanceled) return "";
+        //***********Towers*************
+        rc = 0;
+        Towers obj8 = new Towers();
+
+        before = System.currentTimeMillis();
+        obj8.timeTowers(500);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Towers: " + (after - before));
+
+        if (!verify_Towers()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Towers*************
+
+
+
+
+        if(isJavaCanceled) return "";
+        //***********Treesort*************
+        rc = 0;
+        Treesort obj9 = new Treesort();
+
+        before = System.currentTimeMillis();
+        obj9.timeTreesort(2500);
+        after = System.currentTimeMillis();
+
+        System.out.println("art_benchmarks/stanford/Treesort: " + (after - before));
+
+        if (!verify_Treesort()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Treesort*************
+
+
+
+
+
+
+
+        xout[2] = Interceptor.outputTxt;
+        Interceptor.clear();
+
+        endTest = System.currentTimeMillis();
+
+        return benchmarkName + ":" + getBenchmarkResult(5, integrationType);
+    }
+
+    public boolean stopBenchmark(){
+        isJavaCanceled = true;
+        Log.i(TAG, "stopBenchmark: isJNICanceled");
+        return true;
+    }
+}
diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test9.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test9.java
new file mode 100644
index 0000000..f0a885d
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test9.java
@@ -0,0 +1,266 @@
+package org.linaro.iasenov.benchmarkframework;
+
+import android.util.Log;
+
+import java.io.PrintStream;
+
+import art_benchmarks.algorithm.AccessFannkuch;
+import art_benchmarks.algorithm.BitopsNSieve;
+import art_benchmarks.algorithm.CryptoMD5;
+import art_benchmarks.algorithm.CryptoSHA1;
+import art_benchmarks.algorithm.DeltaBlue;
+import art_benchmarks.algorithm.Dhrystone;
+import art_benchmarks.algorithm.Linpack;
+import art_benchmarks.algorithm.NSieve;
+import art_benchmarks.algorithm.Richards;
+import art_benchmarks.algorithm.Sort;
+
+/**
+ * Created by iasenov on 9/20/16.
+ */
+public class Test9 extends BaseBenchmark{
+
+    private String TAG = "Algorithm(ART)";
+    static boolean  isJavaCanceled = false;
+
+    public String startBenchmark(int count) {
+
+        isJavaCanceled = false;
+
+        version = " Algorithm ";
+        benchmarkName = "Test9";
+        integrationType = "SL";
+
+        long before;
+        long after;
+
+
+        clear();
+
+        //****Redirect System.out and Syste.err****
+        PrintStream stdOut = System.out;
+        PrintStream stdErrt = System.err;
+
+        PrintStream interceptor_stdout = new Interceptor(stdOut);
+        PrintStream interceptor_err = new Interceptor(stdErrt);
+        System.setOut(interceptor_stdout);// just add the interceptor
+        System.setErr(interceptor_err);// just add the interceptor
+        //****Redirect System.out and Syste.err****
+
+        startTest = System.currentTimeMillis();
+
+
+        if(isJavaCanceled) return "";
+        //***********AccessFannkuch*************
+        AccessFannkuch obj1 = new AccessFannkuch();
+        before = System.currentTimeMillis();
+        obj1.timeAccessFannkuch(109);
+        after = System.currentTimeMillis();
+        obj1.verify();
+        System.out.println("art_benchmarks/algorithm/AccessFankuch: " + (after - before));
+        //***********AccessFannkuch*************
+
+
+        if(isJavaCanceled) return "";
+        //***********BitopsNSieve*************
+        BitopsNSieve obj2 = new BitopsNSieve();
+        before = System.currentTimeMillis();
+        obj2.timeBitopsNSieve(189);
+        after = System.currentTimeMillis();
+        obj2.verify();
+        System.out.println("art_benchmarks/algorithm/BitopsNSieve: " + (after - before));
+        //***********BitopsNSieve*************
+
+
+        if(isJavaCanceled) return "";
+        //***********CryptoMD5*************
+        CryptoMD5 obj3 = new CryptoMD5();
+        before = System.currentTimeMillis();
+        obj3.timeHexMD5(2305);
+        after = System.currentTimeMillis();
+        obj3.verify();
+        System.out.println("art_benchmarks/algorithm/CryptoMD5: " + (after - before));
+        //***********CryptoMD5*************
+
+
+        if(isJavaCanceled) return "";
+        //***********CryptoSHA1*************
+        CryptoSHA1 obj4 = new CryptoSHA1();
+        before = System.currentTimeMillis();
+        obj4.timeHexSHA1(1600);
+        after = System.currentTimeMillis();
+        obj4.verify();
+        System.out.println("art_benchmarks/algorithm/CryptoSHA1: " + (after - before));
+        //***********CryptoSHA1*************
+
+
+        if(isJavaCanceled) return "";
+        // /***********DeltaBlue*************
+        int rc = 0;
+        DeltaBlue obj5 = new DeltaBlue();
+
+        before = System.currentTimeMillis();
+        obj5.timeDeltaBlue(300);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/DeltaBlue: " + (after - before));
+        if (!obj5.verifyDeltaBlue()) {
+            rc++;
+        }
+        //System.exit(rc);
+        //***********DeltaBlue*************
+
+
+        if(isJavaCanceled) return "";
+        //***********Dhrystone*************
+        rc = 0;
+        Dhrystone obj6 = new Dhrystone();
+
+        before = System.currentTimeMillis();
+        obj6.timeDhrystone(1);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Dhrystone: " + (after - before));
+        if (!obj6.verifyDhrystone()) {
+            rc++;
+        }
+        //System.exit(rc);
+        //***********Dhrystone*************
+
+
+        if(isJavaCanceled) return "";
+        //***********Linpack*************
+        rc = 0;
+        Linpack obj7 = new Linpack();
+
+
+        before = System.currentTimeMillis();
+        obj7.timeLinpack(200);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Linpack: " + (after - before));
+
+        if (!obj7.verifyLinpack()) {
+            rc++;
+        }
+
+        //System.exit(rc);
+        //***********Linpack*************
+
+
+        if(isJavaCanceled) return "";
+        //***********NSieve*************
+        NSieve obj8 = new NSieve();
+        before = System.currentTimeMillis();
+        obj8.timeNSieveAccess(100);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/NSieve.NSieveAccess: " + (after - before));
+        //***********NSieve*************
+
+        if(isJavaCanceled) return "";
+        //***********Richards*************
+        Richards obj9 = new Richards();
+        before = System.currentTimeMillis();
+        obj9.timeRichards(1200);
+        after = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Richards: " + (after - before));
+        //***********Richards*************
+
+        if(isJavaCanceled) return "";
+        //***********Sort*************
+        rc = 0;
+        long b;               // before
+        long a;               // after
+        Sort o = new Sort();  // object
+
+        // The number of iterations run were calibrated so that each benchmark runs in about one second.
+
+        // CHECKSTYLE.OFF: LineLength
+        // CHECKSTYLE.OFF: OneStatementPerLine
+        b = System.currentTimeMillis(); o.timeBubbleSort____16(700000); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.BubbleSort____16: " + (a - b));
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeBubbleSort___128(15500); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.BubbleSort___128: " + (a - b));
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeBubbleSort__2048(60); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.BubbleSort__2048: " + (a - b));
+        if (!o.verifyBubbleSort()) {
+            rc++;
+        }
+
+        b = System.currentTimeMillis(); o.timeInsertionSort____16(1450000); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.InsertionSort____16: " + (a - b));
+
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeInsertionSort___128(40000); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.InsertionSort___128: " + (a - b));
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeInsertionSort__2048(170); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.InsertionSort__2048: " + (a - b));
+        if (!o.verifyInsertionSort()) {
+            rc++;
+        }
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeMergeSort____16(110000); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.MergeSort____16: " + (a - b));
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeMergeSort___128(12000); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.MergeSort___128: " + (a - b));
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeMergeSort__2048(600); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.MergeSort__2048: " + (a - b));
+        if (!o.verifyMergeSort()) {
+            rc++;
+        }
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeSystemSort____16(1200000); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.SystemSort____16: " + (a - b));
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeSystemSort___128(100000); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.SystemSort___128: " + (a - b));
+
+        if(isJavaCanceled) return "";
+
+        b = System.currentTimeMillis(); o.timeSystemSort__2048(6250); a = System.currentTimeMillis();
+        System.out.println("art_benchmarks/algorithm/Sort.SystemSort__2048: " + (a - b));
+        if (!o.verifySystemSort()) {
+            rc++;
+        }
+        // CHECKSTYLE.ON: OneStatementPerLine
+        // CHECKSTYLE.ON: LineLength
+
+        //System.exit(rc);
+        //***********Sort*************
+
+
+        xout[2] = Interceptor.outputTxt;
+        Interceptor.clear();
+
+        endTest = System.currentTimeMillis();
+
+        return benchmarkName + ":" + getBenchmarkResult(5, integrationType);
+    }
+
+
+    public boolean stopBenchmark(){
+        isJavaCanceled = true;
+        Log.i(TAG, "stopBenchmark: isJNICanceled");
+        return true;
+    }
+}
diff --git a/BenchmarkFramework/app/src/main/res/drawable/grid_items_border.xml b/BenchmarkFramework/app/src/main/res/drawable/grid_items_border.xml
new file mode 100644
index 0000000..cb64738
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/res/drawable/grid_items_border.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content">
+
+ <solid android:color="#fff8ce" />
+ <stroke
+ android:width="2dp"
+ android:color="#fd0261" ></stroke>
+
+</shape>
diff --git a/BenchmarkFramework/app/src/main/res/layout/activity_main.xml b/BenchmarkFramework/app/src/main/res/layout/activity_main.xml
index 733dd82..239e22a 100644
--- a/BenchmarkFramework/app/src/main/res/layout/activity_main.xml
+++ b/BenchmarkFramework/app/src/main/res/layout/activity_main.xml
@@ -104,12 +104,12 @@
             android:maxLines = "20"
             android:scrollbars = "vertical"
             android:textStyle="bold"
-            android:layout_weight="1">
+            android:layout_weight="4">
         </TextView>
 
 
 
-
+        <!--
         <ListView
             android:id="@+id/tests_list_view"
             android:layout_width="match_parent"
@@ -120,6 +120,28 @@
             android:background="#fff8ce"
             android:layout_weight="1">
             ></ListView>
+        -->
+        <GridView android:id="@+id/listGrid"
+            android:layout_width="match_parent" android:layout_height="0dp"
+            android:numColumns="2" android:verticalSpacing="1dp"
+            android:horizontalSpacing="10dp" android:columnWidth="90dp"
+            android:stretchMode="columnWidth" android:gravity="center"
+            android:background="#fff8ce"
+            android:layout_marginLeft="2dp"
+            android:layout_marginRight="2dp"
+            android:layout_marginBottom="2dp"
+            android:layout_weight="4"
+            />
+
+        <Button
+            android:id="@+id/showHideDisplay"
+            android:layout_width="match_parent"
+            android:layout_height="40dp"
+            android:text="Hide Display"
+            android:background="@drawable/buttonshape"
+            android:textColor="#FFFFFF"
+            android:layout_gravity="center_horizontal">
+        </Button>
 
 
     </LinearLayout>
diff --git a/BenchmarkFramework/app/src/main/res/layout/listview.xml b/BenchmarkFramework/app/src/main/res/layout/listview.xml
new file mode 100644
index 0000000..f6ca2c0
--- /dev/null
+++ b/BenchmarkFramework/app/src/main/res/layout/listview.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent" android:layout_height="match_parent">
+    <TextView android:id="@+id/itemText" android:layout_width="wrap_content"
+        android:layout_height="wrap_content" android:layout_alignParentLeft="true"
+        android:layout_alignParentBottom="true"
+        android:layout_alignParentTop="true"/>
+    <CheckBox android:id="@+id/itemCheckBox" android:layout_width="wrap_content"
+        android:layout_height="wrap_content" android:layout_alignParentRight="true"
+        android:layout_toRightOf="@id/itemText"
+        android:layout_alignParentBottom="true"
+        android:buttonTint="#3366CC"
+        android:scaleX="0.90"
+        android:scaleY="0.90"/>
+</RelativeLayout>
\ No newline at end of file
diff --git a/BenchmarkFramework/shellscript/runTestsFromShell.sh b/BenchmarkFramework/shellscript/runTestsFromShell.sh
index b275f5c..88dfb6a 100755
--- a/BenchmarkFramework/shellscript/runTestsFromShell.sh
+++ b/BenchmarkFramework/shellscript/runTestsFromShell.sh
@@ -97,6 +97,13 @@ echo "Test5 = Linaro-Harness"
 echo "Test6 = Linaro-Dhrystone"
 echo "Test7 = Iozone"
 echo "Test8 = Bonnie++"
+echo "Test9 = Algorithm(ART)"
+echo "Test10 = BMsGame(ART)"
+echo "Test11 = Caffeine(ART)"
+echo "Test12 = Jit-out(ART)"
+echo "Test13 = Math(ART)"
+echo "Test14 = Micro(ART)"
+echo "Test15 = Stanford(ART)"
 echo ""