/*
  OUTPUT A
 
  % java Worker?  
  15
*/





/*
  OUTPUT B
 
  % java Worker?  
  30
*/





/*
  OUTPUT C
 
  % java Worker?
  0 1 2 3 4 5
  
*/





/*
  OUTPUT D
 
  % java Worker?
  5 4 3 2 1 0
  
*/





/*
  OUTPUT E 
 
  % java Worker?  
  <compile error>
*/




/*
  OUTPUT F
 
  % java Worker?  
  0

*/



/*
  OUTPUT G
 
  % java Worker?
  (any of the following and lots more are possible)  
  5 4 3 3 4 5
  0 4 2 2 4 0
  5 1 2 2 1 5
  5 4 2 2 4 5
  0 4 3 3 4 0
  ...
*/



/*
  OUTPUT H
 
  % java Worker?  
  (any of the following are technically possible, though the first is the most probable)
  0
  1
  3
  6
  10
  15
*/


















public class Worker1 implements Runnable 
{
	private int [] 	d 		= null;
	private int 	result	= 0;
	
	public Worker1(int [] d) 	{ this.d = d; 	 }	
	public int getResult() 		{ return result; }
	
	public void run()
	{
		for (int i : d)
			result += i;
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		
		Thread t1 = new Thread(new Worker1(d));
		t1.start();
		System.out.println(Worker1.getResult());
	}
}


public class Worker2 implements Runnable 
{
	private int [] 	d 		= null;
	private int 	result	= 0;
	
	public Worker2(int [] d) 	{ this.d = d; 	 }	
	public int getResult() 		{ return result; }
	
	public void run()
	{
		for (int i : d)
			result += i;
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		Worker2 w = new Worker2(d);
		Thread t1 = new Thread(w);
		t1.start();
		try 
		{ 
			t1.join(); 
		} catch (InterruptedException e) 
		{ 
			e.printStackTrace(); 
		}
		System.out.println(w.getResult());
	}
}


public class Worker3 implements Runnable 
{
	private int [] d = null;
	
	public Worker3(int [] d) 	{ this.d = d; 	 }	
	
	public void mystery()
	{
		for (int i = 0; i < d.length / 2; i++)
		{
			int swap = d[i];
			d[i] = d[d.length - i - 1];
			d[d.length - i - 1] = swap;
		}
	}
	
	public void run()
	{
		for (int loops = 0; loops < 999; loops++)
			mystery();
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		Worker3 w = new Worker3(d);
		
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		t1.start();
		t2.start();
		
		try 
		{ 			
			t1.join();
			t2.join();
		} catch (InterruptedException e) 
		{ 
			e.printStackTrace(); 
		}
		for (int i : d)
			System.out.print(i + " ");
	}
}











public class Worker4 implements Runnable 
{
	private int [] 	d 		= null;
	private int 	result	= 0;
	
	public Worker4(int [] d) 	{ this.d = d; 	 }	
	public int getResult() 		{ return result; }
	
	public void run()
	{
		for (int i : d)
			result += i;
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		Worker4 w = new Worker4(d);
		Thread t1 = new Thread(w);
		t1.start();
		System.out.println(w.getResult());
	}
}

































public class Worker5 implements Runnable 
{
	private int [] d = null;
	
	public Worker5(int [] d) 	{ this.d = d; 	 }	
	
	public synchronized void mystery()
	{
		for (int i = 0; i < d.length / 2; i++)
		{
			int swap = d[i];
			d[i] = d[d.length - i - 1];
			d[d.length - i - 1] = swap;
		}
	}
	
	public void run()
	{
		for (int loops = 0; loops < 999; loops++)
			mystery();
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		Worker5 w = new Worker5(d);
		
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		t1.start();
		t2.start();
		
		try 
		{ 			
			t1.join();
			t2.join();
		} catch (InterruptedException e) 
		{ 
			e.printStackTrace(); 
		}
		for (int i : d)
			System.out.print(i + " ");
	}
}












public class Worker6 implements Runnable 
{
	private int [] 	d 		= null;
	private int 	result	= 0;
	
	public Worker6(int [] d) 	{ this.d = d; 	 }	
	public int getResult() 		{ return result; }
	
	public void run()
	{
		for (int i : d)
			result += i;
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		Worker6 w = new Worker6(d);
		Worker6 x = new Worker6(d);
		
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(x);
		t1.start();
		t2.start();
		
		try 
		{ 
			t2.join();
			t1.join();			
		} catch (InterruptedException e) 
		{ 
			e.printStackTrace(); 
		}
		
		System.out.println(w.getResult() + x.getResult());
	}
}




















public class Worker7 implements Runnable 
{
	private int [] d = null;
	
	public Worker7(int [] d) 	{ this.d = d; 	 }	
	
	public synchronized void mystery()
	{
		for (int i = 0; i < d.length / 2; i++)
		{
			int swap = d[i];
			d[i] = d[d.length - i - 1];
			d[d.length - i - 1] = swap;
		}
	}
	
	public void run()
	{
		for (int loops = 0; loops < 999; loops++)
			mystery();
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		Worker7 w = new Worker7(d);
		
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);
		t1.start();
		t2.start();
		t3.start();
		
		try 
		{ 			
			t1.join();
			t2.join();
			t3.join();
		} catch (InterruptedException e) 
		{ 
			e.printStackTrace(); 
		}
		for (int i : d)
			System.out.print(i + " ");
	}
}








public class Worker8 implements Runnable 
{
	private int [] 	d 		= null;
	private int 	result	= 0;
	
	public Worker8(int [] d) 	{ this.d = d; 	 }	
	public int getResult() 		{ return result; }
	
	public void run()
	{
		for (int i : d)
			result += i;
	}
	
	public static void main(String [] args)
	{
		int [] d = {0, 1, 2, 3, 4, 5};
		Worker8 w = new Worker8(d);
		Thread t1 = new Thread();
		t1.start();
		try 
		{ 			
			t1.join();
		} catch (InterruptedException e) 
		{ 
			e.printStackTrace(); 
		}
		System.out.println(w.getResult());
	}
}