// Code by Jonathan Lee and Andy Huchala.

// Computes pairs of nonisomorphic irreducible E8 representations of equal dimension.

import java.util.*;
import java.math.*;

class Pair implements Comparable {
	public Pair(long coordinates, double log) {
		this.coordinates = coordinates;
		this.log = log;
	}

	public int compareTo(Object other) {
		if (this.log - ((Pair) other).log < 0) {
			return -1;
		}
		return 1;
	}

	public double log;
	public long coordinates;
}

public class e8_irreps {
	static int UPPER_BOUND_FACTOR = 900;
	static double[] cachedLogs = new double[UPPER_BOUND_FACTOR];
	static int[] cums = {0, 7, 16, 23, 34, 40, 48, 57};
	static BigInteger bigDenom = new BigInteger("12389761771281087987161913865011039548629176646031786340025309566313679656889905840128000000000000000000000");

	public static void main(String[] args) {
		for (int i = 1; i < UPPER_BOUND_FACTOR; i++) {
			cachedLogs[i] = Math.log(i);
		}
		long x = 0L;
		PriorityQueue<Pair> fringe = new PriorityQueue<Pair>();
		HashSet<Long> seen = new HashSet<Long>();
		int numToCompute = 1000000000;
		int numComputed = 0;

		double irrep = ComputeIrrep(x);
		fringe.add(new Pair(x, irrep));
		double lastLog = 0.0;
		long lastCoord = -1;
		while (numComputed++ < numToCompute) {
			if (numComputed % 250000 == 0) {
				// double high = 0.0;
				// for (Pair p : fringe) {
				// 	if (p.log > high) {
				// 		high = p.log;
				// 	}
				// }
				// System.out.println(numComputed + ", " + fringe.size() + ", " + seen.size());
			}
			Pair cur = fringe.poll();
			seen.remove(cur.coordinates);
			// if (Math.abs(lastLog-cur.log) < 1e-12) {
				// System.out.println(ComputeIrrepInteger(cur.coordinates));
				// System.out.println(ComputeIrrepInteger(lastCoord));
				if (dimension_check(cur.coordinates,lastCoord).compareTo(BigInteger.ZERO)==1) {
					System.out.println(ComputeIrrepInteger(cur.coordinates));
					// System.out.println(ComputeIrrepInteger(lastCoord));
					// System.out.println("found duplicate: " + toArray(cur.coordinates) + ", " + toArray(lastCoord) + ", " + cur.log + ", " + lastLog + ", " + (cur.log-lastLog));
				}
			// }
			lastLog = cur.log;
			lastCoord = cur.coordinates;
			for (int i = 0; i < 8; i++) {
				long newCoord = cur.coordinates + (1L << cums[i]);
				if (seen.contains(newCoord)) {
					continue;
				}
				double newIrrep = ComputeIrrep(newCoord);
				fringe.add(new Pair(newCoord, newIrrep));
				seen.add(newCoord);
			}
		}
	}

	public static BigInteger dimension_check(long coords1, long coords2) {
		// System.out.println(toArray(coords1));
		// System.out.println(toArray(coords2));
		BigInteger dim = ComputeIrrepInteger(coords1);
		if (dim.equals(ComputeIrrepInteger(coords2))) {
			return dim;
		}
		return BigInteger.ZERO;
	}

	public static ArrayList<Integer> toArray(long coords) {
		int x0 = (int) (coords & ((1 << 7) - 1));
		int x1 = (int) ((coords >> 7) & ((1 << 9) - 1));
		int x2 = (int) ((coords >> 16) & ((1 << 7) - 1));
		int x3 = (int) ((coords >> 23) & ((1 << 11) - 1));
		int x4 = (int) ((coords >> 34) & ((1 << 6) - 1));
		int x5 = (int) ((coords >> 40) & ((1 << 8) - 1));
		int x6 = (int) ((coords >> 48) & ((1 << 9) - 1));
		int x7 = (int) ((coords >> 57) & ((1 << 7) - 1));
		ArrayList<Integer> al = new ArrayList<Integer>();
		al.add(x0);al.add(x1);al.add(x2);al.add(x3);
		al.add(x4);al.add(x5);al.add(x6);al.add(x7);
		return al;
	}
	public static double ComputeIrrep(long coords) {
		// >>> x = [7, 9, 7, 11, 6, 8, 9, 7]
		// >>> cum = [sum(x[:i]) for i in range(len(x))]
		// >>> for i in range(8):
		// ...     print 'int x%d = (coords >> %d) & ((1 << %d) - 1);' % (i, cum[i], x[i])

		int x0 = (int) (coords & ((1 << 7) - 1));
		int x1 = (int) ((coords >> 7) & ((1 << 9) - 1));
		int x2 = (int) ((coords >> 16) & ((1 << 7) - 1));
		int x3 = (int) ((coords >> 23) & ((1 << 11) - 1));
		int x4 = (int) ((coords >> 34) & ((1 << 6) - 1));
		int x5 = (int) ((coords >> 40) & ((1 << 8) - 1));
		int x6 = (int) ((coords >> 48) & ((1 << 9) - 1));
		int x7 = (int) ((coords >> 57) & ((1 << 7) - 1));

		double total = 0;
		int _2x0 = x0<<1; int _2x1 = x1<<1; int _2x2 = x2<<1; int _2x3 = x3<<1; int _2x4 = x4<<1;
		int _2x5 = x5<<1; int _2x6 = x6<<1; int _2x7 = x7<<1;

		int _3x0 = 3*x0; int _3x2 = 3*x2; int _3x4 = 3*x4; int _3x5 = 3*x5;
		int _3x6 = 3*x6; int _3x7 = 3*x7;

		int _4x0 = x0<<2; int _4x2 = x2<<2; int _4x4 = x4<<2; int _4x7 = x7<<2;

		int _5x4 = 5*x4;

		int _6x4 = 6*x4;


		total += cachedLogs[x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + 8];
		total += cachedLogs[x0 + x1 + x2 + x3 + x4 + x6 + x7 + 7];
		total += cachedLogs[x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + x7 + 9];
		total += cachedLogs[x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + _2x7 + 10];
		total += cachedLogs[x0 + x1 + x2 + x4 + x5 + x6 + x7 + 7];
		total += cachedLogs[x0 + x1 + x2 + x4 + x5 + x7 + 6];
		total += cachedLogs[x0 + x1 + x2 + x4 + x6 + x7 + 6];
		total += cachedLogs[x0 + x1 + x2 + x4 + x7 + 5];
		total += cachedLogs[x0 + x1 + x2 + _2x4 + x5 + x6 + x7 + 8];
		total += cachedLogs[x0 + x1 + x2 + _2x4 + x5 + x6 + _2x7 + 9];
		total += cachedLogs[x0 + x1 + x2 + _2x4 + x5 + x7 + 7];
		total += cachedLogs[x0 + x1 + x2 + _2x4 + x5 + _2x7 + 8];
		total += cachedLogs[x0 + x1 + _2x2 + x3 + _2x4 + x5 + x6 + _2x7 + 11];
		total += cachedLogs[x0 + x1 + _2x2 + x3 + _2x4 + x5 + _2x6 + _2x7 + 12];
		total += cachedLogs[x0 + x1 + _2x2 + _2x4 + x5 + x6 + _2x7 + 10];
		total += cachedLogs[x0 + x1 + x4 + x5 + x7 + 5];
		total += cachedLogs[x0 + x1 + x4 + x5 + 4];
		total += cachedLogs[x0 + x1 + x4 + x7 + 4];
		total += cachedLogs[x0 + x1 + x4 + 3];
		total += cachedLogs[x0 + x1 + _2x4 + x5 + x7 + 6];
		total += cachedLogs[x0 + x1 + 2];
		total += cachedLogs[x0 + x2 + x3 + x4 + x5 + x6 + x7 + 7];
		total += cachedLogs[x0 + x2 + x3 + x4 + x6 + x7 + 6];
		total += cachedLogs[x0 + x2 + x3 + _2x4 + x5 + x6 + x7 + 8];
		total += cachedLogs[x0 + x2 + x3 + _2x4 + x5 + x6 + _2x7 + 9];
		total += cachedLogs[x0 + x2 + x4 + x5 + x6 + x7 + 6];
		total += cachedLogs[x0 + x2 + x4 + x5 + x7 + 5];
		total += cachedLogs[x0 + x2 + x4 + x6 + x7 + 5];
		total += cachedLogs[x0 + x2 + x4 + x7 + 4];
		total += cachedLogs[x0 + x2 + _2x4 + x5 + x6 + x7 + 7];
		total += cachedLogs[x0 + x2 + _2x4 + x5 + x6 + _2x7 + 8];
		total += cachedLogs[x0 + x2 + _2x4 + x5 + x7 + 6];
		total += cachedLogs[x0 + x2 + _2x4 + x5 + _2x7 + 7];
		total += cachedLogs[x0 + _2x2 + x3 + _2x4 + x5 + x6 + _2x7 + 10];
		total += cachedLogs[x0 + _2x2 + x3 + _2x4 + x5 + _2x6 + _2x7 + 11];
		total += cachedLogs[x0 + _2x2 + _2x4 + x5 + x6 + _2x7 + 9];
		total += cachedLogs[x0 + x4 + x5 + x7 + 4];
		total += cachedLogs[x0 + x4 + x5 + 3];
		total += cachedLogs[x0 + x4 + x7 + 3];
		total += cachedLogs[x0 + x4 + 2];
		total += cachedLogs[x0 + _2x4 + x5 + x7 + 5];
		total += cachedLogs[x0 + 1];
		total += cachedLogs[_2x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + x7 + 10];
		total += cachedLogs[_2x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + _2x7 + 11];
		total += cachedLogs[_2x0 + x1 + x2 + x3 + _3x4 + x5 + x6 + _2x7 + 12];
		total += cachedLogs[_2x0 + x1 + x2 + x3 + _3x4 + _2x5 + x6 + _2x7 + 13];
		total += cachedLogs[_2x0 + x1 + x2 + _2x4 + x5 + x6 + x7 + 9];
		total += cachedLogs[_2x0 + x1 + x2 + _2x4 + x5 + x6 + _2x7 + 10];
		total += cachedLogs[_2x0 + x1 + x2 + _2x4 + x5 + x7 + 8];
		total += cachedLogs[_2x0 + x1 + x2 + _2x4 + x5 + _2x7 + 9];
		total += cachedLogs[_2x0 + x1 + x2 + _3x4 + x5 + x6 + _2x7 + 11];
		total += cachedLogs[_2x0 + x1 + x2 + _3x4 + x5 + _2x7 + 10];
		total += cachedLogs[_2x0 + x1 + x2 + _3x4 + _2x5 + x6 + _2x7 + 12];
		total += cachedLogs[_2x0 + x1 + x2 + _3x4 + _2x5 + _2x7 + 11];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _2x4 + x5 + x6 + _2x7 + 12];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _2x4 + x5 + _2x6 + _2x7 + 13];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + x6 + _2x7 + 13];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + x6 + _3x7 + 14];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + _2x6 + _2x7 + 14];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + _2x6 + _3x7 + 15];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + x6 + _2x7 + 14];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + x6 + _3x7 + 15];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + _2x6 + _2x7 + 15];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + _2x6 + _3x7 + 16];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + x6 + _3x7 + 16];
		total += cachedLogs[_2x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 17];
		total += cachedLogs[_2x0 + x1 + _2x2 + _2x4 + x5 + x6 + _2x7 + 11];
		total += cachedLogs[_2x0 + x1 + _2x2 + _3x4 + x5 + x6 + _2x7 + 12];
		total += cachedLogs[_2x0 + x1 + _2x2 + _3x4 + x5 + x6 + _3x7 + 13];
		total += cachedLogs[_2x0 + x1 + _2x2 + _3x4 + _2x5 + x6 + _2x7 + 13];
		total += cachedLogs[_2x0 + x1 + _2x2 + _3x4 + _2x5 + x6 + _3x7 + 14];
		total += cachedLogs[_2x0 + x1 + _2x2 + _4x4 + _2x5 + x6 + _3x7 + 15];
		total += cachedLogs[_2x0 + x1 + _3x2 + x3 + _3x4 + x5 + _2x6 + _3x7 + 16];
		total += cachedLogs[_2x0 + x1 + _3x2 + x3 + _3x4 + _2x5 + _2x6 + _3x7 + 17];
		total += cachedLogs[_2x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 18];
		total += cachedLogs[_2x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _4x7 + 19];
		total += cachedLogs[_2x0 + x1 + _2x4 + x5 + x7 + 7];
		total += cachedLogs[_3x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + x6 + _3x7 + 17];
		total += cachedLogs[_3x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 18];
		total += cachedLogs[_3x0 + x1 + _2x2 + _4x4 + _2x5 + x6 + _3x7 + 16];
		total += cachedLogs[_3x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 19];
		total += cachedLogs[_3x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _4x7 + 20];
		total += cachedLogs[_3x0 + x1 + _3x2 + x3 + _5x4 + _2x5 + _2x6 + _4x7 + 21];
		total += cachedLogs[_3x0 + x1 + _3x2 + x3 + _5x4 + _3x5 + _2x6 + _4x7 + 22];
		total += cachedLogs[_3x0 + _2x1 + _2x2 + x3 + _4x4 + _2x5 + x6 + _3x7 + 18];
		total += cachedLogs[_3x0 + _2x1 + _2x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 19];
		total += cachedLogs[_3x0 + _2x1 + _2x2 + _4x4 + _2x5 + x6 + _3x7 + 17];
		total += cachedLogs[_3x0 + _2x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 20];
		total += cachedLogs[_3x0 + _2x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _4x7 + 21];
		total += cachedLogs[_3x0 + _2x1 + _3x2 + x3 + _5x4 + _2x5 + _2x6 + _4x7 + 22];
		total += cachedLogs[_3x0 + _2x1 + _3x2 + x3 + _5x4 + _3x5 + _2x6 + _4x7 + 23];
		total += cachedLogs[_4x0 + _2x1 + _3x2 + x3 + _5x4 + _2x5 + _2x6 + _4x7 + 23];
		total += cachedLogs[_4x0 + _2x1 + _3x2 + x3 + _5x4 + _3x5 + _2x6 + _4x7 + 24];
		total += cachedLogs[_4x0 + _2x1 + _3x2 + x3 + _6x4 + _3x5 + _2x6 + _4x7 + 25];
		total += cachedLogs[_4x0 + _2x1 + _3x2 + x3 + _6x4 + _3x5 + _2x6 + 5*x7 + 26];
		total += cachedLogs[_4x0 + _2x1 + _4x2 + x3 + _6x4 + _3x5 + _2x6 + 5*x7 + 27];
		total += cachedLogs[_4x0 + _2x1 + _4x2 + x3 + _6x4 + _3x5 + _3x6 + 5*x7 + 28];
		total += cachedLogs[_4x0 + _2x1 + _4x2 + _2x3 + _6x4 + _3x5 + _3x6 + 5*x7 + 29];
		total += cachedLogs[x1 + 1];
		total += cachedLogs[x2 + x3 + x4 + x6 + x7 + 5];
		total += cachedLogs[x2 + x3 + x6 + x7 + 4];
		total += cachedLogs[x2 + x3 + x6 + 3];
		total += cachedLogs[x2 + x4 + x6 + x7 + 4];
		total += cachedLogs[x2 + x4 + x7 + 3];
		total += cachedLogs[x2 + x6 + x7 + 3];
		total += cachedLogs[x2 + x6 + 2];
		total += cachedLogs[x2 + x7 + 2];
		total += cachedLogs[x2 + 1];
		total += cachedLogs[x2 + x3 + x4 + x5 + x6 + x7 + 6];
		total += cachedLogs[x2 + x4 + x5 + x6 + x7 + 5];
		total += cachedLogs[x2 + x4 + x5 + x7 + 4];
		total += cachedLogs[x3 + x6 + 2];
		total += cachedLogs[x3 + 1];
		total += cachedLogs[x4 + x7 + 2];
		total += cachedLogs[x4 + 1];
		total += cachedLogs[x4 + x5 + x7 + 3];
		total += cachedLogs[x4 + x5 + 2];
		total += cachedLogs[x5 + 1];
		total += cachedLogs[x6 + 1];
		total += cachedLogs[x7 + 1];
		return total;
	}

	public static BigInteger ComputeIrrepInteger(long coords) {
		// >>> x = [7, 9, 7, 11, 6, 8, 9, 7]
		// >>> cum = [sum(x[:i]) for i in range(len(x))]
		// >>> for i in range(8):
		// ...     print 'int x%d = (coords >> %d) & ((1 << %d) - 1);' % (i, cum[i], x[i])

		int x0 = (int) (coords & ((1 << 7) - 1));
		int x1 = (int) ((coords >> 7) & ((1 << 9) - 1));
		int x2 = (int) ((coords >> 16) & ((1 << 7) - 1));
		int x3 = (int) ((coords >> 23) & ((1 << 11) - 1));
		int x4 = (int) ((coords >> 34) & ((1 << 6) - 1));
		int x5 = (int) ((coords >> 40) & ((1 << 8) - 1));
		int x6 = (int) ((coords >> 48) & ((1 << 9) - 1));
		int x7 = (int) ((coords >> 57) & ((1 << 7) - 1));

		BigInteger total = BigInteger.ONE;

		int _2x0 = x0<<1; int _2x1 = x1<<1; int _2x2 = x2<<1; int _2x3 = x3<<1; int _2x4 = x4<<1;
		int _2x5 = x5<<1; int _2x6 = x6<<1; int _2x7 = x7<<1;

		int _3x0 = 3*x0; int _3x2 = 3*x2; int _3x4 = 3*x4; int _3x5 = 3*x5;
		int _3x6 = 3*x6; int _3x7 = 3*x7;

		int _4x0 = x0<<2; int _4x2 = x2<<2; int _4x4 = x4<<2; int _4x7 = x7<<2;

		int _5x4 = 5*x4;

		int _6x4 = 6*x4;

		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + 8));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x3 + x4 + x6 + x7 + 7));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + x7 + 9));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + _2x7 + 10));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x4 + x5 + x6 + x7 + 7));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x4 + x5 + x7 + 6));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x4 + x6 + x7 + 6));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + x4 + x7 + 5));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + _2x4 + x5 + x6 + x7 + 8));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + _2x4 + x5 + x6 + _2x7 + 9));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + _2x4 + x5 + x7 + 7));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x2 + _2x4 + x5 + _2x7 + 8));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + _2x2 + x3 + _2x4 + x5 + x6 + _2x7 + 11));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + _2x2 + x3 + _2x4 + x5 + _2x6 + _2x7 + 12));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + _2x2 + _2x4 + x5 + x6 + _2x7 + 10));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x4 + x5 + x7 + 5));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x4 + x5 + 4));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x4 + x7 + 4));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + x4 + 3));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + _2x4 + x5 + x7 + 6));
		total = total.multiply(BigInteger.valueOf(x0 + x1 + 2));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x3 + x4 + x5 + x6 + x7 + 7));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x3 + x4 + x6 + x7 + 6));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x3 + _2x4 + x5 + x6 + x7 + 8));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x3 + _2x4 + x5 + x6 + _2x7 + 9));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x4 + x5 + x6 + x7 + 6));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x4 + x5 + x7 + 5));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x4 + x6 + x7 + 5));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + x4 + x7 + 4));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + _2x4 + x5 + x6 + x7 + 7));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + _2x4 + x5 + x6 + _2x7 + 8));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + _2x4 + x5 + x7 + 6));
		total = total.multiply(BigInteger.valueOf(x0 + x2 + _2x4 + x5 + _2x7 + 7));
		total = total.multiply(BigInteger.valueOf(x0 + _2x2 + x3 + _2x4 + x5 + x6 + _2x7 + 10));
		total = total.multiply(BigInteger.valueOf(x0 + _2x2 + x3 + _2x4 + x5 + _2x6 + _2x7 + 11));
		total = total.multiply(BigInteger.valueOf(x0 + _2x2 + _2x4 + x5 + x6 + _2x7 + 9));
		total = total.multiply(BigInteger.valueOf(x0 + x4 + x5 + x7 + 4));
		total = total.multiply(BigInteger.valueOf(x0 + x4 + x5 + 3));
		total = total.multiply(BigInteger.valueOf(x0 + x4 + x7 + 3));
		total = total.multiply(BigInteger.valueOf(x0 + x4 + 2));
		total = total.multiply(BigInteger.valueOf(x0 + _2x4 + x5 + x7 + 5));
		total = total.multiply(BigInteger.valueOf(x0 + 1));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + x7 + 10));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + x3 + _2x4 + x5 + x6 + _2x7 + 11));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + x3 + _3x4 + x5 + x6 + _2x7 + 12));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + x3 + _3x4 + _2x5 + x6 + _2x7 + 13));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _2x4 + x5 + x6 + x7 + 9));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _2x4 + x5 + x6 + _2x7 + 10));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _2x4 + x5 + x7 + 8));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _2x4 + x5 + _2x7 + 9));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _3x4 + x5 + x6 + _2x7 + 11));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _3x4 + x5 + _2x7 + 10));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _3x4 + _2x5 + x6 + _2x7 + 12));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + x2 + _3x4 + _2x5 + _2x7 + 11));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _2x4 + x5 + x6 + _2x7 + 12));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _2x4 + x5 + _2x6 + _2x7 + 13));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + x6 + _2x7 + 13));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + x6 + _3x7 + 14));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + _2x6 + _2x7 + 14));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + x5 + _2x6 + _3x7 + 15));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + x6 + _2x7 + 14));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + x6 + _3x7 + 15));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + _2x6 + _2x7 + 15));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _3x4 + _2x5 + _2x6 + _3x7 + 16));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + x6 + _3x7 + 16));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 17));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + _2x4 + x5 + x6 + _2x7 + 11));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + _3x4 + x5 + x6 + _2x7 + 12));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + _3x4 + x5 + x6 + _3x7 + 13));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + _3x4 + _2x5 + x6 + _2x7 + 13));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + _3x4 + _2x5 + x6 + _3x7 + 14));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x2 + _4x4 + _2x5 + x6 + _3x7 + 15));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _3x2 + x3 + _3x4 + x5 + _2x6 + _3x7 + 16));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _3x2 + x3 + _3x4 + _2x5 + _2x6 + _3x7 + 17));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 18));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _4x7 + 19));
		total = total.multiply(BigInteger.valueOf(_2x0 + x1 + _2x4 + x5 + x7 + 7));
		total = total.multiply(BigInteger.valueOf(_3x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + x6 + _3x7 + 17));
		total = total.multiply(BigInteger.valueOf(_3x0 + x1 + _2x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 18));
		total = total.multiply(BigInteger.valueOf(_3x0 + x1 + _2x2 + _4x4 + _2x5 + x6 + _3x7 + 16));
		total = total.multiply(BigInteger.valueOf(_3x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 19));
		total = total.multiply(BigInteger.valueOf(_3x0 + x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _4x7 + 20));
		total = total.multiply(BigInteger.valueOf(_3x0 + x1 + _3x2 + x3 + _5x4 + _2x5 + _2x6 + _4x7 + 21));
		total = total.multiply(BigInteger.valueOf(_3x0 + x1 + _3x2 + x3 + _5x4 + _3x5 + _2x6 + _4x7 + 22));
		total = total.multiply(BigInteger.valueOf(_3x0 + _2x1 + _2x2 + x3 + _4x4 + _2x5 + x6 + _3x7 + 18));
		total = total.multiply(BigInteger.valueOf(_3x0 + _2x1 + _2x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 19));
		total = total.multiply(BigInteger.valueOf(_3x0 + _2x1 + _2x2 + _4x4 + _2x5 + x6 + _3x7 + 17));
		total = total.multiply(BigInteger.valueOf(_3x0 + _2x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _3x7 + 20));
		total = total.multiply(BigInteger.valueOf(_3x0 + _2x1 + _3x2 + x3 + _4x4 + _2x5 + _2x6 + _4x7 + 21));
		total = total.multiply(BigInteger.valueOf(_3x0 + _2x1 + _3x2 + x3 + _5x4 + _2x5 + _2x6 + _4x7 + 22));
		total = total.multiply(BigInteger.valueOf(_3x0 + _2x1 + _3x2 + x3 + _5x4 + _3x5 + _2x6 + _4x7 + 23));
		total = total.multiply(BigInteger.valueOf(_4x0 + _2x1 + _3x2 + x3 + _5x4 + _2x5 + _2x6 + _4x7 + 23));
		total = total.multiply(BigInteger.valueOf(_4x0 + _2x1 + _3x2 + x3 + _5x4 + _3x5 + _2x6 + _4x7 + 24));
		total = total.multiply(BigInteger.valueOf(_4x0 + _2x1 + _3x2 + x3 + _6x4 + _3x5 + _2x6 + _4x7 + 25));
		total = total.multiply(BigInteger.valueOf(_4x0 + _2x1 + _3x2 + x3 + _6x4 + _3x5 + _2x6 + 5*x7 + 26));
		total = total.multiply(BigInteger.valueOf(_4x0 + _2x1 + _4x2 + x3 + _6x4 + _3x5 + _2x6 + 5*x7 + 27));
		total = total.multiply(BigInteger.valueOf(_4x0 + _2x1 + _4x2 + x3 + _6x4 + _3x5 + _3x6 + 5*x7 + 28));
		total = total.multiply(BigInteger.valueOf(_4x0 + _2x1 + _4x2 + _2x3 + _6x4 + _3x5 + _3x6 + 5*x7 + 29));
		total = total.multiply(BigInteger.valueOf(x1 + 1));
		total = total.multiply(BigInteger.valueOf(x2 + x3 + x4 + x6 + x7 + 5));
		total = total.multiply(BigInteger.valueOf(x2 + x3 + x6 + x7 + 4));
		total = total.multiply(BigInteger.valueOf(x2 + x3 + x6 + 3));
		total = total.multiply(BigInteger.valueOf(x2 + x4 + x6 + x7 + 4));
		total = total.multiply(BigInteger.valueOf(x2 + x4 + x7 + 3));
		total = total.multiply(BigInteger.valueOf(x2 + x6 + x7 + 3));
		total = total.multiply(BigInteger.valueOf(x2 + x6 + 2));
		total = total.multiply(BigInteger.valueOf(x2 + x7 + 2));
		total = total.multiply(BigInteger.valueOf(x2 + 1));
		total = total.multiply(BigInteger.valueOf(x2 + x3 + x4 + x5 + x6 + x7 + 6));
		total = total.multiply(BigInteger.valueOf(x2 + x4 + x5 + x6 + x7 + 5));
		total = total.multiply(BigInteger.valueOf(x2 + x4 + x5 + x7 + 4));
		total = total.multiply(BigInteger.valueOf(x3 + x6 + 2));
		total = total.multiply(BigInteger.valueOf(x3 + 1));
		total = total.multiply(BigInteger.valueOf(x4 + x7 + 2));
		total = total.multiply(BigInteger.valueOf(x4 + 1));
		total = total.multiply(BigInteger.valueOf(x4 + x5 + x7 + 3));
		total = total.multiply(BigInteger.valueOf(x4 + x5 + 2));
		total = total.multiply(BigInteger.valueOf(x5 + 1));
		total = total.multiply(BigInteger.valueOf(x6 + 1));
		total = total.multiply(BigInteger.valueOf(x7 + 1));
		total = total.divide(bigDenom);
		return total;
	}
}