Index: benchmark/creation/JavaThread.java
===================================================================
--- benchmark/creation/JavaThread.java	(revision ce55a81847ece86766c279874bcc6dccb9aff995)
+++ benchmark/creation/JavaThread.java	(revision eccb14d7241424d1aae22fb905858900c58eaa4e)
@@ -1,30 +1,30 @@
 public class JavaThread {
 	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
-	// Bijective   
+	// Bijective
 	// Cycle length for non-zero values is 4G-1.
 	// 0 is absorbing and should be avoided -- fixed point.
 	// The returned value is typically masked to produce a positive value.
-	static volatile int Ticket = 0 ; 
+	static volatile int Ticket = 0 ;
 
 	private static int nextRandom (int x) {
-		if (x == 0) { 
+		if (x == 0) {
 			// reseed the PRNG
-			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
-			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
-			// If the race is a concern switch to an AtomicInteger.  
-			// In addition accesses to the RW volatile global "Ticket"  variable are not 
-			// (readily) predictable at compile-time so the JIT will not be able to elide 
-			// nextRandom() invocations.  
-			x = ++Ticket ; 
-			if (x == 0) x = 1 ; 
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot.
+			// Note that we use a non-atomic racy increment -- the race is rare and benign.
+			// If the race is a concern switch to an AtomicInteger.
+			// In addition accesses to the RW volatile global "Ticket"  variable are not
+			// (readily) predictable at compile-time so the JIT will not be able to elide
+			// nextRandom() invocations.
+			x = ++Ticket ;
+			if (x == 0) x = 1 ;
 		}
 		x ^= x << 6;
 		x ^= x >>> 21;
 		x ^= x << 7;
-		return x ;   
+		return x ;
 	}
 	static int x = 2;
 
-	static private int times = Integer.parseInt("10000") ;
+	static private long times = Long.parseLong("10000") ;
 
 	public static class MyThread extends Thread {
@@ -33,5 +33,5 @@
 	}
 	public static void helper() throws InterruptedException {
-		for(int i = 1; i <= times; i += 1) {
+		for(long i = 1; i <= times; i += 1) {
 			MyThread m = new MyThread();
 			x = nextRandom( x );
@@ -48,7 +48,7 @@
 	public static void main(String[] args) throws InterruptedException {
 		if ( args.length > 2 ) System.exit( 1 );
-		if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+		if ( args.length == 2 ) { times = Long.parseLong(args[1]); }
 
-		for (int i = Integer.parseInt("5"); --i >= 0 ; ) { 
+		for (int i = Integer.parseInt("5"); --i >= 0 ; ) {
 			InnerMain();
 			Thread.sleep(2000);		// 2 seconds
Index: benchmark/ctxswitch/JavaThread.java
===================================================================
--- benchmark/ctxswitch/JavaThread.java	(revision ce55a81847ece86766c279874bcc6dccb9aff995)
+++ benchmark/ctxswitch/JavaThread.java	(revision eccb14d7241424d1aae22fb905858900c58eaa4e)
@@ -1,33 +1,33 @@
 public class JavaThread {
 	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
-	// Bijective   
+	// Bijective
 	// Cycle length for non-zero values is 4G-1.
 	// 0 is absorbing and should be avoided -- fixed point.
 	// The returned value is typically masked to produce a positive value.
-	static volatile int Ticket = 0 ; 
+	static volatile int Ticket = 0 ;
 
 	private static int nextRandom (int x) {
-		if (x == 0) { 
+		if (x == 0) {
 			// reseed the PRNG
-			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
-			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
-			// If the race is a concern switch to an AtomicInteger.  
-			// In addition accesses to the RW volatile global "Ticket"  variable are not 
-			// (readily) predictable at compile-time so the JIT will not be able to elide 
-			// nextRandom() invocations.  
-			x = ++Ticket ; 
-			if (x == 0) x = 1 ; 
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot.
+			// Note that we use a non-atomic racy increment -- the race is rare and benign.
+			// If the race is a concern switch to an AtomicInteger.
+			// In addition accesses to the RW volatile global "Ticket"  variable are not
+			// (readily) predictable at compile-time so the JIT will not be able to elide
+			// nextRandom() invocations.
+			x = ++Ticket ;
+			if (x == 0) x = 1 ;
 		}
 		x ^= x << 6;
 		x ^= x >>> 21;
 		x ^= x << 7;
-		return x ;   
+		return x ;
 	}
 	static int x = 2;
 
-	static private int times = Integer.parseInt("100000");
+	static private long times = Long.parseLong("100000");
 
 	public static void helper() {
-		for(int i = 1; i <= times; i += 1) {
+		for(long i = 1; i <= times; i += 1) {
 			Thread.yield();
 		}
@@ -41,5 +41,5 @@
 	public static void main(String[] args) throws InterruptedException {
 		if ( args.length > 2 ) System.exit( 1 );
-		if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+		if ( args.length == 2 ) { times = Long.parseLong(args[1]); }
 
 		for (int i = Integer.parseInt("5"); --i >= 0 ; ) {
Index: benchmark/mutex/JavaThread.java
===================================================================
--- benchmark/mutex/JavaThread.java	(revision ce55a81847ece86766c279874bcc6dccb9aff995)
+++ benchmark/mutex/JavaThread.java	(revision eccb14d7241424d1aae22fb905858900c58eaa4e)
@@ -1,30 +1,30 @@
 public class JavaThread {
 	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
-	// Bijective   
+	// Bijective
 	// Cycle length for non-zero values is 4G-1.
 	// 0 is absorbing and should be avoided -- fixed point.
 	// The returned value is typically masked to produce a positive value.
-	static volatile int Ticket = 0 ; 
+	static volatile int Ticket = 0 ;
 
 	private static int nextRandom (int x) {
-		if (x == 0) { 
+		if (x == 0) {
 			// reseed the PRNG
-			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
-			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
-			// If the race is a concern switch to an AtomicInteger.  
-			// In addition accesses to the RW volatile global "Ticket"  variable are not 
-			// (readily) predictable at compile-time so the JIT will not be able to elide 
-			// nextRandom() invocations.  
-			x = ++Ticket ; 
-			if (x == 0) x = 1 ; 
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot.
+			// Note that we use a non-atomic racy increment -- the race is rare and benign.
+			// If the race is a concern switch to an AtomicInteger.
+			// In addition accesses to the RW volatile global "Ticket"  variable are not
+			// (readily) predictable at compile-time so the JIT will not be able to elide
+			// nextRandom() invocations.
+			x = ++Ticket ;
+			if (x == 0) x = 1 ;
 		}
 		x ^= x << 6;
 		x ^= x >>> 21;
 		x ^= x << 7;
-		return x ;   
+		return x ;
 	}
 	static int x = 2;
 
-	static private int times = Integer.parseInt("100000000");
+	static private long times = Long.parseLong("100000000");
 
 	public synchronized void noop() {
@@ -34,6 +34,6 @@
 		JavaThread j = new JavaThread();
 		// Inhibit biased locking ...
-		x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;     
-		for(int i = 1; i <= times; i += 1) {
+		x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;
+		for(long i = 1; i <= times; i += 1) {
 			x = nextRandom(x);
 			j.noop();
@@ -48,7 +48,7 @@
 	public static void main(String[] args) throws InterruptedException {
 		if ( args.length > 2 ) System.exit( 1 );
-		if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+		if ( args.length == 2 ) { times = Long.parseLong(args[1]); }
 
-		for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+		for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
 			InnerMain();
 			Thread.sleep(2000);     // 2 seconds
Index: benchmark/mutexC/JavaThread.java
===================================================================
--- benchmark/mutexC/JavaThread.java	(revision ce55a81847ece86766c279874bcc6dccb9aff995)
+++ benchmark/mutexC/JavaThread.java	(revision eccb14d7241424d1aae22fb905858900c58eaa4e)
@@ -1,26 +1,26 @@
 class Noop {
 	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
-	// Bijective   
+	// Bijective
 	// Cycle length for non-zero values is 4G-1.
 	// 0 is absorbing and should be avoided -- fixed point.
 	// The returned value is typically masked to produce a positive value.
-	static volatile int Ticket = 0 ; 
+	static volatile int Ticket = 0 ;
 
 	public static int nextRandom( int x ) {
-		if (x == 0) { 
+		if (x == 0) {
 			// reseed the PRNG
-			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
-			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
-			// If the race is a concern switch to an AtomicInteger.  
-			// In addition accesses to the RW volatile global "Ticket"  variable are not 
-			// (readily) predictable at compile-time so the JIT will not be able to elide 
-			// nextRandom() invocations.  
-			x = ++Ticket ; 
-			if (x == 0) x = 1 ; 
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot.
+			// Note that we use a non-atomic racy increment -- the race is rare and benign.
+			// If the race is a concern switch to an AtomicInteger.
+			// In addition accesses to the RW volatile global "Ticket"  variable are not
+			// (readily) predictable at compile-time so the JIT will not be able to elide
+			// nextRandom() invocations.
+			x = ++Ticket ;
+			if (x == 0) x = 1 ;
 		}
 		x ^= x << 6;
 		x ^= x >>> 21;
 		x ^= x << 7;
-		return x ;   
+		return x ;
 	}
 }
@@ -47,5 +47,5 @@
 	static int x = 2;
 
-	static private int times = Integer.parseInt("10000000");
+	static private long times = Long.parseLong("10000000");
 
 	public static void call( Monitor m ) throws InterruptedException {
@@ -53,5 +53,5 @@
 		m.go = true;
 		//while ( ! m.go2 );
-		for ( int i = 0; i < times; i += 1 ) {
+		for ( long i = 0; i < times; i += 1 ) {
 			m.call();
 			x = Noop.nextRandom( x );
@@ -71,10 +71,7 @@
 	public static void main( String[] args ) throws InterruptedException {
 		if ( args.length > 2 ) System.exit( 1 );
-		if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+		if ( args.length == 2 ) { times = Long.parseLong(args[1]); }
 
-		if ( args.length > 2 ) System.exit( 1 );
-		if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
-
-		for ( int i = Integer.parseInt("5"); --i >= 0 ; ) { 
+		for ( int i = Integer.parseInt("5"); --i >= 0 ; ) {
 			InnerMain();
 			// Thread.sleep(2000);	// 2 seconds
Index: benchmark/schedint/JavaThread.java
===================================================================
--- benchmark/schedint/JavaThread.java	(revision ce55a81847ece86766c279874bcc6dccb9aff995)
+++ benchmark/schedint/JavaThread.java	(revision eccb14d7241424d1aae22fb905858900c58eaa4e)
@@ -24,33 +24,33 @@
 public class JavaThread {
 	// Simplistic low-quality Marsaglia Shift-XOR pseudo-random number generator.
-	// Bijective   
+	// Bijective
 	// Cycle length for non-zero values is 4G-1.
 	// 0 is absorbing and should be avoided -- fixed point.
 	// The returned value is typically masked to produce a positive value.
-	static volatile int Ticket = 0 ; 
+	static volatile int Ticket = 0 ;
 
 	private static int nextRandom (int x) {
-		if (x == 0) { 
+		if (x == 0) {
 			// reseed the PRNG
-			// Ticket is accessed infrequently and does not constitute a coherence hot-spot. 
-			// Note that we use a non-atomic racy increment -- the race is rare and benign. 
-			// If the race is a concern switch to an AtomicInteger.  
-			// In addition accesses to the RW volatile global "Ticket"  variable are not 
-			// (readily) predictable at compile-time so the JIT will not be able to elide 
-			// nextRandom() invocations.  
-			x = ++Ticket ; 
-			if (x == 0) x = 1 ; 
+			// Ticket is accessed infrequently and does not constitute a coherence hot-spot.
+			// Note that we use a non-atomic racy increment -- the race is rare and benign.
+			// If the race is a concern switch to an AtomicInteger.
+			// In addition accesses to the RW volatile global "Ticket"  variable are not
+			// (readily) predictable at compile-time so the JIT will not be able to elide
+			// nextRandom() invocations.
+			x = ++Ticket ;
+			if (x == 0) x = 1 ;
 		}
 		x ^= x << 6;
 		x ^= x >>> 21;
 		x ^= x << 7;
-		return x ;   
+		return x ;
 	}
 	static int x = 2;
 
-	static private int times = Integer.parseInt("1000000");
+	static private long times = Long.parseLong("1000000");
 
 	public static void helper( Monitor m ) throws InterruptedException {
-		for(int i = 1; i <= times; i += 1) {
+		for(long i = 1; i <= times; i += 1) {
 			m.wait();		// relase monitor lock
 			m.next = true;
@@ -76,7 +76,7 @@
 	public static void main(String[] args) throws InterruptedException {
 		if ( args.length > 2 ) System.exit( 1 );
-		if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+		if ( args.length == 2 ) { times = Long.parseLong(args[1]); }
 
-		for (int n = Integer.parseInt("5"); --n >= 0 ; ) { 
+		for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
 			InnerMain();
 			Thread.sleep(2000);     // 2 seconds