test.sub

executable = /home/amir/dev/mace/_venv/bin/python
error = _cluster_logs/test.$(Process).err
output = _cluster_logs/test.$(Process).out
log = _cluster_logs/test.$(Process).log
request_memory = 32768
request_cpus = 1





arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 0 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 1 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 2 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 3 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 4 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 5 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 6 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 7 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 8 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 9 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 10 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 11 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 12 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 13 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 14 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 15 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 16 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 17 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 18 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 19 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 20 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 21 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 22 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 23 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 24 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 25 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 26 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 27 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 28 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 29 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 30 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 31 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 32 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 33 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 34 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 35 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 36 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 37 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 38 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 39 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 40 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 41 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 42 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 43 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 44 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 45 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 46 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 47 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 48 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 49 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 50 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 51 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 52 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 53 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 54 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 55 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 56 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 57 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 58 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 59 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 60 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 61 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 62 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 63 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 64 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 65 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 66 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 67 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 68 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 69 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 70 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 71 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 72 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 73 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 74 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 75 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 76 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 77 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 78 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 79 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 80 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 81 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 82 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 83 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 84 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 85 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 86 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 87 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 88 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 89 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 90 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 91 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 92 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 93 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 94 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 95 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 96 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 97 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 98 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 99 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 100 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 101 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 102 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 103 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 104 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 105 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 106 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 107 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 108 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 109 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 110 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 111 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 112 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 113 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 114 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 115 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 116 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 117 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 118 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 119 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 120 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 121 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 122 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 123 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 124 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 125 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 126 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 127 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 128 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 129 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 130 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 131 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 132 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 133 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 134 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 135 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 136 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 137 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 138 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 139 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 140 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 141 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 142 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 143 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 144 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 145 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 146 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 147 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 148 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 149 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 150 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 151 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 152 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 153 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 154 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 155 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 156 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 157 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 158 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 159 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 160 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 161 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 162 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 163 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 164 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 165 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 166 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 167 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 168 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 169 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 170 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 171 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 172 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 173 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 174 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 175 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 176 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 177 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 178 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 179 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 180 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 181 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 182 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 183 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 184 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 185 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 186 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 187 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 188 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 189 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 190 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 191 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 192 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 193 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 194 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 195 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 196 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 197 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 198 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 199 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 200 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 201 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 202 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 203 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 204 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 205 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 206 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 207 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 208 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 209 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 210 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 211 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 212 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 213 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 214 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 215 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 216 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 217 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 218 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 219 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 220 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 221 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 222 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 223 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 224 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 225 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 226 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 227 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 228 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 229 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 230 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 231 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 232 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 233 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 234 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 235 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 236 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 237 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 238 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 239 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 240 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 241 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 242 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 243 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 244 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 245 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 246 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 247 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 248 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 249 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 250 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 251 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 252 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 253 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 254 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 255 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 256 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 257 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 258 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 259 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 260 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 261 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 262 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 263 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 264 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 265 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 266 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 267 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 268 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 269 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 270 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 271 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 272 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 273 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 274 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 275 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 276 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 277 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 278 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 279 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 280 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 281 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 282 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 283 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 284 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 285 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 286 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 287 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 288 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 289 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 290 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 291 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 292 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 293 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 294 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 295 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 296 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 297 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 298 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 299 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 300 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 301 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 302 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 303 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 304 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 305 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 306 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 307 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 308 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 309 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 310 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 311 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 312 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 313 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 314 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 315 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 316 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 317 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 318 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 319 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 320 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 321 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 322 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 323 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 324 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 325 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 326 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 327 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 328 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 329 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 330 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 331 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 332 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 333 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 334 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 335 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 336 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 337 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 338 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 339 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 340 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 341 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 342 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 343 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 344 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 345 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 346 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 347 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 348 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 349 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 350 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 351 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 352 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 353 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 354 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 355 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 356 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 357 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 358 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 359 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 360 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 361 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 362 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 363 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 364 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 365 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 366 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 367 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 368 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 369 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 370 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 371 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 372 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 373 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 374 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 375 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 376 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 377 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 378 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 379 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 380 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 381 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 382 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 383 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 384 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 385 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 386 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 387 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 388 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 389 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 390 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 391 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 392 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 393 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 394 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 395 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 396 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 397 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 398 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 399 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 400 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 401 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 402 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 403 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 404 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 405 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 406 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 407 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 408 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 409 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 410 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 411 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 412 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 413 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 414 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 415 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 416 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 417 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 418 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 419 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 420 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 421 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 422 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 423 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 424 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 425 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 426 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 427 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 428 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 429 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 430 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 431 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 432 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 433 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 434 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 435 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 436 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 437 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 438 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 439 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 440 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 441 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 442 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 443 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 444 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 445 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 446 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 447 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 448 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 449 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 450 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 451 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 452 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 453 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 454 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 455 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 456 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 457 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 458 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 459 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 460 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 461 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 462 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 463 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 464 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 465 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 466 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 467 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 468 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 469 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 470 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 471 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 472 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 473 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 474 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 475 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 476 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 477 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 478 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 479 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 480 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 481 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 482 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 483 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 484 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 485 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 486 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 487 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 488 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 489 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 490 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 491 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 492 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 493 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 494 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 495 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 496 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 497 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 498 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m lr -n two_norm -a MACE_eps_1e-3 -b 499 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 0 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 1 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 2 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 3 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 4 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 5 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 6 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 7 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 8 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 9 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 10 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 11 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 12 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 13 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 14 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 15 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 16 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 17 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 18 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 19 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 20 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 21 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 22 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 23 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 24 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 25 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 26 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 27 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 28 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 29 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 30 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 31 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 32 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 33 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 34 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 35 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 36 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 37 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 38 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 39 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 40 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 41 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 42 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 43 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 44 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 45 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 46 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 47 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 48 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 49 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 50 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 51 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 52 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 53 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 54 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 55 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 56 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 57 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 58 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 59 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 60 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 61 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 62 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 63 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 64 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 65 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 66 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 67 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 68 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 69 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 70 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 71 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 72 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 73 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 74 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 75 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 76 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 77 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 78 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 79 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 80 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 81 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 82 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 83 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 84 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 85 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 86 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 87 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 88 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 89 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 90 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 91 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 92 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 93 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 94 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 95 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 96 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 97 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 98 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 99 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 100 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 101 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 102 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 103 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 104 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 105 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 106 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 107 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 108 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 109 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 110 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 111 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 112 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 113 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 114 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 115 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 116 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 117 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 118 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 119 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 120 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 121 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 122 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 123 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 124 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 125 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 126 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 127 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 128 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 129 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 130 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 131 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 132 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 133 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 134 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 135 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 136 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 137 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 138 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 139 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 140 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 141 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 142 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 143 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 144 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 145 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 146 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 147 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 148 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 149 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 150 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 151 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 152 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 153 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 154 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 155 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 156 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 157 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 158 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 159 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 160 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 161 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 162 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 163 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 164 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 165 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 166 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 167 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 168 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 169 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 170 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 171 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 172 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 173 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 174 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 175 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 176 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 177 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 178 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 179 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 180 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 181 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 182 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 183 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 184 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 185 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 186 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 187 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 188 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 189 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 190 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 191 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 192 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 193 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 194 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 195 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 196 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 197 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 198 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 199 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 200 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 201 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 202 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 203 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 204 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 205 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 206 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 207 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 208 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 209 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 210 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 211 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 212 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 213 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 214 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 215 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 216 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 217 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 218 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 219 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 220 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 221 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 222 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 223 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 224 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 225 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 226 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 227 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 228 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 229 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 230 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 231 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 232 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 233 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 234 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 235 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 236 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 237 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 238 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 239 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 240 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 241 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 242 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 243 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 244 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 245 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 246 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 247 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 248 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 249 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 250 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 251 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 252 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 253 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 254 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 255 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 256 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 257 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 258 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 259 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 260 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 261 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 262 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 263 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 264 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 265 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 266 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 267 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 268 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 269 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 270 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 271 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 272 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 273 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 274 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 275 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 276 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 277 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 278 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 279 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 280 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 281 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 282 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 283 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 284 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 285 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 286 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 287 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 288 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 289 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 290 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 291 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 292 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 293 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 294 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 295 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 296 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 297 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 298 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 299 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 300 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 301 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 302 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 303 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 304 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 305 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 306 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 307 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 308 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 309 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 310 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 311 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 312 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 313 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 314 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 315 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 316 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 317 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 318 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 319 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 320 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 321 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 322 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 323 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 324 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 325 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 326 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 327 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 328 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 329 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 330 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 331 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 332 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 333 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 334 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 335 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 336 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 337 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 338 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 339 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 340 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 341 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 342 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 343 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 344 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 345 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 346 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 347 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 348 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 349 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 350 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 351 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 352 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 353 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 354 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 355 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 356 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 357 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 358 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 359 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 360 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 361 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 362 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 363 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 364 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 365 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 366 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 367 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 368 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 369 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 370 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 371 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 372 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 373 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 374 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 375 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 376 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 377 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 378 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 379 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 380 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 381 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 382 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 383 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 384 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 385 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 386 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 387 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 388 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 389 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 390 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 391 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 392 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 393 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 394 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 395 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 396 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 397 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 398 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 399 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 400 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 401 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 402 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 403 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 404 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 405 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 406 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 407 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 408 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 409 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 410 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 411 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 412 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 413 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 414 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 415 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 416 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 417 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 418 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 419 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 420 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 421 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 422 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 423 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 424 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 425 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 426 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 427 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 428 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 429 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 430 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 431 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 432 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 433 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 434 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 435 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 436 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 437 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 438 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 439 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 440 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 441 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 442 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 443 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 444 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 445 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 446 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 447 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 448 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 449 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 450 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 451 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 452 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 453 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 454 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 455 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 456 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 457 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 458 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 459 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 460 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 461 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 462 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 463 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 464 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 465 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 466 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 467 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 468 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 469 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 470 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 471 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 472 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 473 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 474 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 475 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 476 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 477 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 478 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 479 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 480 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 481 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 482 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 483 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 484 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 485 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 486 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 487 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 488 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 489 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 490 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 491 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 492 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 493 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 494 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 495 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 496 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 497 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 498 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m tree -n two_norm -a MACE_eps_1e-3 -b 499 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 0 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 1 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 2 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 3 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 4 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 5 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 6 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 7 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 8 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 9 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 10 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 11 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 12 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 13 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 14 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 15 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 16 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 17 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 18 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 19 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 20 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 21 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 22 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 23 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 24 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 25 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 26 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 27 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 28 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 29 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 30 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 31 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 32 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 33 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 34 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 35 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 36 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 37 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 38 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 39 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 40 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 41 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 42 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 43 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 44 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 45 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 46 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 47 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 48 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 49 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 50 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 51 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 52 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 53 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 54 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 55 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 56 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 57 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 58 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 59 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 60 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 61 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 62 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 63 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 64 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 65 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 66 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 67 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 68 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 69 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 70 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 71 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 72 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 73 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 74 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 75 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 76 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 77 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 78 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 79 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 80 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 81 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 82 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 83 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 84 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 85 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 86 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 87 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 88 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 89 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 90 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 91 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 92 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 93 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 94 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 95 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 96 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 97 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 98 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 99 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 100 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 101 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 102 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 103 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 104 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 105 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 106 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 107 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 108 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 109 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 110 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 111 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 112 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 113 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 114 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 115 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 116 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 117 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 118 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 119 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 120 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 121 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 122 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 123 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 124 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 125 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 126 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 127 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 128 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 129 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 130 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 131 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 132 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 133 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 134 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 135 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 136 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 137 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 138 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 139 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 140 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 141 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 142 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 143 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 144 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 145 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 146 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 147 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 148 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 149 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 150 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 151 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 152 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 153 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 154 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 155 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 156 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 157 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 158 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 159 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 160 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 161 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 162 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 163 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 164 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 165 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 166 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 167 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 168 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 169 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 170 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 171 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 172 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 173 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 174 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 175 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 176 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 177 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 178 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 179 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 180 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 181 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 182 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 183 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 184 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 185 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 186 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 187 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 188 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 189 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 190 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 191 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 192 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 193 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 194 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 195 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 196 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 197 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 198 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 199 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 200 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 201 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 202 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 203 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 204 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 205 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 206 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 207 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 208 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 209 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 210 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 211 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 212 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 213 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 214 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 215 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 216 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 217 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 218 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 219 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 220 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 221 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 222 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 223 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 224 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 225 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 226 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 227 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 228 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 229 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 230 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 231 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 232 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 233 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 234 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 235 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 236 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 237 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 238 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 239 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 240 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 241 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 242 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 243 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 244 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 245 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 246 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 247 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 248 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 249 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 250 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 251 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 252 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 253 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 254 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 255 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 256 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 257 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 258 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 259 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 260 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 261 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 262 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 263 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 264 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 265 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 266 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 267 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 268 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 269 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 270 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 271 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 272 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 273 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 274 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 275 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 276 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 277 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 278 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 279 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 280 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 281 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 282 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 283 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 284 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 285 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 286 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 287 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 288 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 289 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 290 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 291 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 292 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 293 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 294 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 295 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 296 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 297 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 298 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 299 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 300 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 301 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 302 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 303 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 304 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 305 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 306 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 307 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 308 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 309 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 310 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 311 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 312 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 313 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 314 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 315 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 316 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 317 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 318 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 319 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 320 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 321 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 322 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 323 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 324 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 325 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 326 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 327 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 328 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 329 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 330 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 331 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 332 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 333 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 334 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 335 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 336 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 337 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 338 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 339 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 340 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 341 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 342 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 343 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 344 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 345 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 346 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 347 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 348 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 349 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 350 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 351 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 352 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 353 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 354 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 355 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 356 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 357 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 358 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 359 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 360 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 361 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 362 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 363 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 364 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 365 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 366 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 367 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 368 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 369 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 370 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 371 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 372 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 373 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 374 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 375 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 376 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 377 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 378 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 379 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 380 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 381 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 382 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 383 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 384 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 385 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 386 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 387 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 388 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 389 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 390 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 391 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 392 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 393 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 394 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 395 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 396 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 397 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 398 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 399 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 400 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 401 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 402 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 403 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 404 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 405 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 406 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 407 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 408 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 409 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 410 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 411 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 412 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 413 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 414 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 415 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 416 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 417 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 418 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 419 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 420 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 421 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 422 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 423 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 424 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 425 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 426 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 427 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 428 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 429 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 430 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 431 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 432 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 433 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 434 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 435 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 436 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 437 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 438 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 439 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 440 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 441 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 442 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 443 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 444 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 445 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 446 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 447 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 448 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 449 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 450 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 451 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 452 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 453 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 454 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 455 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 456 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 457 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 458 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 459 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 460 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 461 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 462 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 463 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 464 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 465 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 466 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 467 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 468 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 469 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 470 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 471 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 472 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 473 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 474 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 475 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 476 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 477 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 478 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 479 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 480 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 481 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 482 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 483 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 484 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 485 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 486 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 487 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 488 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 489 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 490 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 491 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 492 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 493 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 494 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 495 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 496 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 497 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 498 -s 10  -g neg_and_pos  -p $(Process)
queue


arguments = batchTest.py -d twomoon -m mlp -n two_norm -a MACE_eps_1e-3 -b 499 -s 10  -g neg_and_pos  -p $(Process)
queue