summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--pom.xml2
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/AccessFannkuch.java113
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/BitopsNSieve.java75
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/CryptoMD5.java271
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/CryptoSHA1.java220
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/Dhrystone.java390
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/Linpack.java671
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/NSieve.java67
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/Richards.java648
-rw-r--r--src/main/java/org/linaro/benchmarks/algorithm/Sort.java469
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/LICENSE34
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/binarytrees.java102
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/chameneosredux.java253
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/fannkuchredux.java94
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/fasta.java173
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/fastaredux.java204
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/knucleotide.java1312
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/mandelbrot.java104
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/meteor.java479
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/nbody.java204
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/pidigits.java156
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/regexdna.java1160
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/revcomp.java1103
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/spectralnorm.java112
-rw-r--r--src/main/java/org/linaro/benchmarks/benchmarksgame/threadring.java120
-rw-r--r--src/main/java/org/linaro/benchmarks/jit_aot/Invoke.java92
-rw-r--r--src/main/java/org/linaro/benchmarks/jit_aot/LoadCheck.java97
-rw-r--r--src/main/java/org/linaro/benchmarks/math/AccessNBody.java208
-rw-r--r--src/main/java/org/linaro/benchmarks/math/MathCordic.java116
-rw-r--r--src/main/java/org/linaro/benchmarks/math/MathPartialSums.java77
-rw-r--r--src/main/java/org/linaro/benchmarks/math/MathSpectralNorm.java90
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/ArrayAccess.java68
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/Base64.java139
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/BitfieldRotate.java302
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/ControlFlowRecursive.java84
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/Exceptions.java118
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/HashMapBench.java101
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/PrefetchLoopedArrayAccess.java78
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/ShifterOperand.java548
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/StringEquals.java73
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/StringOps.java425
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/SystemArrayCopy.java115
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/VectorCalc.java83
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/intrinsics/CRC32Bench.java70
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java272
-rw-r--r--src/main/java/org/linaro/benchmarks/micro/intrinsics/MathIntrinsics.java367
-rw-r--r--src/main/java/org/linaro/benchmarks/misc/TestAddSubExtension.java427
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Bubblesort.java81
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/IntMM.java75
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Oscar.java168
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Perm.java68
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Puzzle.java128
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Queens.java80
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Quicksort.java87
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/RealMM.java68
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Towers.java128
-rw-r--r--src/main/java/org/linaro/benchmarks/stanford/Treesort.java108
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestRGBToCmyk.java (renamed from src/main/java/org/linaro/benchmarks/TestRGBToCmyk.java)9
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestReduceAdd.java (renamed from src/main/java/org/linaro/benchmarks/TestReduceAdd.java)29
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDAdd.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDAdd.java)74
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDCopy.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDCopy.java)67
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDFma.java223
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDLd2St2.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDLd2St2.java)15
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDLd3St3.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDLd3St3.java)15
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDLd4St4.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDLd4St4.java)15
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaInt.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDMlaInt.java)17
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaShort.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDMlaShort.java)29
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDMul.java (renamed from src/main/java/org/linaro/benchmarks/TestSIMDMul.java)74
-rw-r--r--src/main/java/org/linaro/benchmarks/vector/TestSIMDMulC.java85
69 files changed, 14068 insertions, 61 deletions
diff --git a/pom.xml b/pom.xml
index 18d3c70..8d9c9cc 100644
--- a/pom.xml
+++ b/pom.xml
@@ -67,7 +67,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
<!--
JMH version to use with this project.
-->
- <jmh.version>1.13</jmh.version>
+ <jmh.version>1.17.5</jmh.version>
<!--
Java source/target to use for compilation.
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/AccessFannkuch.java b/src/main/java/org/linaro/benchmarks/algorithm/AccessFannkuch.java
new file mode 100644
index 0000000..c999216
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/AccessFannkuch.java
@@ -0,0 +1,113 @@
+/*
+ * 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 org.linaro.benchmarks.algorithm;
+
+import java.lang.Integer;
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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++;
+ }
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeAccessFannkuch() {
+ fannkuch(8);
+ }
+}
+
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/BitopsNSieve.java b/src/main/java/org/linaro/benchmarks/algorithm/BitopsNSieve.java
new file mode 100644
index 0000000..8904fe7
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/BitopsNSieve.java
@@ -0,0 +1,75 @@
+/*
+ * 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 org.linaro.benchmarks.algorithm;
+
+import java.lang.Integer;
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+
+ @Benchmark
+ public void jmhTimeBitopsNSieve() {
+ sieve();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/CryptoMD5.java b/src/main/java/org/linaro/benchmarks/algorithm/CryptoMD5.java
new file mode 100644
index 0000000..4641b01
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/CryptoMD5.java
@@ -0,0 +1,271 @@
+/*
+ * 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 org.linaro.benchmarks.algorithm;
+
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+
+ @Benchmark
+ public void jmhTimeHexMD5() {
+ hexMD5(TEXT);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/CryptoSHA1.java b/src/main/java/org/linaro/benchmarks/algorithm/CryptoSHA1.java
new file mode 100644
index 0000000..846d7e3
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/CryptoSHA1.java
@@ -0,0 +1,220 @@
+/*
+ * 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 org.linaro.benchmarks.algorithm;
+
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+
+ @Benchmark
+ public void jmhTimeHexSHA1() {
+ hexSHA1(TEXT);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Dhrystone.java b/src/main/java/org/linaro/benchmarks/algorithm/Dhrystone.java
new file mode 100644
index 0000000..c0986f0
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/Dhrystone.java
@@ -0,0 +1,390 @@
+/*
+ * 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 org.linaro.benchmarks.algorithm;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+class Record {
+ Record ptrComp;
+ int discr;
+ int enumComp;
+ int intComp;
+ StringBuilder strComp;
+ int enumComp2;
+ char ch1Comp;
+ char ch2Comp;
+}
+
+class Pointer<T> {
+ T ref;
+}
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+
+
+
+ @Benchmark
+ public void jmhTimeDhrystone() {
+ 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 */
+ }
+ }
+
+ /* 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;
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Linpack.java b/src/main/java/org/linaro/benchmarks/algorithm/Linpack.java
new file mode 100644
index 0000000..d0d4119
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/Linpack.java
@@ -0,0 +1,671 @@
+/*
+
+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 org.linaro.benchmarks.algorithm;
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+
+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);
+ }
+
+ @Benchmark
+ public void jmhTimeLinpack() {
+ runLinpack();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/NSieve.java b/src/main/java/org/linaro/benchmarks/algorithm/NSieve.java
new file mode 100644
index 0000000..08a3fee
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/NSieve.java
@@ -0,0 +1,67 @@
+/*
+ * 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 org.linaro.benchmarks.algorithm;
+
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+
+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
+ **/
+ @Benchmark
+ public void jmhTimeNSieveAccess() {
+ 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;
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Richards.java b/src/main/java/org/linaro/benchmarks/algorithm/Richards.java
new file mode 100644
index 0000000..eee1a43
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/Richards.java
@@ -0,0 +1,648 @@
+/*
+ * 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.
+ * (2) Added timeRichards() method for running with different iterations.
+ * (3) Changed arrays from using GWT library classes (JavaScriptArray,
+ * CollectionFactory, etc) into standard java arrays.
+ */
+
+package org.linaro.benchmarks.algorithm;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+// 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 org.linaro.benchmarks.algorithm;
+ * 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.
+ */
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+
+
+ @Benchmark // CHECKSTYLE.ON: .*
+ public void jmhTimeRichards() {
+ runRichards();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/algorithm/Sort.java b/src/main/java/org/linaro/benchmarks/algorithm/Sort.java
new file mode 100644
index 0000000..10f003a
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/algorithm/Sort.java
@@ -0,0 +1,469 @@
+/*
+ * 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 org.linaro.benchmarks.algorithm;
+
+import java.lang.System;
+import java.util.ArrayList;
+import java.util.Arrays;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public class Sort {
+ private final int ITERS = 10;
+
+ 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[]>();
+
+ public static int[] array_16 = new int[16];
+ public static int[] array_128 = new int[128];
+ public static int[] array_2048 = new int[2048];
+ public static final int SMALL=16;
+ public static final int MEDIUM=128;
+ public static final int LARGE=2048;
+ public static int[] array_scratch_small = new int[SMALL];
+ public static int[] array_scratch_medium = new int[MEDIUM];
+ public static int[] array_scratch_large = new int[LARGE];
+
+ 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 []array, int iterations) {
+ bubbleSortArraysToVerify.add(array);
+ for (int iter = 0; iter < iterations; ++iter) {
+ initArray(array); // This will include lots of uncertain noise.
+ 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 []array, int iterations) {
+ // 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[] array, int iterations) {
+ int [] scratch;
+ if (array.length <= SMALL) {
+ scratch = array_scratch_small;
+ } else if (array.length > SMALL && array.length <= MEDIUM) {
+ scratch = array_scratch_medium;
+ } else {
+ scratch = array_scratch_large;
+ }
+ // mergeSortArraysToVerify.add(array);
+ for (int iter = 0; iter < iterations; ++iter) {
+ initArray(array); // This will bring noise.
+ 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 [] array, int iterations) {
+ // systemSortArraysToVerify.add(array);
+ for (int iter = 0; iter < iterations; ++iter) {
+ initArray(array); // This will bring noise.
+ 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
+ @Benchmark
+ public void timeBubbleSort____16() { benchBubbleSort(array_16, ITERS*100); }
+ @Benchmark
+ public void timeBubbleSort___128() { benchBubbleSort(array_128, ITERS*10); }
+ @Benchmark
+ public void timeBubbleSort__2048() { benchBubbleSort(array_2048, ITERS); }
+ @Benchmark
+ public void timeInsertionSort____16() { benchInsertionSort(array_16, ITERS*100); }
+ @Benchmark
+ public void timeInsertionSort___128() { benchInsertionSort(array_128, ITERS*10); }
+ @Benchmark
+ public void timeInsertionSort__2048() { benchInsertionSort(array_2048, ITERS); }
+ @Benchmark
+ public void timeMergeSort____16() { benchMergeSort(array_16, ITERS*100); }
+ @Benchmark
+ public void timeMergeSort___128() { benchMergeSort(array_128, ITERS*10); }
+ @Benchmark
+ public void timeMergeSort__2048() { benchMergeSort(array_2048, ITERS); }
+ @Benchmark
+ public void timeSystemSort____16() { benchSystemSort(array_16, ITERS*100); }
+ @Benchmark
+ public void timeSystemSort___128() { benchSystemSort(array_128, ITERS*10); }
+ @Benchmark
+ public void timeSystemSort__2048() { benchSystemSort(array_2048, ITERS); }
+ // CHECKSTYLE.ON: EmptyLineSeparator
+ // CHECKSTYLE.ON: RightCurly
+ // CHECKSTYLE.ON: LeftCurly
+
+ // 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/src/main/java/org/linaro/benchmarks/benchmarksgame/LICENSE b/src/main/java/org/linaro/benchmarks/benchmarksgame/LICENSE
new file mode 100644
index 0000000..330d9e7
--- /dev/null
+++ b/src/main/java/org/linaro/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/src/main/java/org/linaro/benchmarks/benchmarksgame/binarytrees.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/binarytrees.java
new file mode 100644
index 0000000..8ce6f1c
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/binarytrees.java
@@ -0,0 +1,102 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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: .*
+ @Benchmark
+ public void jmhTimeBinaryTrees() {
+ old_main();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/chameneosredux.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/chameneosredux.java
new file mode 100644
index 0000000..6733d6b
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/chameneosredux.java
@@ -0,0 +1,253 @@
+/*
+ * 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 org.linaro.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;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+
+/**
+ * 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 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;
+
+ @Benchmark
+ public void jmhTimeChameneosRedux() {
+ 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);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/fannkuchredux.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/fannkuchredux.java
new file mode 100644
index 0000000..6a644c1
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/fannkuchredux.java
@@ -0,0 +1,94 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+ // 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;
+
+ @Benchmark
+ public void jmhTimeFannkuchRedux() {
+ fannkuch(PREDEFINED_N_PANCAKES);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/fasta.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/fasta.java
new file mode 100644
index 0000000..f662bd3
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/fasta.java
@@ -0,0 +1,173 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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: .*
+
+ @Setup
+ public void setup() {
+ makeCumulative(HomoSapiens);
+ makeCumulative(IUB);
+ }
+
+ @Benchmark
+ public void jmhTimeFasta() {
+ old_main();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/fastaredux.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/fastaredux.java
new file mode 100644
index 0000000..a0a86dd
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/fastaredux.java
@@ -0,0 +1,204 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import java.io.*;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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 {
+ }
+ }
+
+ @Setup
+ public void setup() {
+ sumAndScale(IUB);
+ sumAndScale(HomoSapiens);
+
+ Out.stream = new NullOutputStream();
+ }
+
+ @Benchmark
+ public void jmhTimeFastaRedux() throws IOException {
+ old_main();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/knucleotide.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/knucleotide.java
new file mode 100644
index 0000000..b14ef8a
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/knucleotide.java
@@ -0,0 +1,1312 @@
+/*
+ * 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 org.linaro.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;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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<Entry<Key, Value>>();
+ List<Entry<Key, Value>> sequence2 = new ArrayList<Entry<Key, Value>>();
+
+ 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<Key, Value>();
+ species = ">TH".getBytes();
+ }
+
+ public knucleotide() {
+ temp = new byte[LINE_LENGTH];
+ buffer = new byte[125000000];
+ stream = new ByteArrayInputStream(fastaStr.getBytes());
+ in = new LineInputStream(stream);
+ }
+
+ @Benchmark
+ public void jmhTimeKnucleotide() {
+ reinitBuffers();
+ old_main();
+ stream.reset();
+ }
+
+ 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/src/main/java/org/linaro/benchmarks/benchmarksgame/mandelbrot.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/mandelbrot.java
new file mode 100644
index 0000000..df979d8
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/mandelbrot.java
@@ -0,0 +1,104 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import java.io.IOException;
+import java.io.PrintStream;
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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: .*
+ @Benchmark
+ public void jmhTimeMandelbrot() {
+ bufLen = 0;
+ compute();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/meteor.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/meteor.java
new file mode 100644
index 0000000..6671bb2
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/meteor.java
@@ -0,0 +1,479 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+//package benchmarks.benchmarksgame;
+
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+/** 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();
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeMeteor() {
+ solve();
+ resetMeteor();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/nbody.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/nbody.java
new file mode 100644
index 0000000..ab5ebf3
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/nbody.java
@@ -0,0 +1,204 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+// 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;
+ }
+}
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public 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);
+ }
+ }
+ @Benchmark
+ public void jmhTimeNBody() {
+ solve();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/pidigits.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/pidigits.java
new file mode 100644
index 0000000..fffb7d1
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/pidigits.java
@@ -0,0 +1,156 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+import java.math.BigInteger;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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: .*
+ @Benchmark
+ public void jmhTimePidigits() {
+ old_main();
+ }
+}
+
+
+// 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/src/main/java/org/linaro/benchmarks/benchmarksgame/regexdna.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/regexdna.java
new file mode 100644
index 0000000..63a214c
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/regexdna.java
@@ -0,0 +1,1160 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+// CHECKSTYLE.OFF: .*
+import java.io.*;
+import java.util.regex.*;
+import java.util.*;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public class regexdna {
+
+ private static final Map<String, String> replacements = new HashMap<String, String>();
+ private InputStream stream;
+ private char[] cbuf;
+ private Reader r;
+ private StringBuilder sb;
+ static 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"
+ };
+
+ public regexdna() {
+ stream = new ByteArrayInputStream(fastaStr.getBytes());
+ cbuf = new char[16384];
+ //TODO (jmh) Catch IOException in JMH instead of catched here.
+ // Because class regexdna in art-testing throws IOException not catched here.
+ try {
+ r = new InputStreamReader(stream, "ISO-8859-1");
+ // Move code block below from main loop to here to reduce noise.
+ stream.reset();
+ sb = new StringBuilder(5100000);
+ int charsRead;
+ while ((charsRead = r.read(cbuf)) != -1)
+ sb.append(cbuf, 0, charsRead);
+ // int initialLength = sb.length();
+ } catch (IOException e){
+ e.printStackTrace();
+ }
+ }
+
+ 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 static void main(String [] args) throws Exception {
+ regexdna rd = new regexdna();
+ for (int i = 0; i < 100; i++)
+ rd.old_main();
+ }
+
+ public int old_main() throws IOException {
+
+ String sequence = new Rewriter(">.*\n|\n") {
+
+ public String replacement() {
+ return "";
+ }
+ }.rewrite(sb);
+
+ // int codeLength = sequence.length();
+
+ 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: .*
+
+ @Benchmark
+ public void jmhTimeRegexDna() throws IOException {
+ old_main();
+ }
+
+ 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/src/main/java/org/linaro/benchmarks/benchmarksgame/revcomp.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/revcomp.java
new file mode 100644
index 0000000..0c2f88d
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/revcomp.java
@@ -0,0 +1,1103 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import java.io.*;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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: .*
+ @Benchmark
+ public void jmhTimeRevComp() throws Exception {
+ old_main();
+ }
+
+ 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/src/main/java/org/linaro/benchmarks/benchmarksgame/spectralnorm.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/spectralnorm.java
new file mode 100644
index 0000000..dc6d3c6
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/spectralnorm.java
@@ -0,0 +1,112 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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;
+ }
+ @Benchmark
+ public void jmhTimeSpectralNorm() {
+ Approximate(APPROXIMATE_N);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/benchmarksgame/threadring.java b/src/main/java/org/linaro/benchmarks/benchmarksgame/threadring.java
new file mode 100644
index 0000000..c30713a
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/benchmarksgame/threadring.java
@@ -0,0 +1,120 @@
+/*
+ * 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 org.linaro.benchmarks.benchmarksgame;
+
+import java.util.concurrent.locks.LockSupport;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+// 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;
+ }
+ }
+ @Benchmark
+ public void jmhTimeThreadRing() throws Exception {
+
+ 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
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/jit_aot/Invoke.java b/src/main/java/org/linaro/benchmarks/jit_aot/Invoke.java
new file mode 100644
index 0000000..36a4f76
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/jit_aot/Invoke.java
@@ -0,0 +1,92 @@
+/*
+ * 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 org.linaro.benchmarks.jit_aot;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+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;
+
+ @Benchmark
+ public void jmhTimeRecursionInvokeVirtual() {
+ recursionInvokeVirtual(recursion_depth);
+ }
+
+ @Benchmark
+ public void jmhTimeRecursionInvokeStatic() {
+ recursionInvokeStatic(recursion_depth);
+ }
+
+ @Benchmark
+ public void jmhTimeRecursionInvokeFinal() {
+ recursionInvokeFinal(recursion_depth);
+ }
+
+ @Benchmark
+ public void jmhTimeRecursionInvokePrivate() {
+ recursionInvokePrivate(recursion_depth);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/jit_aot/LoadCheck.java b/src/main/java/org/linaro/benchmarks/jit_aot/LoadCheck.java
new file mode 100644
index 0000000..8f748b8
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/jit_aot/LoadCheck.java
@@ -0,0 +1,97 @@
+/*
+ * 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 org.linaro.benchmarks.jit_aot;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+
+ @Benchmark
+ public void jmhTimeRandomSumInvokeStaticMethod() {
+ randomSumInvokeStaticMethod(loop_size);
+ }
+
+ @Benchmark
+ public void jmhTimeRandomSumInvokeUserClass() {
+ randomSumInvokeUserClass(loop_size);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/math/AccessNBody.java b/src/main/java/org/linaro/benchmarks/math/AccessNBody.java
new file mode 100644
index 0000000..bdeb5c2
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/math/AccessNBody.java
@@ -0,0 +1,208 @@
+/*
+ * 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 org.linaro.benchmarks.math;
+
+import java.lang.Math;
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+
+ @Benchmark
+ public void jmhTimeAccessNBody() {
+ simulateGalaxy();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/math/MathCordic.java b/src/main/java/org/linaro/benchmarks/math/MathCordic.java
new file mode 100644
index 0000000..313e52c
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/math/MathCordic.java
@@ -0,0 +1,116 @@
+/*
+ * 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 org.linaro.benchmarks.math;
+
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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);
+ }
+
+ @Benchmark
+ public double jmhTimeMathCordic() {
+ // When profiling, hot region is in jmhTimeMathCordic_avgt_jmhStub not jmhTimeMathCordic.
+ // This may be caused by inlining jmhTimeMathCordic in jmhTimeMathCordic_avgt_jmhStub.
+ // The following "loops" is added to work around this problem.
+ int loops = 400;
+ double s = 0;
+ for (int i = 0; i < loops; i++) {
+ s += cordicSinCos(TARGET_CONST);
+ }
+ return s;
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/math/MathPartialSums.java b/src/main/java/org/linaro/benchmarks/math/MathPartialSums.java
new file mode 100644
index 0000000..0d7919a
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/math/MathPartialSums.java
@@ -0,0 +1,77 @@
+/*
+ * 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 org.linaro.benchmarks.math;
+
+import java.lang.Exception;
+import java.lang.Math;
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+ @Benchmark
+ public void jmhTimeMathPartialSums() {
+ for (int j = 1024; j <= 5000; j *= 2) {
+ partialSums(j);
+ }
+ }
+}
+
diff --git a/src/main/java/org/linaro/benchmarks/math/MathSpectralNorm.java b/src/main/java/org/linaro/benchmarks/math/MathSpectralNorm.java
new file mode 100644
index 0000000..d44e77a
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/math/MathSpectralNorm.java
@@ -0,0 +1,90 @@
+/*
+ * 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 org.linaro.benchmarks.math;
+
+import java.lang.Math;
+import java.lang.System;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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);
+ }
+ @Benchmark
+ public void jmhTimeMathSpectralNorm() {
+ for (int j = 6; j <= 48; j *= 2) {
+ spectralNorm(j);
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/ArrayAccess.java b/src/main/java/org/linaro/benchmarks/micro/ArrayAccess.java
new file mode 100644
index 0000000..5480562
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/ArrayAccess.java
@@ -0,0 +1,68 @@
+/*
+ * 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.
+ */
+
+/*
+ * Description: Tracks performance of accessing array locations using variables and constants
+ * as indexes.
+ * Main Focus: Memory accesses using arrays.
+ *
+ */
+
+package org.linaro.benchmarks.micro;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public class ArrayAccess {
+
+ private static final int ITER_COUNT = 1000;
+ private int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+ public static void accessArrayConstants(int[] array) {
+ for (int j = 0; j < 100000; j++) {
+ array[4]++;
+ array[5]++;
+ }
+ }
+
+ public static void accessArrayVariables(int[] array, int i) {
+ for (int j = 0; j < 100000; j++) {
+ array[i]++;
+ array[i + 1]++;
+ array[i + 2]++;
+ array[i - 2]++;
+ array[i - 1]++;
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeAccessArrayConstants() {
+ for (int i = 0; i < 1000; i++) {
+ accessArrayConstants(array);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeAccessArrayVariables() {
+ for (int i = 0; i < 1000; i++) {
+ accessArrayVariables(array, 5);
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/Base64.java b/src/main/java/org/linaro/benchmarks/micro/Base64.java
new file mode 100644
index 0000000..df58234
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/Base64.java
@@ -0,0 +1,139 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import java.lang.IllegalArgumentException;
+import java.lang.StringBuilder;
+import java.lang.System;
+import java.lang.Thread;
+import java.util.Random;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+
+ @Benchmark
+ public void jmhTimeEncode() {
+ for (int j = 0; j < NUM_Encodings; j++) {
+ encodeResults[j] = encode(randomStrings[j]);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeDecode() {
+ for (int j = 0; j < NUM_Encodings; j++) {
+ decodeResults[j] = new String(decode(randomBase64[j]));
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/BitfieldRotate.java b/src/main/java/org/linaro/benchmarks/micro/BitfieldRotate.java
new file mode 100644
index 0000000..f3185da
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/BitfieldRotate.java
@@ -0,0 +1,302 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import java.nio.ByteBuffer;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeSHA1DigestProcessBlock() {
+ h1 = h2 = h3 = h4 = h5 = 0;
+ processBlock();
+ }
+
+ /**
+ * 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);
+ }
+
+ @Benchmark
+ public void jmhTimeIntegerRotateRight() {
+ for (int distance = 0; distance < Integer.SIZE; distance++) {
+ resultIntegerRightRegVCSubV += rotateIntegerRightRegVCSubV(0xCAFEBABE, distance);
+ resultIntegerRightRegVNegV += rotateIntegerRightRegVNegV(0xCAFEBABE, distance);
+ }
+ }
+
+ /**
+ * 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);
+ }
+
+ @Benchmark
+ public void jmhTimeIntegerRotateLeft() {
+ for (int distance = 0; distance < Integer.SIZE; distance++) {
+ resultIntegerLeftRegCSubVV += rotateIntegerLeftRegCSubVV(0xCAFEBABE, distance);
+ resultIntegerLeftRegNegVV += rotateIntegerLeftRegNegVV(0xCAFEBABE, distance);
+ }
+ }
+
+ /**
+ * 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);
+ }
+
+ @Benchmark
+ public void jmhTimeLongRotateRight() {
+ for (int distance = 0; distance < Long.SIZE; distance++) {
+ resultLongRightRegVCSubV += rotateLongRightRegVCSubV(0xCAFEBABEBAADF00DL, distance);
+ resultLongRightRegVNegV += rotateLongRightRegVNegV(0xCAFEBABEBAADF00DL, distance);
+ }
+ }
+
+ /**
+ * 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);
+ }
+
+ @Benchmark
+ public void jmhTimeLongRotateLeft() {
+ for (int distance = 0; distance < Long.SIZE; distance++) {
+ resultLongLeftRegCSubVV += rotateLongLeftRegCSubVV(0xCAFEBABEBAADF00DL, distance);
+ resultLongLeftRegNegVV += rotateLongLeftRegNegVV(0xCAFEBABEBAADF00DL, distance);
+ }
+ }
+}
+
diff --git a/src/main/java/org/linaro/benchmarks/micro/ControlFlowRecursive.java b/src/main/java/org/linaro/benchmarks/micro/ControlFlowRecursive.java
new file mode 100644
index 0000000..26b4bf9
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/ControlFlowRecursive.java
@@ -0,0 +1,84 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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));
+ }
+
+ @Benchmark
+ public void jmhTimeTak() {
+ for (int i = 3; i <= 5; i++) {
+ tak(3 * i + 3, 2 * i + 2, i + 1);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeTarai() {
+ for (int i = 3; i <= 5; i++) {
+ tarai(3 * i + 3, 2 * i + 2, i + 1);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeControlFlowRecursive() {
+ 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);
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/Exceptions.java b/src/main/java/org/linaro/benchmarks/micro/Exceptions.java
new file mode 100644
index 0000000..3150f42
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/Exceptions.java
@@ -0,0 +1,118 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public class Exceptions {
+
+ private final int SIZE = 10;
+ private int[] smallArray = new int[SIZE];
+ 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[i%SIZE + 5];
+ smallArray[i%SIZE + 5] += a;
+ } catch (Exception e) {
+ a--;
+ }
+ }
+
+ 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[i%SIZE];
+ smallArray[i%SIZE] += a;
+ } catch (Exception e) {
+ a--;
+ }
+ }
+
+ 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[i%SIZE];
+ smallArray[i%SIZE] += a;
+ }
+
+ return (int)expr + a + (int)x + (int)y + (int)z;
+ }
+
+ @Benchmark
+ public void jmhTimeArithmDoubleException() {
+ //TODO (jmh) Following art-testing, use current iteration as arithmDoubleException's arg instead of 10.
+ arithmDoubleException(10);
+ }
+
+ @Benchmark
+ public void jmhTimeArithmDoubleExceptionFires() {
+ //TODO (jmh) Following art-testing, use current iteration as arithmDoubleException's arg instead of 20.
+ arithmDoubleExceptionFires(20);
+ }
+
+ @Benchmark
+ public void jmhTimeArithmDouble() {
+ //TODO (jmh) Following art-testing, use current iteration as arithmDoubleException's arg instead of 30.
+ arithmDouble(30);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/HashMapBench.java b/src/main/java/org/linaro/benchmarks/micro/HashMapBench.java
new file mode 100644
index 0000000..02ffe14
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/HashMapBench.java
@@ -0,0 +1,101 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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>();
+
+ @Benchmark
+ public void jmhTimeTestHashMap() {
+ 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();
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/PrefetchLoopedArrayAccess.java b/src/main/java/org/linaro/benchmarks/micro/PrefetchLoopedArrayAccess.java
new file mode 100644
index 0000000..d70a20a
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/PrefetchLoopedArrayAccess.java
@@ -0,0 +1,78 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import java.util.BitSet;
+import java.util.Random;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRun() {
+ updateBitSets();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/ShifterOperand.java b/src/main/java/org/linaro/benchmarks/micro/ShifterOperand.java
new file mode 100644
index 0000000..b29f551
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/ShifterOperand.java
@@ -0,0 +1,548 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+
+/*
+ * 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 {
+
+ private static final int LOOP_SIZE = 32;
+
+ @Benchmark
+ public static int jmhTimeIntSingleUseLatency1() {
+ int t1 = 0;
+ for (int iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ // 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.
+
+ @Benchmark
+ public static int jmhTimeIntSingleUseLatency1Thread2() {
+ int t1 = 0, t2 = 1;
+ for (int iter1 = 0, iter2 = 1;
+ iter1 < LOOP_SIZE;
+ 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeIntSingleUseLatency1Thread3() {
+ 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 < LOOP_SIZE;
+ 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeIntSingleUseLatency1Thread4() {
+ 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 < LOOP_SIZE;
+ 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeIntSingleUseLatency2() {
+ int t1 = 0, t2 = 0;
+ for (int iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeIntSingleUseLatency3() {
+ int t1 = 0, t2 = 0, t3 = 0;
+ for (int iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeIntSingleUseLatencyLoop() {
+ int t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0;
+ for (int iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeLongSingleUseLatency1() {
+ long t1 = 0;
+ for (long iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ // 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.
+ @Benchmark
+ public static long jmhTimeLongSingleUseLatency1Thread2() {
+ long t1 = 0, t2 = 1;
+ for (long iter1 = 0, iter2 = 1;
+ iter1 < LOOP_SIZE;
+ 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeLongSingleUseLatency1Thread3() {
+ 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 < LOOP_SIZE;
+ 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeLongSingleUseLatency1Thread4() {
+ 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 < LOOP_SIZE;
+ 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeLongSingleUseLatency2() {
+ long t1 = 0, t2 = 0;
+ for (long iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeLongSingleUseLatency3() {
+ long t1 = 0, t2 = 0, t3 = 0;
+ for (long iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeLongSingleUseLatencyLoop() {
+ long t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0;
+ for (long iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeMultipleUsesDifferentPathInt() {
+ int res = 0;
+ for (int iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeMultipleUsesDifferentPathLong() {
+ long res = 0;
+ for (long iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeMultipleSuccessiveUsesSamePathInt() {
+ int res = 0;
+ for (int iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeMultipleSuccessiveUsesSamePathLong() {
+ long res = 0;
+ for (long iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static int jmhTimeMultipleSeparatedUsesSamePathInt() {
+ int res = 0;
+ for (int iter = 0; iter < LOOP_SIZE; 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;
+ }
+
+ @Benchmark
+ public static long jmhTimeMultipleSeparatedUsesSamePathLong() {
+ long res = 0;
+ for (long iter = 0; iter < LOOP_SIZE; 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;
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/StringEquals.java b/src/main/java/org/linaro/benchmarks/micro/StringEquals.java
new file mode 100644
index 0000000..e0dbc72
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/StringEquals.java
@@ -0,0 +1,73 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import java.lang.StringBuilder;
+import java.util.Random;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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];
+
+ @Setup
+ public void setup() {
+ 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();
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeEquals() {
+ for (int j = 0; j < NUM_Equals - 1; j++) {
+ equalsResults[j] = randomStrings[j].equals(randomStrings[j + 1]);
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/StringOps.java b/src/main/java/org/linaro/benchmarks/micro/StringOps.java
new file mode 100644
index 0000000..5851c36
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/StringOps.java
@@ -0,0 +1,425 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import java.lang.StringBuilder;
+import java.lang.System;
+import java.util.Random;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+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 char []chars_8 = new char[8];
+ private static char []chars_16 = new char[16];
+ private static char []chars_32 = new char[32];
+ private static char []chars_128 = new char[128];
+ private static char []chars_512 = new char[512];
+
+ 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
+ */
+
+ @Benchmark
+ public void jmhTimeStringEqualsSmall() {
+ stringEqualsResults[RANDOM_STRING_8]
+ ^= stringData[RANDOM_STRING_8].equals(stringDataAlt[RANDOM_STRING_8]);
+ stringEqualsResults[RANDOM_STRING_16]
+ ^= stringData[RANDOM_STRING_16].equals(stringDataAlt[RANDOM_STRING_16]);
+ stringEqualsResults[RANDOM_STRING_32]
+ ^= stringData[RANDOM_STRING_32].equals(stringDataAlt[RANDOM_STRING_32]);
+ }
+
+ @Benchmark
+ public void jmhTimeStringEqualsLarge() {
+ stringEqualsResults[RANDOM_STRING_128]
+ ^= stringData[RANDOM_STRING_128].equals(stringDataAlt[RANDOM_STRING_128]);
+ stringEqualsResults[RANDOM_STRING_512]
+ ^= stringData[RANDOM_STRING_512].equals(stringDataAlt[RANDOM_STRING_512]);
+ }
+
+ /**
+ * String.equalsIgnoreCase
+ */
+
+ @Benchmark
+ public void jmhTimeStringEqualsIgnoreCaseSmall() {
+ stringEqualsIgnoreCaseResults[RANDOM_STRING_8]
+ ^= stringData[RANDOM_STRING_8].equalsIgnoreCase(
+ stringDataAlt[RANDOM_STRING_8]);
+ stringEqualsIgnoreCaseResults[RANDOM_STRING_16]
+ ^= stringData[RANDOM_STRING_16].equalsIgnoreCase(
+ stringDataAlt[RANDOM_STRING_16]);
+ stringEqualsIgnoreCaseResults[RANDOM_STRING_32]
+ ^= stringData[RANDOM_STRING_32].equalsIgnoreCase(
+ stringDataAlt[RANDOM_STRING_32]);
+ }
+
+ @Benchmark
+ public void jmhTimeStringEqualsIgnoreCaseLarge() {
+ stringEqualsIgnoreCaseResults[RANDOM_STRING_128]
+ ^= stringData[RANDOM_STRING_128].equalsIgnoreCase(
+ stringDataAlt[RANDOM_STRING_128]);
+ stringEqualsIgnoreCaseResults[RANDOM_STRING_512]
+ ^= stringData[RANDOM_STRING_512].equalsIgnoreCase(
+ stringDataAlt[RANDOM_STRING_512]);
+ }
+
+ /**
+ * String.contentEquals
+ */
+
+ @Benchmark
+ public void jmhTimeStringContentEqualsSmall() {
+ stringContentEqualsResults[RANDOM_STRING_8]
+ ^= stringData[RANDOM_STRING_8].contentEquals(
+ stringDataAlt[RANDOM_STRING_8]);
+ stringContentEqualsResults[RANDOM_STRING_16]
+ ^= stringData[RANDOM_STRING_16].contentEquals(
+ stringDataAlt[RANDOM_STRING_16]);
+ stringContentEqualsResults[RANDOM_STRING_32]
+ ^= stringData[RANDOM_STRING_32].contentEquals(
+ stringDataAlt[RANDOM_STRING_32]);
+ }
+
+ @Benchmark
+ public void jmhTimeStringContentEqualsLarge() {
+ stringContentEqualsResults[RANDOM_STRING_128]
+ ^= stringData[RANDOM_STRING_128].contentEquals(
+ stringDataAlt[RANDOM_STRING_128]);
+ stringContentEqualsResults[RANDOM_STRING_512]
+ ^= stringData[RANDOM_STRING_512].contentEquals(
+ stringDataAlt[RANDOM_STRING_512]);
+ }
+
+ /**
+ * String.compareTo
+ */
+
+ @Benchmark
+ public void jmhTimeStringCompareToSmall() {
+ stringCompareToResults[RANDOM_STRING_8]
+ += stringData[RANDOM_STRING_8].compareTo(stringDataAlt[RANDOM_STRING_8]);
+ stringCompareToResults[RANDOM_STRING_16]
+ += stringData[RANDOM_STRING_16].compareTo(stringDataAlt[RANDOM_STRING_16]);
+ stringCompareToResults[RANDOM_STRING_32]
+ += stringData[RANDOM_STRING_32].compareTo(stringDataAlt[RANDOM_STRING_32]);
+ }
+
+ @Benchmark
+ public void jmhTimeStringCompareToLarge() {
+ stringCompareToResults[RANDOM_STRING_128]
+ += stringData[RANDOM_STRING_128].compareTo(stringDataAlt[RANDOM_STRING_128]);
+ stringCompareToResults[RANDOM_STRING_512]
+ += stringData[RANDOM_STRING_512].compareTo(stringDataAlt[RANDOM_STRING_512]);
+ }
+
+ /**
+ * String.compareToIgnoreCase
+ */
+
+ @Benchmark
+ public void jmhTimeStringCompareToIgnoreCaseSmall() {
+ stringCompareToIgnoreCaseResults[RANDOM_STRING_8]
+ += stringData[RANDOM_STRING_8].compareToIgnoreCase(
+ stringDataAlt[RANDOM_STRING_8]);
+ stringCompareToIgnoreCaseResults[RANDOM_STRING_16]
+ += stringData[RANDOM_STRING_16].compareToIgnoreCase(
+ stringDataAlt[RANDOM_STRING_16]);
+ stringCompareToIgnoreCaseResults[RANDOM_STRING_32]
+ += stringData[RANDOM_STRING_32].compareToIgnoreCase(
+ stringDataAlt[RANDOM_STRING_32]);
+ }
+
+ @Benchmark
+ public void jmhTimeStringCompareToIgnoreCaseLarge() {
+ stringCompareToIgnoreCaseResults[RANDOM_STRING_128]
+ += stringData[RANDOM_STRING_128].compareToIgnoreCase(
+ stringDataAlt[RANDOM_STRING_128]);
+ stringCompareToIgnoreCaseResults[RANDOM_STRING_512]
+ += stringData[RANDOM_STRING_512].compareToIgnoreCase(
+ stringDataAlt[RANDOM_STRING_512]);
+ }
+
+ /**
+ * String.regionMatches
+ */
+
+ @Benchmark
+ public void jmhTimeStringRegionMatchesSmall() {
+ stringRegionMatchesResults[RANDOM_STRING_8]
+ ^= stringData[RANDOM_STRING_8].regionMatches(
+ 0, stringDataAlt[RANDOM_STRING_8], 0, 8);
+ stringRegionMatchesResults[RANDOM_STRING_16]
+ ^= stringData[RANDOM_STRING_16].regionMatches(
+ 0, stringDataAlt[RANDOM_STRING_16], 0, 16);
+ stringRegionMatchesResults[RANDOM_STRING_32]
+ ^= stringData[RANDOM_STRING_32].regionMatches(
+ 0, stringDataAlt[RANDOM_STRING_32], 0, 32);
+ }
+
+ @Benchmark
+ public void jmhTimeStringRegionMatchesLarge() {
+ stringRegionMatchesResults[RANDOM_STRING_128]
+ ^= stringData[RANDOM_STRING_128].regionMatches(
+ 0, stringDataAlt[RANDOM_STRING_128], 0, 128);
+ stringRegionMatchesResults[RANDOM_STRING_512]
+ ^= stringData[RANDOM_STRING_512].regionMatches(
+ 0, stringDataAlt[RANDOM_STRING_512], 0, 512);
+ }
+
+ /**
+ * String.regionMatches
+ */
+
+ @Benchmark
+ public void jmhTimeStringRegionMatchesIgnoreCaseSmall() {
+ stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_8]
+ ^= stringData[RANDOM_STRING_8].regionMatches(
+ true, 0, stringDataAlt[RANDOM_STRING_8], 0, 8);
+ stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_16]
+ ^= stringData[RANDOM_STRING_16].regionMatches(
+ true, 0, stringDataAlt[RANDOM_STRING_16], 0, 16);
+ stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_32]
+ ^= stringData[RANDOM_STRING_32].regionMatches(
+ true, 0, stringDataAlt[RANDOM_STRING_32], 0, 32);
+ }
+
+ @Benchmark
+ public void jmhTimeStringRegionMatchesIgnoreCaseLarge() {
+ stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_128]
+ ^= stringData[RANDOM_STRING_128].regionMatches(
+ true, 0, stringDataAlt[RANDOM_STRING_128], 0, 128);
+ stringRegionMatchesIgnoreCaseResults[RANDOM_STRING_512]
+ ^= stringData[RANDOM_STRING_512].regionMatches(
+ true, 0, stringDataAlt[RANDOM_STRING_512], 0, 512);
+ }
+
+ /**
+ * String.charAt
+ */
+
+ @Benchmark
+ public void jmhTimeStringCharAt() {
+ for (int j = 0; j < 512; j++) {
+ stringCharAtResult = stringData[RANDOM_STRING_512].charAt(j);
+ }
+ }
+
+ /**
+ * String.indexOf
+ */
+
+ @Benchmark
+ public void jmhTimeStringIndexOfSmall() {
+ stringIndexOfResult += stringData[RANDOM_STRING_8].indexOf(searchChar);
+ stringIndexOfResult += stringData[RANDOM_STRING_16].indexOf(searchChar);
+ stringIndexOfResult += stringData[RANDOM_STRING_32].indexOf(searchChar);
+ }
+
+ @Benchmark
+ public void jmhTimeStringIndexOfLarge() {
+ stringIndexOfResult += stringData[RANDOM_STRING_128].indexOf(searchChar);
+ stringIndexOfResult += stringData[RANDOM_STRING_512].indexOf(searchChar);
+ }
+
+ /**
+ * String.indexOfAfter
+ */
+
+ @Benchmark
+ public void jmhTimeStringIndexOfAfterSmall() {
+ stringIndexOfAfterResult += stringData[RANDOM_STRING_8].indexOf(searchChar, 1);
+ stringIndexOfAfterResult += stringData[RANDOM_STRING_16].indexOf(searchChar, 1);
+ stringIndexOfAfterResult += stringData[RANDOM_STRING_32].indexOf(searchChar, 1);
+ }
+
+ @Benchmark
+ public void jmhTimeStringIndexOfAfterLarge() {
+ stringIndexOfAfterResult += stringData[RANDOM_STRING_128].indexOf(searchChar, 1);
+ stringIndexOfAfterResult += stringData[RANDOM_STRING_512].indexOf(searchChar, 1);
+ }
+
+ /**
+ * NewStringFromBytes
+ */
+
+ @Benchmark
+ public void jmhTimeStringNewStringFromBytesSmall() {
+ byte[] bytes = stringData[RANDOM_STRING_8].getBytes();
+ stringNewStringFromBytesResult[RANDOM_STRING_8] = new String(bytes);
+ byte[] bytes2 = stringData[RANDOM_STRING_16].getBytes();
+ stringNewStringFromBytesResult[RANDOM_STRING_16] = new String(bytes2);
+ byte[] bytes3 = stringData[RANDOM_STRING_32].getBytes();
+ stringNewStringFromBytesResult[RANDOM_STRING_32] = new String(bytes3);
+ }
+
+ @Benchmark
+ public void jmhTimeStringNewStringFromBytesLarge() {
+ byte[] bytes = stringData[RANDOM_STRING_128].getBytes();
+ stringNewStringFromBytesResult[RANDOM_STRING_128] = new String(bytes);
+ byte[] bytes2 = stringData[RANDOM_STRING_512].getBytes();
+ stringNewStringFromBytesResult[RANDOM_STRING_512] = new String(bytes2);
+ }
+
+ /**
+ * NewStringFromChars
+ */
+
+ @Benchmark
+ public void jmhTimeStringNewStringFromCharsSmall() {
+ char[] chars = new char[8];
+ stringData[RANDOM_STRING_8].getChars(0, 8, chars, 0);
+ stringNewStringFromCharsResult[RANDOM_STRING_8] = new String(chars);
+ char[] chars2 = new char[16];
+ stringData[RANDOM_STRING_16].getChars(0, 16, chars2, 0);
+ stringNewStringFromCharsResult[RANDOM_STRING_16] = new String(chars2);
+ char[] chars3 = new char[32];
+ stringData[RANDOM_STRING_32].getChars(0, 32, chars3, 0);
+ stringNewStringFromCharsResult[RANDOM_STRING_32] = new String(chars3);
+ }
+
+ @Benchmark
+ public void jmhTimeStringNewStringFromCharsLarge() {
+ char[] chars = new char[128];
+ stringData[RANDOM_STRING_128].getChars(0, 128, chars, 0);
+ stringNewStringFromCharsResult[RANDOM_STRING_128] = new String(chars);
+ char[] chars2 = new char[512];
+ stringData[RANDOM_STRING_512].getChars(0, 512, chars2, 0);
+ stringNewStringFromCharsResult[RANDOM_STRING_512] = new String(chars2);
+ }
+
+ /**
+ * NewStringFromString
+ */
+
+ @Benchmark
+ public void jmhTimeStringNewStringFromStringSmall() {
+ stringNewStringFromStringResult[RANDOM_STRING_8] =
+ new String(stringData[RANDOM_STRING_8]);
+ stringNewStringFromStringResult[RANDOM_STRING_16] =
+ new String(stringData[RANDOM_STRING_16]);
+ stringNewStringFromStringResult[RANDOM_STRING_32] =
+ new String(stringData[RANDOM_STRING_32]);
+ }
+
+ @Benchmark
+ public void jmhTimeStringNewStringFromStringLarge() {
+ stringNewStringFromStringResult[RANDOM_STRING_128] =
+ new String(stringData[RANDOM_STRING_128]);
+ stringNewStringFromStringResult[RANDOM_STRING_512] =
+ new String(stringData[RANDOM_STRING_512]);
+ }
+
+ /**
+ * String.getCharsNoCheck
+ */
+
+ @Benchmark
+ public void jmhTimeStringGetCharsNoCheckSmall() {
+ stringData[RANDOM_STRING_8].getChars(0, 8, chars_8, 0);
+ stringGetCharsNoCheckResult[RANDOM_STRING_8] = new String(chars_8);
+ stringData[RANDOM_STRING_16].getChars(0, 16, chars_16, 0);
+ stringGetCharsNoCheckResult[RANDOM_STRING_16] = new String(chars_16);
+ stringData[RANDOM_STRING_32].getChars(0, 32, chars_32, 0);
+ stringGetCharsNoCheckResult[RANDOM_STRING_32] = new String(chars_32);
+ }
+
+ @Benchmark
+ public void jmhTimeStringGetCharsNoCheckLarge() {
+ stringData[RANDOM_STRING_128].getChars(0, 128, chars_128, 0);
+ stringGetCharsNoCheckResult[RANDOM_STRING_128] = new String(chars_128);
+ stringData[RANDOM_STRING_512].getChars(0, 512, chars_512, 0);
+ stringGetCharsNoCheckResult[RANDOM_STRING_512] = new String(chars_512);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/SystemArrayCopy.java b/src/main/java/org/linaro/benchmarks/micro/SystemArrayCopy.java
new file mode 100644
index 0000000..230bd4b
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/SystemArrayCopy.java
@@ -0,0 +1,115 @@
+/*
+ * 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 org.linaro.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;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+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;
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeArrayCopyCharBufferedReadSmall() throws IOException {
+ bufferedReadLoop(cbuf, ARRAY_COPY_SMALL);
+ arrayCopyCharBufferedReadSmallResult = cbuf[MAX_BUFFER_BYTES - 1];
+ }
+
+ @Benchmark
+ public void jmhTimeArrayCopyCharBufferedReadMedium() throws IOException {
+ bufferedReadLoop(cbuf, ARRAY_COPY_MEDIUM);
+ arrayCopyCharBufferedReadMediumResult = cbuf[MAX_BUFFER_BYTES - 1];
+ }
+
+ @Benchmark
+ public void jmhTimeArrayCopyCharBufferedReadLarge() throws IOException {
+ bufferedReadLoop(cbuf, ARRAY_COPY_LARGE);
+ arrayCopyCharBufferedReadLargeResult = cbuf[MAX_BUFFER_BYTES - 1];
+ }
+
+ @Benchmark
+ public void jmhTimeArrayCopySmall() {
+ System.arraycopy(stringArray, 0, stringArraySmall, 0, ARRAY_COPY_SMALL);
+ }
+
+ @Benchmark
+ public void jmhTimeArrayCopyMedium() {
+ System.arraycopy(stringArray, 0, stringArrayMedium, 0, ARRAY_COPY_MEDIUM);
+ }
+
+ @Benchmark
+ public void jmhTimeArrayCopyLarge() {
+ System.arraycopy(stringArray, 0, stringArrayLarge, 0, ARRAY_COPY_LARGE);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/VectorCalc.java b/src/main/java/org/linaro/benchmarks/micro/VectorCalc.java
new file mode 100644
index 0000000..0c2ad2a
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/VectorCalc.java
@@ -0,0 +1,83 @@
+/*
+ * 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 org.linaro.benchmarks.micro;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+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];
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRun() {
+ 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);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/intrinsics/CRC32Bench.java b/src/main/java/org/linaro/benchmarks/micro/intrinsics/CRC32Bench.java
new file mode 100644
index 0000000..3d8d817
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/intrinsics/CRC32Bench.java
@@ -0,0 +1,70 @@
+/*
+ * 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 org.linaro.benchmarks.micro.intrinsics;
+
+import java.util.Random;
+import java.util.zip.CRC32;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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);
+ }
+
+ @Benchmark
+ public void jmhTimeUpdateInt() {
+ benchUpdateInt();
+ }
+
+ @Benchmark
+ public void jmhTimeUpdateBytes() {
+ 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*100; i++) {
+ crc32.update(bytes);
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java b/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java
new file mode 100644
index 0000000..f43d977
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java
@@ -0,0 +1,272 @@
+/*
+ * 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 org.linaro.benchmarks.micro.intrinsics;
+
+import java.lang.System;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.Random;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+public class Intrinsics {
+
+ /* Invoke each intrinsic in question the same no. of times */
+ private static final int NUM_INVOKES = 128;
+
+ /* 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];
+
+ @Benchmark
+ public void jmhTimeNumberOfLeadingZerosInteger() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsNumberOfLeadingZerosInteger[i] =
+ Integer.numberOfLeadingZeros(0x80000000 >>> i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeNumberOfLeadingZerosLong() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsNumberOfLeadingZerosLong[i] =
+ Long.numberOfLeadingZeros(0x8000000000000000L >>> i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeNumberOfLeadingZerosIntegerRandom() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsNumberOfLeadingZerosIntegerRandom[i] =
+ Integer.numberOfLeadingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeNumberOfLeadingZerosLongRandom() {
+ 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];
+
+ @Benchmark
+ public void jmhTimeNumberOfTrailingZerosInteger() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsNumberOfTrailingZerosInteger[i] =
+ Integer.numberOfTrailingZeros(0x80000000 >>> i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeNumberOfTrailingZerosLong() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsNumberOfTrailingZerosLong[i] =
+ Long.numberOfTrailingZeros(0x8000000000000000L >>> i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeNumberOfTrailingZerosIntegerRandom() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsNumberOfTrailingZerosIntegerRandom[i] =
+ Integer.numberOfTrailingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeNumberOfTrailingZerosLongRandom() {
+ 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];
+
+ @Benchmark
+ public void jmhTimeBitCountInteger() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsBitCountInteger[i] = Integer.bitCount(0x1234abcd);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeBitCountLong() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsBitCountLong[i] = Long.bitCount(0x1234abcd1234abcdL);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeBitCountIntegerRandom() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsBitCountIntegerRandom[i] = Integer.bitCount(rand[i % NUM_RANDS]);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeBitCountLongRandom() {
+ 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];
+
+ @Benchmark
+ public void jmhTimeRotateRightInteger() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsRotateRightInteger[i] = Integer.rotateRight(0xFF0000DD, i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRotateRightIntegerConstant() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsRotateRightIntegerConstant[i] = Integer.rotateRight(0xFF0000DD, 16);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRotateRightLong() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsRotateRightLong[i] = Long.rotateRight(0xBBAAAADDFF0000DDL, i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRotateRightLongConstant() {
+ 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];
+
+ @Benchmark
+ public void jmhTimeRotateLeftInteger() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsRotateLeftInteger[i] = Integer.rotateLeft(0xFF0000DD, i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRotateLeftIntegerConstant() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsRotateLeftIntegerConstant[i] = Integer.rotateLeft(0xFF0000DD, 16);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRotateLeftLong() {
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ resultsRotateLeftLong[i] = Long.rotateLeft(0xBBAAAADDFF0000DDL, i);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRotateLeftLongConstant() {
+ 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];
+
+ @Benchmark
+ public void jmhTimeRotateRandomInteger() {
+ 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]);
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRotateRandomLong() {
+ 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]);
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/micro/intrinsics/MathIntrinsics.java b/src/main/java/org/linaro/benchmarks/micro/intrinsics/MathIntrinsics.java
new file mode 100644
index 0000000..a1a86a6
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/intrinsics/MathIntrinsics.java
@@ -0,0 +1,367 @@
+/*
+ * 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 math-related intrinsics: rounding, min/max, etc.
+ * Main Focus: Math-related intrinsics.
+ */
+
+package org.linaro.benchmarks.micro.intrinsics;
+
+import java.lang.System;
+import java.util.Random;
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+
+public class MathIntrinsics {
+ // 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];
+
+ private static final int[] rand_int = new int[NUM_RANDS];
+ private static final long[] rand_long = new long[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_int[i] = rand.nextInt();
+ rand_long[i] = rand.nextLong();
+
+ 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];
+ }
+ }
+ }
+
+ @Benchmark
+ public void jmhTimeRoundPositiveFloat() {
+ int res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.round(rand_pos_float[i % NUM_RANDS]);
+ }
+ res_int = res;
+ }
+
+ @Benchmark
+ public void jmhTimeRoundNegativeFloat() {
+ int res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.round(rand_neg_float[i % NUM_RANDS]);
+ }
+ res_int = res;
+ }
+
+ @Benchmark
+ public void jmhTimeRoundFloat() {
+ int res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.round(rand_float[i % NUM_RANDS]);
+ }
+ res_int = res;
+ }
+
+ @Benchmark
+ public void jmhTimeRoundPositiveDouble() {
+ long res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.round(rand_pos_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeRoundNegativeDouble() {
+ long res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.round(rand_neg_double[i % NUM_RANDS]);
+ }
+ res_long = res;
+ }
+
+ @Benchmark
+ public void jmhTimeRoundDouble() {
+ long res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.round(rand_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeFloorPositiveFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.floor(rand_pos_float[i % NUM_RANDS]);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeFloorNegativeFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.floor(rand_neg_float[i % NUM_RANDS]);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeFloorFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.floor(rand_float[i % NUM_RANDS]);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeFloorPositiveDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.floor(rand_pos_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeFloorNegativeDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.floor(rand_neg_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeFloorDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.floor(rand_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeCeilPositiveFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.ceil(rand_pos_float[i % NUM_RANDS]);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeCeilNegativeFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.ceil(rand_neg_float[i % NUM_RANDS]);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeCeilFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.ceil(rand_float[i % NUM_RANDS]);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeCeilPositiveDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.ceil(rand_pos_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+
+ @Benchmark
+ public void jmhTimeCeilNegativeDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.ceil(rand_neg_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeCeilDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.ceil(rand_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeRint() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ res += Math.rint(rand_double[i % NUM_RANDS]);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMinDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ double a = rand_double[i % NUM_RANDS];
+ double b = rand_double[(i + 1) % NUM_RANDS];
+ res += Math.min(a, b);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMaxDouble() {
+ double res = 0.0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ double a = rand_double[i % NUM_RANDS];
+ double b = rand_double[(i + 1) % NUM_RANDS];
+ res += Math.max(a, b);
+ }
+ res_double = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMinFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ float a = rand_float[i % NUM_RANDS];
+ float b = rand_float[(i + 1) % NUM_RANDS];
+ res += Math.min(a, b);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMaxFloat() {
+ float res = 0.0f;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ float a = rand_float[i % NUM_RANDS];
+ float b = rand_float[(i + 1) % NUM_RANDS];
+ res += Math.max(a, b);
+ }
+ res_float = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMinLong() {
+ long res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ long a = rand_long[i % NUM_RANDS];
+ long b = rand_long[(i + 1) % NUM_RANDS];
+ res += Math.min(a, b);
+ }
+ res_long = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMaxLong() {
+ long res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ long a = rand_long[i % NUM_RANDS];
+ long b = rand_long[(i + 1) % NUM_RANDS];
+ res += Math.max(a, b);
+ }
+ res_long = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMinInt() {
+ int res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ int a = rand_int[i % NUM_RANDS];
+ int b = rand_int[(i + 1) % NUM_RANDS];
+ res += Math.min(a, b);
+ }
+ res_int = res;
+ }
+
+ @Benchmark
+ public void jmhTimeMaxInt() {
+ int res = 0;
+ for (int i = 0; i < NUM_INVOKES; ++i) {
+ int a = rand_int[i % NUM_RANDS];
+ int b = rand_int[(i + 1) % NUM_RANDS];
+ res += Math.max(a, b);
+ }
+ res_int = res;
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/misc/TestAddSubExtension.java b/src/main/java/org/linaro/benchmarks/misc/TestAddSubExtension.java
new file mode 100644
index 0000000..7f77b97
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/misc/TestAddSubExtension.java
@@ -0,0 +1,427 @@
+/*
+ * Copyright (C) 2017 Linaro Limited. All rights received.
+ *
+ * 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 org.linaro.benchmarks.misc;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public class TestAddSubExtension {
+ // hot region will move to jmh framework if 'loop' is less than 100000.
+ private static final int loop = 100000;
+
+ public long addConvertShift(long x0, long x1, long x2, long x3, long x4) {
+ long acc0 = 0;
+ long acc1 = 0;
+ long acc2 = 0;
+ long acc3 = 0;
+ long acc4 = 0;
+ int i0 = 1;
+ int i1 = 1;
+ int i2 = 2;
+ int i3 = 3;
+ int i4 = 4;
+
+ for (int i = 0; i < loop; i++) {
+ // Another typical usage is:
+ // x = unsafe.getAddress(mem) + (((long)i) << 3)
+ acc0 += x0 + ((long)i0 << 0);
+ acc1 += x1 + ((long)i1 << 1);
+ acc2 += x2 + ((long)i2 << 2);
+ acc3 += x3 + ((long)i3 << 3);
+ acc4 += x4 + ((long)i4 << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0 + acc1 + acc2 + acc3 + acc4;
+ }
+
+ public long subConvertShift(long x0) {
+ long acc0 = 1;
+ int i0 = 1;
+
+ // Adding more caculations (e.g. i1 << 1, i2 << 2 etc. same as
+ // addConvertShift function does.) will fail to match
+ // SubExtL_sxtw_imm pattern in AArch64.ad.
+ for (int i = 0; i < loop; i++) {
+ i0 += 2;
+ acc0 -= ((long)i0 << 2);
+ }
+ return acc0;
+ }
+
+ public int subAnd255Shift(int x0, int x1, int x2, int x3, int x4) {
+ int i0 = 0;
+ int i1 = 1;
+ int i2 = 2;
+ int i3 = 3;
+ int i4 = 4;
+
+ int acc0 = 0;
+ int acc1 = 0;
+ int acc2 = 0;
+ int acc3 = 0;
+ int acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ acc0 -= ((i0 & 255) << 0);
+ acc1 -= ((i1 & 255) << 1);
+ acc2 -= ((i2 & 255) << 2);
+ acc3 -= ((i3 & 255) << 3);
+ acc4 -= ((i4 & 255) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ public int subAnd65535Shift(int x0, int x1, int x2, int x3, int x4) {
+ int i0 = 0;
+ int i1 = 1;
+ int i2 = 2;
+ int i3 = 3;
+ int i4 = 4;
+
+ int acc0 = 0;
+ int acc1 = 0;
+ int acc2 = 0;
+ int acc3 = 0;
+ int acc4 = 0;
+
+ for (int i = 0; i < loop; i++) {
+ // TODO check why there is extra 'and' instruction generated in C2.
+ acc0 -= ((i0 & 65535) << 0);
+ acc1 -= ((i1 & 65535) << 1);
+ acc2 -= ((i2 & 65535) << 2);
+ acc3 -= ((i3 & 65535) << 3);
+ acc4 -= ((i4 & 65535) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0 + acc1 + acc2 + acc3 + acc4;
+ }
+
+ public long subAnd255Shift(long x0, long x1, long x2, long x3, long x4) {
+ long i0 = 0;
+ long i1 = 1;
+ long i2 = 2;
+ long i3 = 3;
+ long i4 = 4;
+
+ long acc0 = 0;
+ long acc1 = 0;
+ long acc2 = 0;
+ long acc3 = 0;
+ long acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ acc0 -= ((i0 & 255) << 0);
+ acc1 -= ((i1 & 255) << 1);
+ acc2 -= ((i2 & 255) << 2);
+ acc3 -= ((i3 & 255) << 3);
+ acc4 -= ((i4 & 255) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ public long subAnd65535Shift(long x0, long x1, long x2, long x3, long x4) {
+ long i0 = 0;
+ long i1 = 1;
+ long i2 = 2;
+ long i3 = 3;
+ long i4 = 4;
+
+ long acc0 = 0;
+ long acc1 = 0;
+ long acc2 = 0;
+ long acc3 = 0;
+ long acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ acc0 -= ((i0 & 65535) << 0);
+ acc1 -= ((i1 & 65535) << 1);
+ acc2 -= ((i2 & 65535) << 2);
+ acc3 -= ((i3 & 65535) << 3);
+ acc4 -= ((i4 & 65535) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ public long subAnd4294967295Shift(long x0, long x1, long x2, long x3, long x4) {
+ long i0 = 0;
+ long i1 = 1;
+ long i2 = 2;
+ long i3 = 3;
+ long i4 = 4;
+
+ long acc0 = 0;
+ long acc1 = 0;
+ long acc2 = 0;
+ long acc3 = 0;
+ long acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ // 2^32 - 1 = 4294967295
+ acc0 -= ((i0 & 4294967295L) << 0);
+ acc1 -= ((i1 & 4294967295L) << 1);
+ acc2 -= ((i2 & 4294967295L) << 2);
+ acc3 -= ((i3 & 4294967295L) << 3);
+ acc4 -= ((i4 & 4294967295L) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ public int addAnd255Shift(int x0, int x1, int x2, int x3, int x4) {
+ int i0 = 0;
+ int i1 = 1;
+ int i2 = 2;
+ int i3 = 3;
+ int i4 = 4;
+
+ int acc0 = 0;
+ int acc1 = 0;
+ int acc2 = 0;
+ int acc3 = 0;
+ int acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ acc0 += ((i0 & 255) << 0);
+ acc1 += ((i1 & 255) << 1);
+ acc2 += ((i2 & 255) << 2);
+ acc3 += ((i3 & 255) << 3);
+ acc4 += ((i4 & 255) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ public int addAnd65535Shift(int x0, int x1, int x2, int x3, int x4) {
+ int i0 = 0;
+ int i1 = 1;
+ int i2 = 2;
+ int i3 = 3;
+ int i4 = 4;
+
+ int acc0 = 0;
+ int acc1 = 0;
+ int acc2 = 0;
+ int acc3 = 0;
+ int acc4 = 0;
+
+ for (int i = 0; i < loop; i++) {
+ acc0 += ((i0 & 65535) << 0);
+ acc1 += ((i1 & 65535) << 1);
+ acc2 += ((i2 & 65535) << 2);
+ acc3 += ((i3 & 65535) << 3);
+ acc4 += ((i4 & 65535) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0 + acc1 + acc2 + acc3 + acc4;
+ }
+
+ public long addAnd255Shift(long x0, long x1, long x2, long x3, long x4) {
+ long i0 = 0;
+ long i1 = 1;
+ long i2 = 2;
+ long i3 = 3;
+ long i4 = 4;
+
+ long acc0 = 0;
+ long acc1 = 0;
+ long acc2 = 0;
+ long acc3 = 0;
+ long acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ acc0 += ((i0 & 255) << 0);
+ acc1 += ((i1 & 255) << 1);
+ acc2 += ((i2 & 255) << 2);
+ acc3 += ((i3 & 255) << 3);
+ acc4 += ((i4 & 255) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ public long addAnd65535Shift(long x0, long x1, long x2, long x3, long x4) {
+ long i0 = 0;
+ long i1 = 1;
+ long i2 = 2;
+ long i3 = 3;
+ long i4 = 4;
+
+ long acc0 = 0;
+ long acc1 = 0;
+ long acc2 = 0;
+ long acc3 = 0;
+ long acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ acc0 += ((i0 & 65535) << 0);
+ acc1 += ((i1 & 65535) << 1);
+ acc2 += ((i2 & 65535) << 2);
+ acc3 += ((i3 & 65535) << 3);
+ acc4 += ((i4 & 65535) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ public long addAnd4294967295Shift(long x0, long x1, long x2, long x3, long x4) {
+ long i0 = 0;
+ long i1 = 1;
+ long i2 = 2;
+ long i3 = 3;
+ long i4 = 4;
+
+ long acc0 = 0;
+ long acc1 = 0;
+ long acc2 = 0;
+ long acc3 = 0;
+ long acc4 = 0;
+
+ for (long i = 0; i < loop; i++) {
+ // 2^32 - 1 = 4294967295
+ acc0 += ((i0 & 4294967295L) << 0);
+ acc1 += ((i1 & 4294967295L) << 1);
+ acc2 += ((i2 & 4294967295L) << 2);
+ acc3 += ((i3 & 4294967295L) << 3);
+ acc4 += ((i4 & 4294967295L) << 4);
+
+ i0 += 3;
+ i1 += 4;
+ i2 += 5;
+ i3 += 6;
+ i4 += 7;
+ }
+ return acc0;
+ }
+
+ @Benchmark
+ public long testSubAnd255ShiftInt() {
+ return subAnd255Shift(10, 10, 10, 10, 10);
+ }
+
+ @Benchmark
+ public long testSubAnd65535ShiftInt() {
+ return subAnd65535Shift(10, 10, 10, 10, 10);
+ }
+
+ @Benchmark
+ public long testSubAnd255ShiftLong() {
+ return subAnd255Shift(10L, 10L, 10L, 10L, 10L);
+ }
+
+ @Benchmark
+ public long testSubAnd65535ShiftLong() {
+ return subAnd65535Shift(10L, 10L, 10L, 10L, 10L);
+ }
+
+ @Benchmark
+ public long testSubAnd4294967295Shift() {
+ return subAnd4294967295Shift(10, 10, 10, 10, 10);
+ }
+
+ @Benchmark
+ public int testAddAnd255ShiftInt() {
+ return addAnd255Shift(10, 10, 10, 10, 10);
+ }
+
+ @Benchmark
+ public int testAddAnd65535ShiftInt() {
+ return addAnd65535Shift(10, 10, 10, 10, 10);
+ }
+
+ @Benchmark
+ public long testAddAnd255ShiftLong() {
+ return addAnd255Shift(10L, 10L, 10L, 10L, 10L);
+ }
+
+ @Benchmark
+ public long testAddAnd65535ShiftLong() {
+ return addAnd65535Shift(10L, 10L, 10L, 10L, 10L);
+ }
+
+ @Benchmark
+ public long testAddAnd4294967295Shift() {
+ return addAnd4294967295Shift(10, 10, 10, 10, 10);
+ }
+
+ @Benchmark
+ public long testAddConvertShift() {
+ return addConvertShift(10, 10, 10, 10, 10);
+ }
+
+ @Benchmark
+ public long testSubConvertShift() {
+ return subConvertShift(10);
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Bubblesort.java b/src/main/java/org/linaro/benchmarks/stanford/Bubblesort.java
new file mode 100644
index 0000000..e53d9b9
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Bubblesort.java
@@ -0,0 +1,81 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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 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: .*
+ @Benchmark
+ public void jmhTimeBubble() {
+ Bubble();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/IntMM.java b/src/main/java/org/linaro/benchmarks/stanford/IntMM.java
new file mode 100644
index 0000000..52ab141
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/IntMM.java
@@ -0,0 +1,75 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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: .*
+
+ @Benchmark
+ public void jmhTimeIntmm() {
+ for (int j = 0; j < INTMM_ITERS; j++) {
+ Intmm(j);
+ }
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Oscar.java b/src/main/java/org/linaro/benchmarks/stanford/Oscar.java
new file mode 100644
index 0000000..5388366
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Oscar.java
@@ -0,0 +1,168 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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: .*
+
+ @Benchmark
+ public void jmhTimeOscar() {
+ Oscar();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Perm.java b/src/main/java/org/linaro/benchmarks/stanford/Perm.java
new file mode 100644
index 0000000..1f04a58
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Perm.java
@@ -0,0 +1,68 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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: .*
+
+ @Benchmark
+ public void jmhTimePerm() {
+ Perm();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Puzzle.java b/src/main/java/org/linaro/benchmarks/stanford/Puzzle.java
new file mode 100644
index 0000000..c9a142c
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Puzzle.java
@@ -0,0 +1,128 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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;
+
+ private 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: .*
+
+ @Benchmark
+ public void jmhTimePuzzle() {
+ Puzzle();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Queens.java b/src/main/java/org/linaro/benchmarks/stanford/Queens.java
new file mode 100644
index 0000000..2da9f04
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Queens.java
@@ -0,0 +1,80 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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 i;
+ for ( i = 1; i <= 50; i++ ) Doit();
+}
+ // CHECKSTYLE.ON: .*
+
+ @Benchmark
+ public void jmhTimeQueens() {
+ Queens();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Quicksort.java b/src/main/java/org/linaro/benchmarks/stanford/Quicksort.java
new file mode 100644
index 0000000..2232926
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Quicksort.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 org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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 () {
+ Quicksort(sortlist,1,sortelements);
+ if ( (sortlist[1] != littlest) || (sortlist[sortelements] != biggest) ) error = true;
+}
+ // CHECKSTYLE.ON: .*
+
+ @Setup
+ public void setup() {
+ Initarr();
+ }
+
+ @Benchmark
+ public void jmhTimeQuicksort() {
+ Quick();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/RealMM.java b/src/main/java/org/linaro/benchmarks/stanford/RealMM.java
new file mode 100644
index 0000000..0f8e4fa
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/RealMM.java
@@ -0,0 +1,68 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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 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: .*
+
+ @Benchmark
+ public void jmhTimeRealMM() {
+ Mm();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Towers.java b/src/main/java/org/linaro/benchmarks/stanford/Towers.java
new file mode 100644
index 0000000..0e57ea5
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Towers.java
@@ -0,0 +1,128 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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: .*
+
+ @Benchmark
+ public void jmhTimeTowers() {
+ Towers();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/stanford/Treesort.java b/src/main/java/org/linaro/benchmarks/stanford/Treesort.java
new file mode 100644
index 0000000..e044926
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/stanford/Treesort.java
@@ -0,0 +1,108 @@
+/* Copied from https://llvm.org/svn/llvm-project/test-suite/tags/RELEASE_14/SingleSource/Benchmarks
+ * License: LLVM Release License. See Notice file
+ */
+
+package org.linaro.benchmarks.stanford;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+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 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: .*
+
+ @Benchmark
+ public void jmhTimeTreesort() {
+ Trees();
+ }
+}
diff --git a/src/main/java/org/linaro/benchmarks/TestRGBToCmyk.java b/src/main/java/org/linaro/benchmarks/vector/TestRGBToCmyk.java
index 71a93cd..e56a356 100644
--- a/src/main/java/org/linaro/benchmarks/TestRGBToCmyk.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestRGBToCmyk.java
@@ -15,7 +15,7 @@
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -26,7 +26,8 @@ import java.util.concurrent.TimeUnit;
public class TestRGBToCmyk
{
- static final int LENGTH = 256 * 1024;
+ static final int LENGTH = 1024;
+ static final int COUNT = 128;
static byte input[] = new byte[LENGTH*3];
static byte output[] = new byte[LENGTH*4];
@@ -64,7 +65,9 @@ public class TestRGBToCmyk
@Benchmark
public void testRGBToCmyk() {
- RGBToCmyk(input, output, LENGTH);
+ for (int i = 0; i < COUNT; i++) {
+ RGBToCmyk(input, output, LENGTH);
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestReduceAdd.java b/src/main/java/org/linaro/benchmarks/vector/TestReduceAdd.java
index 51e7181..679fac4 100644
--- a/src/main/java/org/linaro/benchmarks/TestReduceAdd.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestReduceAdd.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,12 +24,13 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestReduceAdd {
- static final int LENGTH = 256 * 1024;
+ static final int LENGTH = 1024;
+ static final int COUNT = 2000;
static int [] a = new int[LENGTH];
static int [] b = new int[LENGTH];
static short [] sa = new short[LENGTH];
static short [] sb = new short[LENGTH];
-
+ static int result = 0;
public static void TestReduceAddInit() {
for (int i = 0; i < LENGTH; i++) {
a[i] = 2;
@@ -103,18 +104,24 @@ public class TestReduceAdd {
@Benchmark
public void testReduceAddInt() {
- int sum;
- sum = reduceAddInt(a, b);
- sum = reduceAddSumofSubInt(a, b);
- sum = reduceAddSumofMulInt(a, b);
+ int sum = 0;
+ for (int i = 0; i < COUNT; i++) {
+ sum += reduceAddInt(a, b);
+ sum += reduceAddSumofSubInt(a, b);
+ sum += reduceAddSumofMulInt(a, b);
+ }
+ result += sum;
}
@Benchmark
public void testReduceAddShort() {
- int sum;
- sum = reduceAddShort(sa, sb);
- sum = reduceAddSumofSubShort(sa, sb);
- sum = reduceAddSumofMulShort(sa, sb);
+ int sum = 0;
+ for (int i = 0; i < COUNT; i++) {
+ sum += reduceAddShort(sa, sb);
+ sum += reduceAddSumofSubShort(sa, sb);
+ sum += reduceAddSumofMulShort(sa, sb);
+ }
+ result += sum;
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDAdd.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDAdd.java
index 264458f..a7c69b4 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDAdd.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDAdd.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDAdd {
- static final int LENGTH = 1024 * 256;
+ static final int LENGTH = 1024;
+ static final int COUNT = 128;
static int [] a = new int[LENGTH];
static int [] b = new int[LENGTH];
static int [] c = new int[LENGTH];
@@ -34,6 +35,15 @@ public class TestSIMDAdd {
static byte [] ba = new byte[LENGTH];
static byte [] bb = new byte[LENGTH];
static byte [] bc = new byte[LENGTH];
+ static long [] la = new long[LENGTH];
+ static long [] lb = new long[LENGTH];
+ static long [] lc = new long[LENGTH];
+ static float [] fa = new float[LENGTH];
+ static float [] fb = new float[LENGTH];
+ static float [] fc = new float[LENGTH];
+ static double [] da = new double[LENGTH];
+ static double [] db = new double[LENGTH];
+ static double [] dc = new double[LENGTH];
public static void TestSIMDAddInit() {
for (int i = 0; i < LENGTH; i++) {
@@ -46,6 +56,15 @@ public class TestSIMDAdd {
ba[i] = (byte)(i + 3);
bb[i] = (byte)(i + 2);
bc[i] = (byte)(i + 1);
+ la[i] = (long)(i + 3);
+ lb[i] = (long)(i + 2);
+ lc[i] = (long)(i + 1);
+ fa[i] = (float)(i + 3);
+ fb[i] = (float)(i + 2);
+ fc[i] = (float)(i + 1);
+ da[i] = (double)(i + 3);
+ db[i] = (double)(i + 2);
+ dc[i] = (double)(i + 1);
}
}
@@ -67,6 +86,24 @@ public class TestSIMDAdd {
}
}
+ public static void vectAddLong() {
+ for (int i = 0; i < LENGTH; i++) {
+ lc[i] = la[i] + lb[i];
+ }
+ }
+
+ public static void vectAddFloat() {
+ for (int i = 0; i < LENGTH; i++) {
+ fc[i] = fa[i] + fb[i];
+ }
+ }
+
+ public static void vectAddDouble() {
+ for (int i = 0; i < LENGTH; i++) {
+ dc[i] = da[i] + db[i];
+ }
+ }
+
@Setup
public void setup()
{
@@ -75,17 +112,44 @@ public class TestSIMDAdd {
@Benchmark
public void testVectAddByte() {
- vectAddByte();
+ for (int i = 0; i < COUNT; i++) {
+ vectAddByte();
+ }
}
@Benchmark
public void testVectAddShort() {
- vectAddShort();
+ for (int i = 0; i < COUNT; i++) {
+ vectAddShort();
+ }
}
@Benchmark
public void testVectAddInt() {
- vectAddInt();
+ for (int i = 0; i < COUNT; i++) {
+ vectAddInt();
+ }
+ }
+
+ @Benchmark
+ public void testVectAddLong() {
+ for (int i = 0; i < COUNT; i++) {
+ vectAddLong();
+ }
+ }
+
+ @Benchmark
+ public void testVectAddFloat() {
+ for (int i = 0; i < COUNT; i++) {
+ vectAddFloat();
+ }
+ }
+
+ @Benchmark
+ public void testVectAddDouble() {
+ for (int i = 0; i < COUNT; i++) {
+ vectAddDouble();
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDCopy.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDCopy.java
index 9e9aeee..8619ff4 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDCopy.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDCopy.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,13 +24,20 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDCopy {
- static final int LENGTH = 1024 * 256;
+ static final int LENGTH = 1024;
+ static final int COUNT = 128;
static int [] a = new int[LENGTH];
static int [] c = new int[LENGTH];
static short [] sa = new short[LENGTH];
static short [] sc = new short[LENGTH];
static byte [] ba = new byte[LENGTH];
static byte [] bc = new byte[LENGTH];
+ static long [] la = new long[LENGTH];
+ static long [] lc = new long[LENGTH];
+ static float [] fa = new float[LENGTH];
+ static float [] fc = new float[LENGTH];
+ static double [] da = new double[LENGTH];
+ static double [] dc = new double[LENGTH];
public static void TestSIMDCopyInit() {
for (int i = 0; i < LENGTH; i++) {
@@ -40,6 +47,12 @@ public class TestSIMDCopy {
sc[i] = (short)(i + 1);
ba[i] = (byte)(i + 3);
bc[i] = (byte)(i + 1);
+ la[i] = (long)(i + 3);
+ lc[i] = (long)(i + 1);
+ fa[i] = (float)(i + 3);
+ fc[i] = (float)(i + 1);
+ da[i] = (double)(i + 3);
+ dc[i] = (double)(i + 1);
}
}
@@ -61,6 +74,24 @@ public class TestSIMDCopy {
}
}
+ public static void vectCopyLong() {
+ for (int i = 0; i < LENGTH; i++) {
+ lc[i] = la[i];
+ }
+ }
+
+ public static void vectCopyFloat() {
+ for (int i = 0; i < LENGTH; i++) {
+ fc[i] = fa[i];
+ }
+ }
+
+ public static void vectCopyDouble() {
+ for (int i = 0; i < LENGTH; i++) {
+ dc[i] = da[i];
+ }
+ }
+
@Setup
public void setup()
{
@@ -69,17 +100,43 @@ public class TestSIMDCopy {
@Benchmark
public void testVectCopyByte() {
- vectCopyByte();
+ for (int i = 0; i < COUNT; i++) {
+ vectCopyByte();
+ }
}
@Benchmark
public void testVectCopyShort() {
- vectCopyShort();
+ for (int i = 0; i < COUNT; i++) {
+ vectCopyShort();
+ }
}
@Benchmark
public void testVectCopyInt() {
- vectCopyInt();
+ for (int i = 0; i < COUNT; i++) {
+ vectCopyInt();
+ }
}
+ @Benchmark
+ public void testVectCopyLong() {
+ for (int i = 0; i < COUNT; i++) {
+ vectCopyLong();
+ }
+ }
+
+ @Benchmark
+ public void testVectCopyFloat() {
+ for (int i = 0; i < COUNT; i++) {
+ vectCopyFloat();
+ }
+ }
+
+ @Benchmark
+ public void testVectCopyDouble() {
+ for (int i = 0; i < COUNT; i++) {
+ vectCopyDouble();
+ }
+ }
}
diff --git a/src/main/java/org/linaro/benchmarks/vector/TestSIMDFma.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDFma.java
new file mode 100644
index 0000000..336ea87
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDFma.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2017 Linaro Limited. All rights received.
+ *
+ * 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 org.linaro.benchmarks.vector;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public class TestSIMDFma {
+ static final int LENGTH = 1024;
+ static final int COUNT = 128;
+ static float [] fa = new float[LENGTH];
+ static float [] fb = new float[LENGTH];
+ static float [] fc = new float[LENGTH];
+ static double [] da = new double[LENGTH];
+ static double [] db = new double[LENGTH];
+ static double [] dc = new double[LENGTH];
+
+ public static void testSIMDFmaInit() {
+ for (int i = 0; i < LENGTH; i++) {
+ fa[i] = (float)(i + 3);
+ fb[i] = (float)(i + 2);
+ fc[i] = (float)(i + 1);
+ da[i] = (double)(i + 3);
+ db[i] = (double)(i + 2);
+ dc[i] = (double)(i + 1);
+ }
+ }
+
+ public static void vecFusedMulAddFloat(
+ float[] a,
+ float[] b,
+ float[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(a[i], b[i], c[i]);
+ }
+ }
+
+ public static void vecFusedMulSub1Float(
+ float[] a,
+ float[] b,
+ float[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(-a[i], b[i], c[i]);
+ }
+ }
+
+ public static void vecFusedMulSub2Float(
+ float[] a,
+ float[] b,
+ float[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(a[i], -b[i], c[i]);
+ }
+ }
+
+ public static void vecNegFusedMulSubFloat(
+ float[] a,
+ float[] b,
+ float[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(a[i], b[i], -c[i]);
+ }
+ }
+
+ public static void vecNegFusedMulAddFloat(
+ float[] a,
+ float[] b,
+ float[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = -(Math.fma(a[i], b[i], c[i]));
+ }
+ }
+
+ public static void vecFusedMulAddDouble(
+ double[] a,
+ double[] b,
+ double[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(a[i], b[i], c[i]);
+ }
+ }
+
+ public static void vecFusedMulSub1Double(
+ double[] a,
+ double[] b,
+ double[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(-a[i], b[i], c[i]);
+ }
+ }
+
+ public static void vecFusedMulSub2Double(
+ double[] a,
+ double[] b,
+ double[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(a[i], -b[i], c[i]);
+ }
+ }
+
+ public static void vecNegFusedMulSubDouble(
+ double[] a,
+ double[] b,
+ double[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = Math.fma(a[i], b[i], -c[i]);
+ }
+ }
+
+ public static void vecNegFusedMulAddDouble(
+ double[] a,
+ double[] b,
+ double[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ c[i] = -(Math.fma(a[i], b[i], c[i]));
+ }
+ }
+
+ @Setup
+ public void setup()
+ {
+ testSIMDFmaInit();
+ }
+
+ @Benchmark
+ public void testVecFusedMulAddFloat() {
+ for (int i = 0; i < COUNT; i++) {
+ vecFusedMulAddFloat(fa, fb, fc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecFusedMulSub1Float() {
+ for (int i = 0; i < COUNT; i++) {
+ vecFusedMulSub1Float(fa, fb, fc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecFusedMulSub2Float() {
+ for (int i = 0; i < COUNT; i++) {
+ vecFusedMulSub2Float(fa, fb, fc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecNegFusedMulAddFloat() {
+ for (int i = 0; i < COUNT; i++) {
+ vecNegFusedMulAddFloat(fa, fb, fc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecNegFusedMulSubFloat() {
+ for (int i = 0; i < COUNT; i++) {
+ vecNegFusedMulSubFloat(fa, fb, fc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecFusedMulAddDouble() {
+ for (int i = 0; i < COUNT; i++) {
+ vecFusedMulAddDouble(da, db, dc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecFusedMulSub1Double() {
+ for (int i = 0; i < COUNT; i++) {
+ vecFusedMulSub1Double(da, db, dc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecFusedMulSub2Double() {
+ for (int i = 0; i < COUNT; i++) {
+ vecFusedMulSub2Double(da, db, dc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecNegFusedMulAddDouble() {
+ for (int i = 0; i < COUNT; i++) {
+ vecNegFusedMulAddDouble(da, db, dc, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testVecNegFusedMulSubDouble() {
+ for (int i = 0; i < COUNT; i++) {
+ vecNegFusedMulSubDouble(da, db, dc, LENGTH);
+ }
+ }
+
+}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDLd2St2.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd2St2.java
index 59af5c6..7e99698 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDLd2St2.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd2St2.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDLd2St2 {
- static final int VECT_LENGTH = 256 * 1024;
+ static final int VECT_LENGTH = 1024;
+ static final int COUNT = 128;
static final int DIM = 2;
static final int LENGTH = VECT_LENGTH * DIM;
static int [] in = new int[LENGTH];
@@ -102,10 +103,12 @@ public class TestSIMDLd2St2 {
@Benchmark
public void testVect2D() {
- vect2DAddInt(out, in, c);
- vect2DMulInt(out, in, c);
- vect2DAddShort(sout, sin, sc);
- vect2DMulShort(sout, sin, sc);
+ for (int i = 0; i < COUNT; i++) {
+ vect2DAddInt(out, in, c);
+ vect2DMulInt(out, in, c);
+ vect2DAddShort(sout, sin, sc);
+ vect2DMulShort(sout, sin, sc);
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDLd3St3.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd3St3.java
index c6d41c0..b2b6265 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDLd3St3.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd3St3.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDLd3St3 {
- static final int VECT_LENGTH = 256 * 1024;
+ static final int VECT_LENGTH = 1024;
+ static final int COUNT = 128;
static final int DIM = 3;
static final int LENGTH = VECT_LENGTH * DIM;
static int [] in = new int[LENGTH];
@@ -110,10 +111,12 @@ public class TestSIMDLd3St3 {
@Benchmark
public void testVect3D() {
- vect3DAddInt(out, in, c);
- vect3DMulInt(out, in, c);
- vect3DAddShort(sout, sin, sc);
- vect3DMulShort(sout, sin, sc);
+ for (int i = 0; i < COUNT; i++) {
+ vect3DAddInt(out, in, c);
+ vect3DMulInt(out, in, c);
+ vect3DAddShort(sout, sin, sc);
+ vect3DMulShort(sout, sin, sc);
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDLd4St4.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd4St4.java
index 01b7667..e53075c 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDLd4St4.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDLd4St4.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDLd4St4 {
- static final int VECT_LENGTH = 256 * 1024;
+ static final int VECT_LENGTH = 1024;
+ static final int COUNT = 128;
static final int DIM = 4;
static final int LENGTH = VECT_LENGTH * DIM;
static int [] in = new int[LENGTH];
@@ -118,10 +119,12 @@ public class TestSIMDLd4St4 {
@Benchmark
public void testVect4D() {
- vect4DAddInt(out, in, c);
- vect4DMulInt(out, in, c);
- vect4DAddShort(sout, sin, sc);
- vect4DMulShort(sout, sin, sc);
+ for (int i = 0; i < COUNT; i++) {
+ vect4DAddInt(out, in, c);
+ vect4DMulInt(out, in, c);
+ vect4DAddShort(sout, sin, sc);
+ vect4DMulShort(sout, sin, sc);
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDMlaInt.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaInt.java
index 9532c93..08b1f22 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDMlaInt.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaInt.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDMlaInt {
- static final int LENGTH = 256 * 1024;
+ static final int LENGTH = 1024;
+ static final int COUNT = 128;
static int [] a = new int[LENGTH];
static int [] b = new int[LENGTH];
static int [] c = new int[LENGTH];
@@ -86,19 +87,25 @@ public class TestSIMDMlaInt {
@Benchmark
public void testVectSumOfMulAdd1() {
int sum = 0;
- sum = vectSumOfMulAdd1(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ sum += vectSumOfMulAdd1(a, b, c, d);
+ }
}
@Benchmark
public void testVectSumOfMulAdd2() {
int sum = 0;
- sum = vectSumOfMulAdd2(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ sum += vectSumOfMulAdd2(a, b, c, d);
+ }
}
@Benchmark
public void testVectSumOfMulAdd3() {
int sum = 0;
- sum = vectSumOfMulAdd3(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ sum += vectSumOfMulAdd3(a, b, c, d);
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDMlaShort.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaShort.java
index 836595f..68e27d5 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDMlaShort.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMlaShort.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDMlaShort {
- static final int LENGTH = 256 * 1024;
+ static final int LENGTH = 1024;
+ static final int COUNT = 128;
static short [] a = new short[LENGTH];
static short [] b = new short[LENGTH];
static short [] c = new short[LENGTH];
@@ -116,33 +117,45 @@ public class TestSIMDMlaShort {
@Benchmark
public void testVectSumOfMulAdd1() {
int sum = 0;
- sum = vectSumOfMulAdd1(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ sum += vectSumOfMulAdd1(a, b, c, d);
+ }
}
@Benchmark
public void testVectSumOfMulAdd2() {
int sum = 0;
- sum = vectSumOfMulAdd2(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ sum += vectSumOfMulAdd2(a, b, c, d);
+ }
}
@Benchmark
public void testVectSumOfMulAdd3() {
int sum = 0;
- sum = vectSumOfMulAdd3(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ sum += vectSumOfMulAdd3(a, b, c, d);
+ }
}
@Benchmark
public void testVectMulAdd1() {
- vectMulAdd1(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ vectMulAdd1(a, b, c, d);
+ }
}
@Benchmark
public void testVectMulAdd2() {
- vectMulAdd2(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ vectMulAdd2(a, b, c, d);
+ }
}
@Benchmark
public void testVectMulAdd3() {
- vectMulAdd3(a, b, c, d);
+ for (int i = 0; i < COUNT; i++) {
+ vectMulAdd3(a, b, c, d);
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/TestSIMDMul.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMul.java
index 37a16bc..3210e8d 100644
--- a/src/main/java/org/linaro/benchmarks/TestSIMDMul.java
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMul.java
@@ -14,7 +14,7 @@
* limitations under the License.
*
*/
-package org.linaro.benchmarks;
+package org.linaro.benchmarks.vector;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@@ -24,7 +24,8 @@ import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
public class TestSIMDMul {
- static final int LENGTH = 1024 * 256;
+ static final int LENGTH = 1024;
+ static final int COUNT = 128;
static int [] a = new int[LENGTH];
static int [] b = new int[LENGTH];
static int [] c = new int[LENGTH];
@@ -34,6 +35,15 @@ public class TestSIMDMul {
static byte [] ba = new byte[LENGTH];
static byte [] bb = new byte[LENGTH];
static byte [] bc = new byte[LENGTH];
+ static long [] la = new long[LENGTH];
+ static long [] lb = new long[LENGTH];
+ static long [] lc = new long[LENGTH];
+ static float [] fa = new float[LENGTH];
+ static float [] fb = new float[LENGTH];
+ static float [] fc = new float[LENGTH];
+ static double [] da = new double[LENGTH];
+ static double [] db = new double[LENGTH];
+ static double [] dc = new double[LENGTH];
public static void TestSIMDMulInit() {
for (int i = 0; i < LENGTH; i++) {
@@ -46,6 +56,15 @@ public class TestSIMDMul {
ba[i] = (byte)(i + 3);
bb[i] = (byte)(i + 2);
bc[i] = (byte)(i + 1);
+ la[i] = (long)(i + 3);
+ lb[i] = (long)(i + 2);
+ lc[i] = (long)(i + 1);
+ fa[i] = (float)(i + 3);
+ fb[i] = (float)(i + 2);
+ fc[i] = (float)(i + 1);
+ da[i] = (double)(i + 3);
+ db[i] = (double)(i + 2);
+ dc[i] = (double)(i + 1);
}
}
@@ -67,6 +86,24 @@ public class TestSIMDMul {
}
}
+ public static void vectMulLong() {
+ for (int i = 0; i < LENGTH; i++) {
+ lc[i] = la[i] * lb[i];
+ }
+ }
+
+ public static void vectMulFloat() {
+ for (int i = 0; i < LENGTH; i++) {
+ fc[i] = fa[i] * fb[i];
+ }
+ }
+
+ public static void vectMulDouble() {
+ for (int i = 0; i < LENGTH; i++) {
+ dc[i] = da[i] * db[i];
+ }
+ }
+
@Setup
public void setup()
{
@@ -75,17 +112,44 @@ public class TestSIMDMul {
@Benchmark
public void testVectMulByte() {
- vectMulByte();
+ for (int i = 0; i < COUNT; i++) {
+ vectMulByte();
+ }
}
@Benchmark
public void testVectMulShort() {
- vectMulShort();
+ for (int i = 0; i < COUNT; i++) {
+ vectMulShort();
+ }
}
@Benchmark
public void tesVectMulInt() {
- vectMulInt();
+ for (int i = 0; i < COUNT; i++) {
+ vectMulInt();
+ }
+ }
+
+ @Benchmark
+ public void testVectMulLong() {
+ for (int i = 0; i < COUNT; i++) {
+ vectMulLong();
+ }
+ }
+
+ @Benchmark
+ public void testVectMulFloat() {
+ for (int i = 0; i < COUNT; i++) {
+ vectMulFloat();
+ }
+ }
+
+ @Benchmark
+ public void testVectMulDouble() {
+ for (int i = 0; i < COUNT; i++) {
+ vectMulDouble();
+ }
}
}
diff --git a/src/main/java/org/linaro/benchmarks/vector/TestSIMDMulC.java b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMulC.java
new file mode 100644
index 0000000..1b75325
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/vector/TestSIMDMulC.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2017 Linaro Limited. All rights received.
+ *
+ * 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 org.linaro.benchmarks.vector;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+
+public class TestSIMDMulC {
+ static final int LENGTH = 1024;
+ static final int COUNT = 200;
+ static int [] a = new int[LENGTH];
+ static int [] b = new int[LENGTH];
+ static int [] c = new int[LENGTH];
+
+ public static void testSIMDMulCInit() {
+ for (int i = 0; i < LENGTH; i++) {
+ a[i] = i + 3;
+ b[i] = i + 2;
+ c[i] = i + 1;
+ }
+ }
+
+ public static void mulCInt1(
+ int[] a,
+ int[] b,
+ int[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ int t0 = a[i] * 5;
+ int t1 = b[i] * 10;
+ c[i] = t0 + t1;
+ }
+ }
+
+ public static void mulCInt2(
+ int[] a,
+ int[] b,
+ int[] c,
+ int loop) {
+ for (int i = 0; i < loop; i++) {
+ int t0 = a[i] * 9;
+ int t1 = b[i] * 17;
+ c[i] = t0 + t1;
+ }
+ }
+
+ @Setup
+ public void setup()
+ {
+ testSIMDMulCInit();
+ }
+
+ @Benchmark
+ public void testSIMDMulCInt1() {
+ for (int i = 0; i < COUNT; i++) {
+ mulCInt1(a, b, c, LENGTH);
+ }
+ }
+
+ @Benchmark
+ public void testSIMDMulCInt2() {
+ for (int i = 0; i < COUNT; i++) {
+ mulCInt2(a, b, c, LENGTH);
+ }
+ }
+
+}