water_GromacsForces.dat

ASSERT_EQUAL_VEC(Vec3( 1.53862e+01, -9.40085e+01,  8.09974e+01), forces1[0], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.16025e+01,  3.42647e+01,  7.90920e+01), forces1[1], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.96273e+01,  7.80017e+01,  7.38545e+00), forces1[2], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.28843e+01, -1.89277e+01, -2.54913e+02), forces1[3], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.22785e+01, -3.88301e+01, -2.81351e+02), forces1[4], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.09090e+02,  1.75451e+02, -1.29874e+02), forces1[5], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.95616e+02,  5.36132e+02, -4.55554e+02), forces1[6], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.85944e+02, -1.19523e+02,  7.88721e+01), forces1[7], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.13615e+02, -6.17221e+01,  1.57270e+02), forces1[8], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.66977e+01, -6.36326e+01,  1.65651e+02), forces1[9], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.62216e+00,  1.13905e+02, -5.46500e+01), forces1[10], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.21610e+01,  2.96483e+01, -6.34852e+01), forces1[11], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.01658e+01,  1.07406e+02,  2.69335e+01), forces1[12], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.14730e+01,  9.63730e+01,  1.37884e+02), forces1[13], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.45980e+02,  2.47183e+01,  1.30466e+02), forces1[14], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.15321e+01,  2.08457e+02,  4.15324e+02), forces1[15], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.53856e+02,  6.74890e+01, -7.69439e+01), forces1[16], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.56804e+02,  1.82869e+02,  2.35455e+02), forces1[17], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.78646e+02,  4.16416e+01, -2.55139e+02), forces1[18], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.51530e+01,  3.24295e+01,  1.87664e+01), forces1[19], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.04660e+02, -2.25016e+02,  5.95159e+01), forces1[20], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.93048e+01,  3.22523e+01,  1.06075e+02), forces1[21], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.84792e+01,  1.15745e+02,  9.08190e+01), forces1[22], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.22807e+01, -3.30640e+01,  2.38179e+01), forces1[23], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.10281e+01,  5.37699e+01,  1.70935e+02), forces1[24], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.55507e+01,  2.52756e+02,  1.34829e+02), forces1[25], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.62832e+01, -6.20729e+01, -9.53832e+01), forces1[26], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.93262e+01, -8.64360e+01, -9.20284e+01), forces1[27], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.72500e+00, -1.78213e+02,  1.54062e+01), forces1[28], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.46320e+02,  1.93997e+01, -1.06660e+01), forces1[29], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.02138e+01,  1.84585e+02, -1.96791e+02), forces1[30], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.44392e+01, -1.63547e+02, -1.34078e+02), forces1[31], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.64487e+01, -1.01917e+02, -2.94291e+01), forces1[32], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.62979e+02, -8.44104e+01,  4.45776e+00), forces1[33], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.37054e+02, -1.64893e+01,  1.62445e+02), forces1[34], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.79879e+02, -1.28158e+02,  1.46225e+02), forces1[35], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.18701e+02,  1.96825e+01,  1.78171e+02), forces1[36], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.05936e+01, -1.32890e+02,  3.44742e+01), forces1[37], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.00952e+01, -2.04575e+02,  1.62082e+02), forces1[38], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.48119e+02, -5.51581e+01,  7.61226e+01), forces1[39], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.54706e+02, -7.79318e+01, -1.19613e+02), forces1[40], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.99297e+02,  1.36546e+02,  1.92910e+02), forces1[41], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.30607e+02,  9.45022e+01, -1.15484e+02), forces1[42], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.87492e+01,  3.38234e+01, -1.13593e+02), forces1[43], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.13434e+01,  1.75865e+02,  7.10201e+01), forces1[44], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.98165e+02, -1.81350e+02, -1.38226e+02), forces1[45], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.58294e+02, -1.74709e+02, -1.91109e+02), forces1[46], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.09248e+02, -1.57551e+02, -2.54299e+02), forces1[47], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.75881e+01, -1.06801e+02, -8.62635e+01), forces1[48], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.96592e+02, -1.56687e+01, -9.07580e+01), forces1[49], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.07471e+02, -1.59465e+02,  1.41495e+01), forces1[50], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.97824e+02, -1.58296e+01, -3.62499e+01), forces1[51], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.93794e+01,  2.56345e+01,  5.39562e+01), forces1[52], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.00946e+02,  1.34042e+02,  8.37801e+01), forces1[53], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.44101e+01,  1.04507e+02, -7.20338e+00), forces1[54], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.36940e+02,  1.45544e+02,  7.49711e+01), forces1[55], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.50152e+00,  2.02504e+02,  1.20796e+02), forces1[56], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.94096e+02, -4.04458e+01,  5.69722e+01), forces1[57], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.39977e+01, -1.51534e+02, -4.73434e+01), forces1[58], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.19892e+01, -9.31361e+01, -3.38910e+01), forces1[59], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.17884e+01,  1.00547e+02, -1.33243e+02), forces1[60], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.71112e+01,  6.21495e+01,  1.61566e+02), forces1[61], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.56825e+01,  6.35038e+01, -1.08713e+02), forces1[62], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.42227e+02,  2.10144e+02,  1.68761e+02), forces1[63], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.92938e+02, -1.15636e+02, -2.42672e+02), forces1[64], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.46946e+01,  1.75845e+02,  2.87636e+01), forces1[65], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.35161e+01, -3.00661e+01, -1.51624e+02), forces1[66], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.77087e+01,  1.55190e+02,  2.57432e+01), forces1[67], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.98358e+00, -2.76639e+02, -2.72293e+01), forces1[68], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.05003e+02,  1.07560e+02,  3.34506e+01), forces1[69], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.18245e+01, -1.75537e+01, -9.57309e+01), forces1[70], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.67253e+02,  5.59922e-01,  1.01207e+02), forces1[71], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.62670e+02, -6.88248e+01, -4.21201e+02), forces1[72], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.18113e+02, -5.78800e+01, -2.27353e+02), forces1[73], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.64922e+00,  9.21166e+01, -8.93683e+01), forces1[74], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.12201e+02, -3.27194e+01,  1.34264e+02), forces1[75], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.44131e+01, -7.40189e+01,  1.05403e+02), forces1[76], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.25775e+01, -1.36797e+02,  2.73836e+02), forces1[77], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.10304e+01,  7.16395e+01,  4.68672e+02), forces1[78], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.93444e+01, -2.15029e+02, -6.63119e+01), forces1[79], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.55389e+02, -3.73611e+02,  1.19751e+02), forces1[80], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.45909e+02, -1.24787e+02,  3.49148e+01), forces1[81], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.32739e+01,  2.95694e+02, -5.37526e+01), forces1[82], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.54390e+02,  4.53455e+02, -2.26764e+02), forces1[83], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.41532e+02,  4.99625e+01, -2.51478e+02), forces1[84], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.44295e+02,  3.25984e+02, -1.78338e+02), forces1[85], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.41100e+02,  7.63283e+01,  1.44488e+02), forces1[86], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.38640e+00,  2.32776e+02,  7.67636e+01), forces1[87], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.02516e+01,  2.34037e+02,  1.90372e+02), forces1[88], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.91986e+01,  6.06007e+01, -2.82869e+01), forces1[89], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.17690e+01,  2.95809e+02,  8.76127e+01), forces1[90], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.68695e+02,  3.01744e+02, -4.89279e+01), forces1[91], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.69699e+01, -8.28133e+01,  1.45608e+02), forces1[92], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.06525e+02, -1.67708e+02, -8.84405e+01), forces1[93], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.24225e+02, -2.54622e+02,  6.45408e+01), forces1[94], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.17139e+01,  8.98704e+01,  1.46449e+02), forces1[95], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.77809e+01, -7.22944e+00, -1.54716e+02), forces1[96], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.09684e+01, -7.69721e+01,  4.92171e+01), forces1[97], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.39983e+01, -1.04019e+01, -1.19765e+02), forces1[98], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.69240e+02, -4.03667e+02, -1.80224e+01), forces1[99], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.94854e+01,  1.06162e+02,  2.06747e+02), forces1[100], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.37669e+02,  1.53252e+02,  2.04131e+02), forces1[101], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.32814e+02,  6.44910e+01, -3.37777e+02), forces1[102], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.66103e+02,  8.69357e+01, -1.09283e+02), forces1[103], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.18540e+01,  6.11078e+01, -1.30500e+02), forces1[104], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.89128e+02, -2.65106e+02, -1.28996e+02), forces1[105], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.45378e+01, -3.81579e+02, -1.11586e+02), forces1[106], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.79366e+01, -2.27092e+02,  2.32158e+02), forces1[107], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.14303e+02,  1.21953e+02,  3.08605e+01), forces1[108], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.95355e+02,  2.38433e+02, -3.78260e+01), forces1[109], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.25306e+02, -5.62806e+01,  2.93849e+02), forces1[110], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.32541e+02,  1.53253e+02,  1.18339e+02), forces1[111], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.26061e+02,  1.22366e+02,  6.31712e+00), forces1[112], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.68565e+02,  9.40491e+01,  4.12643e+01), forces1[113], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.19917e+02, -1.43527e+02, -2.21682e+02), forces1[114], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.93757e+01,  9.98556e+01,  7.38225e+01), forces1[115], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.87240e+01, -7.40610e+01,  1.37672e+02), forces1[116], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.90455e+01, -9.52131e+01, -4.21601e+02), forces1[117], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.97078e+02,  2.45509e+02,  9.26765e+01), forces1[118], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.98206e+02,  1.14032e+02,  8.71204e+01), forces1[119], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.19803e+02,  1.82722e+01, -3.52888e+00), forces1[120], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.30623e+02,  7.51475e-01, -4.84435e+01), forces1[121], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.02126e+01,  5.55326e+01,  2.67927e+00), forces1[122], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.87364e+02,  1.76214e+02, -3.09445e+02), forces1[123], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.85190e+02, -1.63720e+02, -7.15048e+01), forces1[124], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.65174e+02, -1.33924e+02, -6.94217e+01), forces1[125], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.39913e+00,  2.52232e+01,  5.05709e+01), forces1[126], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.63349e+02,  9.56277e+01,  5.30812e+01), forces1[127], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.92027e+01, -9.44704e+01, -7.51200e+00), forces1[128], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.24094e+02,  7.38856e+01,  1.76005e+02), forces1[129], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.92944e+01,  3.02317e+02,  1.39375e+02), forces1[130], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.66291e+01,  1.41333e+02,  6.15473e+00), forces1[131], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.36178e+01, -1.58532e+01, -8.84526e+00), forces1[132], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.48146e+01, -3.41461e+01, -5.24216e+01), forces1[133], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.99809e+01,  1.02879e+01, -5.01739e+01), forces1[134], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.62285e+02, -4.90274e+01,  3.03601e+01), forces1[135], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.06458e+02, -3.96124e+01,  1.03454e+02), forces1[136], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.29243e+02,  6.18585e+01, -1.77272e+02), forces1[137], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.15853e+02,  2.19635e+02, -4.11751e+02), forces1[138], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.16425e+01,  8.23178e+01,  4.42405e+02), forces1[139], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.21858e+01,  4.82821e+01,  1.93947e+02), forces1[140], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.03450e+00,  2.30768e+01,  4.96796e+01), forces1[141], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.67572e+01,  7.23375e+01,  6.32957e+01), forces1[142], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.67345e+01,  1.26459e+01,  8.78382e+01), forces1[143], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.43687e+02,  1.76648e+01,  3.89767e+01), forces1[144], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.77056e+01, -9.46510e+01, -1.60263e+02), forces1[145], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.49800e+01, -2.68488e+01,  4.35106e+01), forces1[146], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.46710e+02, -5.25895e+01, -5.40524e+01), forces1[147], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.33729e+01, -4.69399e+01, -7.85015e+01), forces1[148], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.78265e+02,  3.19667e+00, -1.14997e+02), forces1[149], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.93773e+02,  7.50014e+01, -6.05331e+01), forces1[150], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.41372e+02,  1.04392e+02, -1.69148e+02), forces1[151], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.16023e+01, -7.84331e+00, -3.50072e+01), forces1[152], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.91752e+02, -8.75055e+01,  2.06764e+01), forces1[153], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.24104e+01,  2.55823e+02,  5.03937e+01), forces1[154], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.44493e+01, -1.88359e+02, -2.96664e+02), forces1[155], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.95569e+01, -1.48556e+02, -3.25981e+01), forces1[156], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.87067e+01, -3.24463e+01, -4.72036e+01), forces1[157], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.57426e+01, -4.76206e+01, -4.60343e+01), forces1[158], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.72900e+01,  5.41697e-01, -1.00543e+02), forces1[159], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.18469e+01, -6.73531e+00,  1.21198e+02), forces1[160], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.22925e+01, -1.12784e+01,  1.43764e+02), forces1[161], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.83447e+00, -1.45820e+01, -1.70105e+02), forces1[162], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.76068e+01, -7.28345e+00, -1.56973e+02), forces1[163], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.79090e+01, -1.92976e+02, -1.29871e+02), forces1[164], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.93110e+01, -1.12724e+02,  2.45046e+01), forces1[165], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.69833e+02, -9.82967e+01,  5.93923e+01), forces1[166], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.02085e+02,  9.27636e+00,  6.98988e+01), forces1[167], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.84338e+01,  1.41909e+02, -4.11691e+01), forces1[168], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.23626e+02, -1.04296e+02,  4.77490e+01), forces1[169], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.37003e+01,  4.13719e+01,  1.29790e+02), forces1[170], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.42874e+02, -8.32344e+01, -3.05737e+01), forces1[171], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.41293e+01,  7.66533e+01,  1.00918e+02), forces1[172], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.02752e+02, -3.11320e+01, -2.04248e+01), forces1[173], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.71192e+01, -3.13758e+02,  2.83511e+02), forces1[174], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.43170e+02,  1.60859e+02,  6.31587e+01), forces1[175], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.26734e+02,  1.91452e+02, -1.93402e+00), forces1[176], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.10931e+02, -1.64391e+01, -6.86948e+01), forces1[177], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.38600e+01,  2.32825e+02, -5.25593e+00), forces1[178], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.54520e+01, -1.88445e+02, -4.29131e+01), forces1[179], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.24785e+02, -1.05275e+02, -2.98944e+01), forces1[180], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.05063e+02, -6.53701e+01,  3.24520e+01), forces1[181], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.53521e+01, -9.04667e+01, -1.59980e+01), forces1[182], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.53764e+01, -3.04915e+01,  1.37888e+02), forces1[183], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.08932e+02, -9.35386e+01, -1.80955e+01), forces1[184], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.64566e+02, -1.70413e+02, -1.27317e+01), forces1[185], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.22672e+02, -3.22897e+02,  3.76674e+00), forces1[186], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.09547e+01,  3.37045e+02, -2.28878e+02), forces1[187], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.33946e+01, -1.01157e+02, -5.42970e+01), forces1[188], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.88672e+01,  2.85116e+01, -8.06985e-01), forces1[189], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.46034e+01,  1.78114e+02, -8.00020e+01), forces1[190], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.94640e+01, -7.09864e+01,  1.32544e+02), forces1[191], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.87772e+01,  8.20162e+01, -9.03433e+01), forces1[192], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.88680e+00,  8.72448e+01, -2.61573e+01), forces1[193], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.28593e+01,  2.51197e+00, -5.73722e+01), forces1[194], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.80417e+01, -7.37577e+01,  1.00134e+02), forces1[195], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.56974e+01,  6.72072e+00, -3.81539e+01), forces1[196], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.19232e+01, -3.54500e+01,  8.29318e+01), forces1[197], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.04113e+01, -4.41970e+01,  1.03326e+02), forces1[198], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.90881e+01, -1.12057e+02,  4.49403e+01), forces1[199], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.92007e+01,  3.55272e+01, -2.40127e+02), forces1[200], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.43562e+02,  6.23027e+02, -2.49264e+02), forces1[201], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.76198e+02, -3.02372e+02,  1.62332e+02), forces1[202], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.20299e+02, -2.27586e+02,  5.80333e+01), forces1[203], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.39488e+01, -1.07027e+00, -2.95203e+01), forces1[204], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.73263e+01, -1.08485e+02,  5.71183e+00), forces1[205], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.00039e+01, -2.49895e+02,  3.39192e+01), forces1[206], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.29623e+01,  1.32732e+02,  2.08741e+01), forces1[207], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.25554e+02, -1.56772e+01, -1.08164e+02), forces1[208], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.38717e+01,  1.52424e+01,  4.36131e+01), forces1[209], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.76367e+01,  1.13676e+02, -8.52759e+01), forces1[210], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.96298e+01, -9.30520e+01, -2.23851e+01), forces1[211], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.75027e+01,  1.64821e+02,  6.78676e+01), forces1[212], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.64028e+02,  3.12107e+01,  8.76753e+01), forces1[213], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.72632e+01,  5.28099e+01,  1.69700e+01), forces1[214], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.40135e+02, -7.08379e+01, -1.93293e+02), forces1[215], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.76562e+01,  2.29918e+02,  1.30609e+02), forces1[216], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.81640e+01, -2.90103e+02,  1.36757e+00), forces1[217], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.79291e+01, -2.93974e+02,  1.15436e+02), forces1[218], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.17338e+02,  1.11581e+02,  3.46029e+01), forces1[219], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.13346e+01,  3.15582e+01,  8.34550e+01), forces1[220], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.57677e+01,  1.77750e+01,  1.01067e+02), forces1[221], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.49827e+02,  8.44938e+01,  1.82793e+02), forces1[222], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.35999e+02, -1.89848e+02, -2.50760e+02), forces1[223], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.41970e+02, -1.87691e+02, -2.44756e+02), forces1[224], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.37302e+02,  8.71479e+01, -2.13793e+02), forces1[225], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.45010e+01,  2.44686e+02, -1.46416e+02), forces1[226], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.31020e+02,  1.28244e+02,  7.71140e+01), forces1[227], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.53744e+01,  1.29065e+02,  2.11056e+02), forces1[228], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.21924e+01,  9.95419e+00, -1.07719e+02), forces1[229], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.85756e+01,  9.52314e+01,  8.76358e+01), forces1[230], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.93957e+00,  1.53656e+02, -1.13339e+02), forces1[231], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.02172e+02,  8.87905e+01, -2.13701e+02), forces1[232], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.68099e+01,  1.91141e+02,  4.82221e+01), forces1[233], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.92679e+02, -2.47187e+02,  6.66851e+01), forces1[234], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.09980e+02, -1.43568e+02, -3.01739e+01), forces1[235], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.33167e+02, -3.32798e+02,  5.34600e+01), forces1[236], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.24223e+01,  9.76875e+00,  4.47725e+01), forces1[237], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.69405e+01, -8.41132e+01, -5.38952e+01), forces1[238], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.12010e+01,  1.44242e+01, -1.42070e+01), forces1[239], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.96477e+02, -4.50656e+02,  1.11329e+02), forces1[240], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.39163e+02,  1.76905e+02,  5.32392e+00), forces1[241], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.19746e+02,  1.76406e+02,  1.08727e+01), forces1[242], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.59625e+01,  1.08166e+01,  1.58314e+02), forces1[243], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.06176e+00,  1.91897e+01,  1.04092e+02), forces1[244], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.25838e+02, -4.67771e+00, -5.29138e+01), forces1[245], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.85855e+01,  1.78805e+01, -1.25884e+02), forces1[246], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.10798e+02,  9.15074e+01,  1.95780e+02), forces1[247], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.10572e+01, -1.48442e+02,  4.74169e+01), forces1[248], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.25479e+02,  2.55010e+01,  8.47576e+01), forces1[249], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.10701e+02, -6.73355e+01,  1.19913e+02), forces1[250], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.70376e+01, -6.37904e+00,  1.26145e+02), forces1[251], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.37588e+02,  1.02142e+02,  3.67769e+02), forces1[252], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.52584e+01, -7.07147e+01,  1.73165e+02), forces1[253], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.33450e+01, -2.18105e+02, -1.55636e+02), forces1[254], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.29365e+02,  7.78338e+01, -3.82730e+01), forces1[255], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.57375e+02, -6.66875e+01, -5.81031e+01), forces1[256], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.78245e+01, -1.40991e+01,  3.12933e+01), forces1[257], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.87648e+01,  2.74231e+02,  7.27232e+01), forces1[258], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.14936e+02,  1.20339e+01, -1.48413e+02), forces1[259], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.06217e+02, -3.13647e+01, -1.68616e+02), forces1[260], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.25106e+02, -2.60277e+02, -1.61136e+02), forces1[261], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.70346e+02, -9.32224e+00, -5.51717e+01), forces1[262], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.83465e+01, -2.28314e+02, -2.29566e+02), forces1[263], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.96075e+01,  1.48719e+02,  9.34688e+01), forces1[264], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.71370e+02,  1.70586e+02, -9.94963e+01), forces1[265], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.40521e+01, -1.08310e+02,  3.14259e+01), forces1[266], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.40452e+02, -2.41911e+02,  1.64059e+02), forces1[267], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.58929e+02, -1.31148e+02, -5.32733e+01), forces1[268], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.63751e+01, -2.73274e+02, -8.70685e+00), forces1[269], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.31634e+02,  2.19012e+02, -9.03802e+01), forces1[270], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.18020e+02, -1.92997e+01, -5.66165e+00), forces1[271], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.73518e+01, -3.11848e+01, -1.30020e+02), forces1[272], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.17466e+01, -3.68264e+02,  2.52209e+02), forces1[273], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.05037e+02, -1.84548e+02, -2.29593e+02), forces1[274], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.33053e+02, -1.07748e+02, -3.35660e+02), forces1[275], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.26641e+00, -2.78635e+00, -6.24895e+01), forces1[276], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.89712e+01, -4.30328e+01, -1.35221e+02), forces1[277], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.08792e+01,  8.56090e+01,  7.01326e+01), forces1[278], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.41320e+01,  1.50690e+02, -3.83537e+01), forces1[279], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.77423e+01,  7.38950e+01,  4.53469e+01), forces1[280], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.26780e+02,  1.02539e+02, -1.85815e+02), forces1[281], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.00799e+01,  1.14102e+02, -1.69102e+02), forces1[282], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.76513e+01,  8.40729e+01,  4.44592e+01), forces1[283], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.26467e+01,  5.77168e+01,  6.22600e+01), forces1[284], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.50347e+02,  3.61081e+02, -9.77920e+00), forces1[285], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.74580e+01, -5.17134e+01, -4.47767e+02), forces1[286], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.34437e+01, -3.97370e+02, -1.13442e+02), forces1[287], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.99880e+01,  2.09852e+02,  5.14899e+02), forces1[288], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.66190e+02, -2.26561e+02,  2.12404e+02), forces1[289], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.70999e+02, -2.62349e+02, -1.29205e+01), forces1[290], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.14337e+01,  5.49849e+01,  1.43268e+02), forces1[291], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.68620e+02,  3.93466e+00,  5.58857e+01), forces1[292], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.80270e+02, -1.13992e+01,  5.41069e+01), forces1[293], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.97739e+00,  1.29408e+02, -5.46560e+01), forces1[294], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.63236e+02, -1.28719e+02,  3.12749e+02), forces1[295], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.22808e+01,  1.12193e+02,  7.28319e+01), forces1[296], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.99596e+01,  2.53709e+02,  4.53500e+01), forces1[297], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.27720e+01,  8.59763e+01,  6.45557e+01), forces1[298], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.27058e+02,  1.22472e+01,  1.29561e+01), forces1[299], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.06664e+01, -9.58809e+01, -3.53582e+01), forces1[300], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.53970e+01,  5.12101e+01,  1.16686e+02), forces1[301], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.73120e+02, -1.27943e+02, -7.31003e+01), forces1[302], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.71294e+01,  2.17024e+02,  9.31014e+01), forces1[303], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.68161e+01, -1.85137e+02,  1.09745e+02), forces1[304], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.01521e+02,  5.92488e+00, -4.76997e+01), forces1[305], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.65074e+02, -7.65780e+01, -1.09596e+02), forces1[306], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.97306e+01,  3.84936e+01,  3.18940e+02), forces1[307], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.03733e+01, -3.14806e+01, -1.59317e+02), forces1[308], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.43092e+01, -1.29125e+02,  1.63512e+02), forces1[309], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.96060e+02,  5.77380e+01, -1.44479e+02), forces1[310], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.06352e+01,  5.46684e+00,  1.26620e+02), forces1[311], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.68377e+01,  1.94905e+02,  2.46429e+02), forces1[312], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.30349e+02,  9.49772e+01, -1.35362e+02), forces1[313], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.38512e+01,  6.40803e+01,  8.45394e+00), forces1[314], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.42175e+01, -1.59403e+00, -1.30405e+02), forces1[315], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.35848e+01, -4.54779e+00, -1.44903e+02), forces1[316], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.11989e+02, -1.18639e+01, -1.17828e+02), forces1[317], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.49970e+02,  6.35046e+01, -2.88805e+01), forces1[318], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.44126e+01, -6.56825e+01, -1.14100e+02), forces1[319], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.77255e+01, -3.66261e+01, -1.19649e+02), forces1[320], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.97007e+01,  1.88165e+01,  4.66627e+01), forces1[321], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.11016e+01,  1.60276e+01, -8.72109e+01), forces1[322], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.62297e+01,  1.86600e+02,  7.68552e+01), forces1[323], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.39138e+02,  2.21671e+02,  8.47440e+01), forces1[324], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.74277e+02, -6.06765e+01, -4.23965e+01), forces1[325], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.63159e+02, -6.13787e+01, -2.54964e+01), forces1[326], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.00529e+01, -6.56450e+01, -3.53408e+01), forces1[327], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.27153e+01, -9.16080e+01, -6.10037e+00), forces1[328], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.07795e+01, -6.31786e+01,  3.97424e+01), forces1[329], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.69043e+01,  2.05417e+02, -1.55673e+02), forces1[330], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.55098e+01,  6.25556e+01, -9.57571e+01), forces1[331], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.75174e+00, -7.00953e+01, -1.65779e+01), forces1[332], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.48906e+02, -9.37035e+01, -1.37237e+02), forces1[333], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.05834e+02, -1.77865e+02, -2.97998e+02), forces1[334], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.28005e+02, -1.09597e+02, -1.57769e+02), forces1[335], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.72019e+01, -2.11978e+02, -5.75568e+01), forces1[336], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.47436e+00, -2.09055e+01,  9.54998e+01), forces1[337], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.00282e+01, -1.18118e+02,  7.20331e+01), forces1[338], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.27051e+01,  3.88512e+01, -3.37338e+02), forces1[339], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.92361e+02,  4.97166e+01, -2.72135e+02), forces1[340], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.01809e+02,  3.12384e+01, -1.44869e+02), forces1[341], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.70524e+01,  6.01604e+01, -1.29958e+01), forces1[342], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.75977e+01, -6.85964e+01,  5.29205e+01), forces1[343], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.82625e+01,  5.36498e+01, -1.27179e+02), forces1[344], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.48158e+02,  1.18954e+01,  1.03589e+02), forces1[345], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.76540e+01,  8.31945e+01,  6.88425e-01), forces1[346], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.36393e+01,  5.97150e+00,  5.92665e+01), forces1[347], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.35596e+01, -3.45187e+01, -8.71186e+01), forces1[348], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.14736e+01,  1.99758e+01,  3.17942e+01), forces1[349], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.15299e+01, -6.78140e+01, -1.20761e+02), forces1[350], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.48161e+02,  1.61995e+02, -2.00364e+01), forces1[351], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.91715e+02,  4.15257e+01, -1.01480e+02), forces1[352], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.53537e+02,  2.47464e+01, -9.32184e+01), forces1[353], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.26331e+02, -1.50752e+02,  3.87836e+02), forces1[354], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.80549e+02, -1.04529e+02,  2.64609e+02), forces1[355], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.33299e+00, -1.04191e+02,  2.43081e+02), forces1[356], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.49417e+02, -2.10331e+02, -2.12391e+02), forces1[357], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.64496e+01, -8.65224e+01,  2.09075e+02), forces1[358], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.26786e+02, -1.04116e+02,  2.42460e+02), forces1[359], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.67930e+01,  5.02589e+01,  7.66782e+01), forces1[360], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.64137e+01, -5.87259e+01,  1.21975e+02), forces1[361], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.49708e+02, -5.25609e+01, -2.18329e+02), forces1[362], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.57850e+02,  5.04311e+02, -5.05894e+01), forces1[363], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.62212e+01, -2.94583e+02,  1.54045e+02), forces1[364], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.61638e+01, -1.84431e+02,  1.13710e+02), forces1[365], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.06173e+02,  9.36425e+01,  2.20592e+02), forces1[366], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.52623e+02,  1.46025e+02,  8.97291e+01), forces1[367], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.54323e+01,  2.26018e+02,  3.46087e+02), forces1[368], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.27183e+02, -2.09440e+01, -1.89634e+02), forces1[369], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.73506e+02,  2.01241e+02,  5.03574e+01), forces1[370], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.14771e+02,  1.73517e+02,  2.04777e+02), forces1[371], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.08803e+02, -4.69136e+01,  3.13410e+01), forces1[372], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.70333e+01, -9.14230e+01,  2.67645e+01), forces1[373], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.42054e+01, -1.04732e+02, -1.88134e+00), forces1[374], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.41157e+02, -1.07118e+02,  1.67297e+02), forces1[375], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.48356e+01, -8.47055e+01,  2.43285e+02), forces1[376], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.80449e+01, -1.46446e+02,  1.85386e+01), forces1[377], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.80687e+00, -6.96210e+01,  1.25177e+01), forces1[378], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.23687e+01, -9.93136e+01,  1.45164e+00), forces1[379], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.95215e+00,  1.37747e+01,  4.23959e+00), forces1[380], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.62211e+01,  5.78277e+02,  3.68049e+01), forces1[381], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.65270e+02, -1.15374e+02,  1.18132e+02), forces1[382], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.66667e+02, -8.49100e+01,  2.96994e+02), forces1[383], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.99785e+02,  2.24069e+02,  2.30458e+01), forces1[384], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.83662e+01,  2.02857e+01,  5.16795e+01), forces1[385], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.30910e+02, -2.01579e+02,  1.48973e+02), forces1[386], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.48803e+01, -2.39996e+02, -6.71369e+01), forces1[387], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.45565e+02, -2.03246e+02, -2.90114e+02), forces1[388], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.28809e+01,  1.07210e+02,  5.79218e+01), forces1[389], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.33045e+01,  4.29217e+01, -2.51884e+01), forces1[390], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.01216e+02,  7.87171e+01, -8.84528e+01), forces1[391], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.94984e+01, -1.82575e+00,  6.60948e+01), forces1[392], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.01760e+01,  1.13645e+02,  1.03720e+02), forces1[393], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.02227e+01, -1.82477e+02, -1.93295e+02), forces1[394], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.88739e+01, -7.04682e+01, -1.97902e+02), forces1[395], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.08208e+02,  2.04314e+02, -9.77061e+01), forces1[396], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.97001e+02, -3.37469e+01,  1.30428e+02), forces1[397], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.39859e+01,  1.55789e+02,  9.33634e+01), forces1[398], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.71075e+01,  1.01907e+02, -1.62363e+02), forces1[399], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.51477e+02, -1.49509e+02,  2.38020e+01), forces1[400], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.62232e+02,  1.06486e+02,  1.02031e+02), forces1[401], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.24938e+01,  1.19921e+02, -9.62759e+01), forces1[402], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.56992e+01, -1.10020e+02,  1.49108e+02), forces1[403], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.10656e+01,  2.79604e+01,  1.91755e+02), forces1[404], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.74338e+00, -7.08051e+01, -1.05929e+02), forces1[405], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.64700e+02, -1.27130e+02, -5.91595e+01), forces1[406], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.30385e+01,  2.08802e+01, -3.57840e+01), forces1[407], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.08287e+02,  2.29771e+01, -2.26233e+02), forces1[408], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.58650e+02, -1.14832e+02, -1.67121e+02), forces1[409], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.19177e+02,  9.05557e+01,  3.00496e+02), forces1[410], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.59854e+01, -1.24855e+02,  1.73507e+02), forces1[411], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.01537e+02, -3.21500e+01, -1.62947e+02), forces1[412], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.68513e+01,  7.25403e+01,  1.10509e+02), forces1[413], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.74676e+01,  1.99661e+02, -3.30448e+02), forces1[414], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.89877e+02, -5.06918e+01,  2.07261e+02), forces1[415], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.05311e+01,  7.99589e+01, -9.81659e+01), forces1[416], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.19039e+02,  7.86478e+01, -1.36094e+02), forces1[417], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.39276e+01,  1.04302e+02, -1.99319e+02), forces1[418], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.07836e+01, -7.02154e+01, -3.20077e+01), forces1[419], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.04021e+01, -2.95668e+01, -9.62964e+01), forces1[420], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.13789e+01,  2.11057e+01, -7.24998e+01), forces1[421], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.89102e+01, -6.59244e+01, -8.40365e+01), forces1[422], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.19672e+02, -4.01191e+01,  6.57098e+01), forces1[423], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.87553e+01, -8.69171e+01,  2.43178e+01), forces1[424], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.67881e+01, -1.94017e+02,  4.85473e+01), forces1[425], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.07150e+02, -1.99734e+02, -2.09862e+01), forces1[426], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.36179e+02,  1.95193e+01, -1.32315e+02), forces1[427], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.23323e+02, -6.31094e+01, -8.32846e+01), forces1[428], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.02495e+00, -1.45980e+02,  5.02494e+02), forces1[429], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.25222e+01,  1.02561e+02,  1.77325e+01), forces1[430], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.12695e+02,  3.15051e+02, -4.46404e+01), forces1[431], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.92031e+02, -9.89024e+01, -3.74688e+02), forces1[432], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.43199e+01,  7.50213e+01,  1.10375e+02), forces1[433], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.10558e+01,  2.43859e+02,  5.47498e+01), forces1[434], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.97703e+01, -1.48364e+02, -1.17638e+02), forces1[435], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.62397e+01,  4.88941e+01, -2.71595e+02), forces1[436], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.31340e+01, -8.20624e+01,  1.16191e+02), forces1[437], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.38517e+02, -7.62394e+01, -5.88168e+00), forces1[438], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.62851e+01,  6.72427e+01, -1.80434e+01), forces1[439], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.58861e+02,  1.15957e+02, -3.78160e+01), forces1[440], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.51803e+02, -4.12446e+01, -8.91525e+01), forces1[441], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.61287e+01, -1.36689e+02, -9.23537e+00), forces1[442], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.82943e+02,  1.05844e+02, -1.72148e+02), forces1[443], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.55236e+01,  9.18378e+01,  1.24360e+01), forces1[444], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.01227e+01,  8.39026e+01,  3.96741e+02), forces1[445], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.87558e+01,  5.47395e+01, -5.73402e+00), forces1[446], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.60796e+02, -5.52985e+01,  3.17802e+01), forces1[447], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.11619e+02,  1.11090e+02,  1.51495e+02), forces1[448], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.78213e+01, -1.33902e+02,  1.13590e+02), forces1[449], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.74607e+02, -2.79326e+02, -1.00171e+02), forces1[450], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.47808e+01, -1.29366e+02, -1.92232e+02), forces1[451], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.75509e+00,  1.63688e+01, -3.24829e+02), forces1[452], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.93082e+01, -2.44679e+02,  7.91941e+01), forces1[453], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.41263e+01,  9.35389e+01,  9.69223e+01), forces1[454], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.76713e+02,  1.98982e+02,  2.68113e+01), forces1[455], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.79544e+01,  6.96513e+01, -1.90320e+02), forces1[456], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.34104e+02,  2.74828e+01, -3.93803e+01), forces1[457], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.28254e+02, -1.35572e+02, -4.32733e+01), forces1[458], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.28600e+01,  3.07094e+00, -3.78996e+01), forces1[459], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.03587e+02,  1.77989e+02, -6.99490e+01), forces1[460], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.08656e+02, -4.54770e+01, -6.76500e+01), forces1[461], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.71838e+01,  5.19782e+01, -2.94923e+01), forces1[462], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.40301e+02,  2.74572e+02, -3.56579e+01), forces1[463], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.03587e+01, -3.16257e+01, -7.72873e+01), forces1[464], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.67138e+02, -7.24846e+01, -6.24143e+01), forces1[465], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.03813e+00,  9.49458e+01,  3.72519e+01), forces1[466], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.14010e+01,  6.47582e+01,  1.42218e+02), forces1[467], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.20325e+01,  1.99039e+02,  3.65580e+02), forces1[468], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.42970e+02, -8.88587e+01,  1.72171e+02), forces1[469], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.90803e+01, -2.60758e+02,  1.15577e+02), forces1[470], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.52557e+02, -8.51485e+00, -1.82612e+02), forces1[471], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 5.19978e+00,  1.82368e+02,  4.96817e+01), forces1[472], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.60405e+02, -5.75249e+01,  4.30526e+01), forces1[473], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.05782e+01, -1.01381e+02,  5.21152e+01), forces1[474], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.98251e-01,  1.60005e+02,  2.94808e+01), forces1[475], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.38812e+02, -2.31535e+02,  1.88049e+02), forces1[476], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.81939e+01,  1.28753e+02, -1.67824e+02), forces1[477], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.23875e+02,  1.55757e+02, -2.79290e+02), forces1[478], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.68146e+01,  8.00636e+01,  1.82356e+00), forces1[479], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.81555e+02, -2.44338e+02, -1.67866e+02), forces1[480], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.60882e+02,  1.64545e+02,  1.24397e+02), forces1[481], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.43347e+02,  1.22527e+02,  2.15375e+02), forces1[482], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.75592e+02, -3.02264e+02,  3.12921e+02), forces1[483], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.42347e+02,  1.64524e+02,  1.46878e+02), forces1[484], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.44791e+00,  6.90323e+01, -3.86573e+01), forces1[485], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.00184e+02, -1.07891e+02,  3.14068e+01), forces1[486], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.40711e+01,  1.27511e+01,  5.66277e+01), forces1[487], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.74580e+02, -1.14306e+02, -1.37535e+02), forces1[488], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.98657e+01,  2.19658e+02, -7.96343e+01), forces1[489], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.90069e+02,  1.36943e+02, -1.78217e+02), forces1[490], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.64334e+01,  2.56388e+02, -8.52711e+01), forces1[491], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.38510e+01, -1.61329e+02,  2.59550e+02), forces1[492], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-8.11033e+01, -7.18533e+01,  7.75259e+00), forces1[493], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.05854e+02,  3.14397e+02, -4.61488e+02), forces1[494], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.69218e+02,  1.76533e+02,  2.08605e+02), forces1[495], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.06655e+01, -6.09886e+02, -6.99069e+01), forces1[496], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.19305e+02, -1.88157e+02,  1.20294e+02), forces1[497], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.74817e+01, -1.67738e+01, -7.85411e+00), forces1[498], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.56252e+00, -4.35681e+01, -6.24241e+01), forces1[499], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.73399e+01,  1.15493e+02,  9.92190e+01), forces1[500], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.58626e+01,  9.15080e+01,  3.20924e+00), forces1[501], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.09582e+01, -1.76054e+01,  6.71996e+00), forces1[502], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.59525e+01,  1.83369e+02, -1.70381e+02), forces1[503], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.32243e+01,  3.37044e+01, -6.27663e+01), forces1[504], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.91590e+01, -5.93696e+01, -7.26003e+01), forces1[505], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.74042e+00,  7.24544e+01,  5.83752e+01), forces1[506], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.35769e+01,  4.35961e+02,  7.54309e+01), forces1[507], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.81578e+02, -1.82955e+02, -1.36110e+02), forces1[508], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.53200e+02, -2.25646e+01, -1.26235e+02), forces1[509], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.02017e+01,  7.54878e+01, -9.98370e+01), forces1[510], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.56935e+01,  7.19882e+00, -3.07487e+02), forces1[511], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.60290e+01,  4.63810e+01, -1.39429e+02), forces1[512], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.36883e+02, -2.71943e+02,  1.90138e+01), forces1[513], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.95573e+01, -1.31976e+02, -1.48737e+02), forces1[514], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.61876e+02,  1.02997e+02, -1.00309e+02), forces1[515], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.73595e+00,  3.79678e+01,  9.45418e+01), forces1[516], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.60218e+00, -7.40917e+01, -2.21371e+01), forces1[517], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.27199e+02,  1.31094e+02,  1.12529e+02), forces1[518], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.04103e+02,  4.69682e+01, -1.18068e+02), forces1[519], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.12794e+01, -1.26833e+02, -4.04741e+01), forces1[520], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.09384e+01,  1.86161e+02,  3.95213e+01), forces1[521], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.91470e+02,  8.17955e+01, -9.25509e+01), forces1[522], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.33121e+01,  7.77548e-01, -1.48384e+02), forces1[523], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.52149e+02, -1.00219e+02, -7.57906e+01), forces1[524], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.46003e+02, -1.03331e+01,  1.17347e+01), forces1[525], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.09634e+00,  1.43847e+02, -1.42581e+02), forces1[526], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.68641e+02,  6.25042e+01, -7.01507e+01), forces1[527], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.49802e+01,  2.37203e+02, -2.40370e+02), forces1[528], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.85669e+01, -1.41784e+02,  4.28138e+01), forces1[529], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.75729e+01, -3.33632e+02,  1.31688e+02), forces1[530], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.04035e+02,  1.12452e+02,  7.19995e+01), forces1[531], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.61972e+00,  5.32166e+01, -9.89477e+01), forces1[532], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.19982e+01, -2.20164e+02,  9.06987e-01), forces1[533], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.71185e+01, -7.67379e+01,  8.12237e+01), forces1[534], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.80057e+01, -1.09793e+02, -2.04253e+01), forces1[535], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.16821e+02,  1.20240e+02,  5.96457e+01), forces1[536], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.64018e+01,  6.17819e+01,  9.91575e+01), forces1[537], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.55515e+01, -9.66187e+01, -8.19956e+00), forces1[538], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.17947e+01, -1.53378e+01,  1.27485e+00), forces1[539], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.02055e+02,  7.70776e+01,  1.14883e+02), forces1[540], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.43124e+01,  9.43473e+01,  8.60578e+01), forces1[541], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.81264e+01, -1.32125e+02,  2.56224e+01), forces1[542], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.25842e+01, -1.26725e+02, -8.30650e+01), forces1[543], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.50125e+01, -6.20165e+01,  2.58080e+01), forces1[544], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.55319e+01, -1.59769e+01, -7.15921e+01), forces1[545], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.34804e+01,  4.08590e+02, -8.70023e+01), forces1[546], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.53654e+01, -2.03185e+02, -4.39618e+01), forces1[547], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.62931e+01, -2.78936e+02,  5.62579e+00), forces1[548], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.92745e+01, -9.69829e+01, -3.54599e+01), forces1[549], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.58047e+01, -8.17034e+01,  5.89773e+01), forces1[550], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.75002e+01, -7.94191e+01,  7.55542e+01), forces1[551], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-9.53611e+01,  1.20621e+02,  1.49809e+02), forces1[552], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.63438e+01, -6.24402e+01, -1.12122e+01), forces1[553], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.11429e+02, -4.56045e+01, -4.59567e+01), forces1[554], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.28516e+02, -4.47595e+00,  1.81453e+02), forces1[555], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.33297e+02,  1.44805e+02, -4.27640e+01), forces1[556], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.16740e+02, -7.65847e+00,  7.66024e+01), forces1[557], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.77942e+02, -1.45939e+02,  8.07326e+01), forces1[558], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.68632e+02,  2.69537e+02,  1.22007e+02), forces1[559], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.12709e+02,  6.01408e+01,  1.54041e+02), forces1[560], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.27652e+02, -5.25610e+01, -9.60596e+01), forces1[561], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.14047e+02, -2.01466e+01, -4.96293e+01), forces1[562], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.09791e+02,  4.12161e+01,  1.83442e+02), forces1[563], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.49134e+02, -4.62596e+00,  2.20999e+01), forces1[564], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.30637e+02, -3.75250e+01,  4.14259e+01), forces1[565], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.75025e+02,  3.85962e+01,  5.80226e+01), forces1[566], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.98389e+00, -1.23933e+02,  1.30628e+02), forces1[567], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.05449e+01, -1.14065e+02,  9.70791e+01), forces1[568], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.60462e+01, -9.53328e+01,  9.89856e+01), forces1[569], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.13288e+01, -1.44056e+01,  1.39952e+02), forces1[570], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.42917e+01,  1.66166e+01,  1.91947e+02), forces1[571], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.13590e+02, -1.55874e+02, -1.13269e+02), forces1[572], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.42809e+02,  3.88945e+02,  1.47303e+02), forces1[573], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.29792e+02, -1.91594e+02, -4.64513e+01), forces1[574], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.06517e+02, -3.17549e+02,  9.06953e+00), forces1[575], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.35062e+02, -3.38933e+01, -9.66009e+01), forces1[576], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.67609e+02,  1.26402e+02, -4.97788e+01), forces1[577], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.05138e+00,  1.07362e+02, -1.02375e+02), forces1[578], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.22771e+02, -7.72250e+01,  1.66501e+02), forces1[579], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.95650e+01,  8.12102e+00,  1.03117e+02), forces1[580], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.75584e+02,  2.88991e+01, -1.17320e+02), forces1[581], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-6.91275e+01,  8.38319e+01,  4.97708e+01), forces1[582], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.51951e+02,  1.60368e+02, -2.06266e+02), forces1[583], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.31889e+01, -2.02781e+02, -8.72161e+01), forces1[584], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.92408e+02, -1.87100e+01,  2.05541e+02), forces1[585], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.73554e+02, -5.01580e+00,  2.66621e+02), forces1[586], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.59561e+02,  9.15584e+00,  1.28235e+02), forces1[587], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.11016e+01,  7.42097e+01, -4.28122e+01), forces1[588], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.03537e+02,  2.10837e+01, -1.33908e+02), forces1[589], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.16906e+01, -1.58535e+01,  4.67992e+01), forces1[590], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.44325e+02, -2.46328e+00, -1.81854e+01), forces1[591], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-5.30320e+01,  9.72891e+01,  2.06240e+01), forces1[592], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.36896e+01,  1.33852e+02,  5.19553e+01), forces1[593], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 9.50875e+00, -1.63962e+02, -7.41674e+01), forces1[594], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.07601e+02, -8.54691e+01,  3.11595e+01), forces1[595], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.65770e+02, -4.64405e+01,  8.34911e+01), forces1[596], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.44367e+01, -1.84108e+02,  1.39835e+02), forces1[597], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.24114e+02,  2.50886e+01,  2.54009e+01), forces1[598], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.16187e+02, -4.85179e+01,  1.32305e+02), forces1[599], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.37446e+01, -3.29674e+01,  1.16326e+02), forces1[600], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.68011e+01, -1.00073e+02,  8.04682e+01), forces1[601], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-4.83294e+01, -1.73859e+02,  1.36328e+01), forces1[602], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.83292e+01,  1.39303e+02, -1.01045e+02), forces1[603], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.07133e+01,  1.29633e+02, -1.90943e+02), forces1[604], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.55543e+02,  7.87557e+01,  9.29806e+01), forces1[605], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.64013e+02, -2.60759e+01,  1.75076e+02), forces1[606], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.33794e+02, -1.63774e+02, -6.37393e+01), forces1[607], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.54235e+02,  2.41512e+02,  1.60676e+02), forces1[608], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.17775e+02,  6.48107e+01,  3.84545e+01), forces1[609], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.04735e+01,  2.01260e+01,  2.39831e+01), forces1[610], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.38884e+02,  1.20777e+02, -5.46490e+01), forces1[611], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.07723e+02,  2.58444e+02,  1.48247e+02), forces1[612], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.01470e+02, -6.94941e+01, -2.70882e+02), forces1[613], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.21667e+01, -1.98769e+02, -1.54892e+02), forces1[614], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.80724e+02,  4.52486e+01,  1.40398e+02), forces1[615], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 3.86820e+02, -7.75719e+00, -1.08164e+01), forces1[616], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.42790e+02,  4.80985e+01, -6.18837e+00), forces1[617], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.76946e+02, -1.97796e+02,  2.44731e+01), forces1[618], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.47411e+02,  2.23512e+02, -4.11150e+01), forces1[619], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.04834e+01,  5.22527e+01, -2.27808e+01), forces1[620], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.52307e+02,  7.40937e+01,  1.12984e+02), forces1[621], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.32953e+01, -1.29608e+02,  1.32966e+02), forces1[622], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.23861e+01, -1.19511e+02,  1.00268e+02), forces1[623], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.50610e+01, -1.46388e+02, -7.77507e+01), forces1[624], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 8.62300e+01, -1.37666e+02, -1.20764e+02), forces1[625], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.47310e+01, -1.47118e+02, -5.18370e+01), forces1[626], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.62932e+01,  7.13690e+01,  1.43985e+02), forces1[627], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.96823e+01, -3.58054e+01, -1.45690e+02), forces1[628], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.18087e+00,  1.85480e+01,  9.50527e+01), forces1[629], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.74362e+00,  1.43052e+01, -4.25871e+01), forces1[630], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.97525e+02, -1.59562e+01,  1.90143e+01), forces1[631], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 2.57292e+01, -2.08667e+02,  2.11507e+01), forces1[632], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.01669e+01, -1.07214e+02, -2.53008e+01), forces1[633], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.18560e+02,  4.41674e+01, -1.78058e+02), forces1[634], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.93301e+00,  5.90508e+01, -3.94824e+01), forces1[635], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-7.81815e+01,  8.73784e+01, -6.35956e+01), forces1[636], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.52356e+01,  1.30136e+02,  1.52025e+01), forces1[637], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.66178e+02, -5.94385e+01, -1.04578e+02), forces1[638], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-1.19123e+02, -1.75069e+02, -2.04114e+00), forces1[639], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-3.92283e+01,  5.61702e+01,  1.27395e+02), forces1[640], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 4.74836e-01, -2.04058e+02, -4.01525e+01), forces1[641], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 6.92669e+01,  6.04519e+00,  4.03163e+01), forces1[642], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.08236e+01,  1.26554e+02, -8.63729e+01), forces1[643], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.88180e+02, -1.08833e+02, -1.18964e+02), forces1[644], 10*TOL);
ASSERT_EQUAL_VEC(Vec3(-2.76077e+01, -2.97113e+02,  5.08198e+02), forces1[645], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 1.84023e+02,  3.56521e+02, -2.17616e+02), forces1[646], 10*TOL);
ASSERT_EQUAL_VEC(Vec3( 7.81607e+01,  3.17356e+02, -1.40920e+02), forces1[647], 10*TOL);