TOL = 0.0001;

# 5
assert(isequalRel(angl([3.174831375214e+04,-6.759905608809e+03,0.000000000000e+00], [1.470332017858e-01,-1.028819629235e-01,-4.769774163569e-02]), 4.737313256142e-01, TOL));
assert(isequalRel(angl([1.470332017858e-01,-1.028819629235e-01,-4.769774163569e-02], [-7.154031202016e+03,-3.783176825037e+03,-3.536194122942e+03]), 1.876783526044e+00, TOL));
assert(isequalRel(angl([3.165757807411e+04,-7.210006083282e+03,0.000000000000e+00], [1.477757725114e-01,-1.018994158828e-01,-4.534383465850e-02]), 4.499442809171e-01, TOL));
assert(isequalRel(angl([1.477757725114e-01,-1.018994158828e-01,-4.534383465850e-02], [-7.134593401193e+03,6.531686413336e+03,3.260271864826e+03]), 2.988460057544e+00, TOL));
assert(isequalRel(angl([3.154828815793e+04,-7.606448489529e+03,0.000000000000e+00], [1.490913922398e-01,-1.017648402534e-01,-4.358655528256e-02]), 4.300433538622e-01, TOL));
assert(isequalRel(angl([1.490913922398e-01,-1.017648402534e-01,-4.358655528256e-02], [5.568539011812e+03,4.492069925906e+03,3.863876419829e+03]), 1.434828952104e+00, TOL));
assert(isequalRel(angl([3.143119696339e+04,-8.038840260060e+03,0.000000000000e+00], [1.496038320603e-01,-1.018779782354e-01,-4.197237703074e-02]), 4.129602097658e-01, TOL));
assert(isequalRel(angl([1.496038320603e-01,-1.018779782354e-01,-4.197237703074e-02], [-9.385592394293e+02,-6.268187488314e+03,-4.294029247512e+03]), 1.073633739092e+00, TOL));
assert(isequalRel(angl([3.135496041382e+04,-8.466297455444e+03,0.000000000000e+00], [1.496651358184e-01,-1.012274726151e-01,-4.002257451669e-02]), 3.940786413426e-01, TOL));
assert(isequalRel(angl([1.496651358184e-01,-1.012274726151e-01,-4.002257451669e-02], [-9.680561217281e+03,2.802477713539e+03,1.241068803824e+02]), 2.769377512716e+00, TOL));
assert(isequalRel(angl([3.120755626309e+04,-8.881030791325e+03,0.000000000000e+00], [1.511297840938e-01,-1.009109357845e-01,-3.792829449608e-02]), 3.714461014458e-01, TOL));
assert(isequalRel(angl([1.511297840938e-01,-1.009109357845e-01,-3.792829449608e-02], [1.901979698785e+02,7.746966536135e+03,5.110006754119e+03]), 2.152516069731e+00, TOL));
assert(isequalRel(angl([3.110448405293e+04,-9.307389190732e+03,0.000000000000e+00], [1.521806609393e-01,-1.012019008332e-01,-3.634713123269e-02]), 3.536718901352e-01, TOL));
assert(isequalRel(angl([1.521806609393e-01,-1.012019008332e-01,-3.634713123269e-02], [5.579556401157e+03,-3.995613967894e+03,-1.518821089660e+03]), 4.010620775949e-02, TOL));
assert(isequalRel(angl([3.098245684179e+04,-9.702437311581e+03,0.000000000000e+00], [1.519464629973e-01,-1.007113912914e-01,-3.454973845057e-02]), 3.370203424465e-01, TOL));
assert(isequalRel(angl([1.519464629973e-01,-1.007113912914e-01,-3.454973845057e-02], [-8.650730822189e+03,-1.914938115252e+03,-3.007036034428e+03]), 2.197202902189e+00, TOL));
assert(isequalRel(angl([3.084001407454e+04,-1.013882352195e+04,0.000000000000e+00], [1.528523552560e-01,-9.977878002889e-02,-3.205917156497e-02]), 3.122540786209e-01, TOL));
assert(isequalRel(angl([1.528523552560e-01,-9.977878002889e-02,-3.205917156497e-02], [-5.429792041645e+03,7.574364937924e+03,3.747393052359e+03]), 2.729639278624e+00, TOL));
assert(isequalRel(angl([3.070576615370e+04,-1.052532391487e+04,0.000000000000e+00], [1.540635448346e-01,-9.968762860258e-02,-3.021607909642e-02]), 2.927010889374e-01, TOL));
assert(isequalRel(angl([1.540635448346e-01,-9.968762860258e-02,-3.021607909642e-02], [6.759045837218e+03,2.001581982197e+03,2.783551925329e+03]), 1.003249486494e+00, TOL));
assert(isequalRel(angl([3.054534855940e+04,-1.093732661806e+04,0.000000000000e+00], [1.541937335332e-01,-9.975199109290e-02,-2.855813573644e-02]), 2.764868690346e-01, TOL));
assert(isequalRel(angl([1.541937335332e-01,-9.975199109290e-02,-2.855813573644e-02], [-3.791445315589e+03,-5.712956178939e+03,-4.533486307144e+03]), 1.495625366016e+00, TOL));
assert(isequalRel(angl([3.042387178341e+04,-1.136453377928e+04,0.000000000000e+00], [1.541902876953e-01,-9.891158179440e-02,-2.638216977878e-02]), 2.558627463958e-01, TOL));
assert(isequalRel(angl([1.541902876953e-01,-9.891158179440e-02,-2.638216977878e-02], [-9.060473735694e+03,4.658709525023e+03,8.136867315342e+02]), 3.027553295387e+00, TOL));

# 4632
assert(isequalRel(angl([1.367322093623e+03,-2.394645248230e+04,0.000000000000e+00], [-7.286158373818e-02,1.252774706993e-01,-1.329796741084e-02]), 2.663673488840e+00, TOL));
assert(isequalRel(angl([-7.286158373818e-02,1.252774706993e-01,-1.329796741084e-02], [-2.902002587128e+04,1.381984419063e+04,-5.713336791827e+03]), 5.998398344535e-01, TOL));
assert(isequalRel(angl([1.365660697880e+03,-2.394622554326e+04,0.000000000000e+00], [-7.289133750054e-02,1.252324854180e-01,-1.330607463274e-02]), 2.663266818797e+00, TOL));
assert(isequalRel(angl([-7.289133750054e-02,1.252324854180e-01,-1.330607463274e-02], [-3.298256870101e+04,-1.112554996609e+04,-6.803284727715e+03]), 1.355729535740e+00, TOL));
assert(isequalRel(angl([1.364529647374e+03,-2.394680603025e+04,0.000000000000e+00], [-7.288220360952e-02,1.252052221000e-01,-1.330603371441e-02]), 2.663176867084e+00, TOL));
assert(isequalRel(angl([-7.288220360952e-02,1.252052221000e-01,-1.330603371441e-02], [-2.209768730513e+04,-3.158313829284e+04,-4.836343293282e+03]), 1.985943404750e+00, TOL));
assert(isequalRel(angl([1.364297654000e+03,-2.394700187875e+04,0.000000000000e+00], [-7.287478730715e-02,1.251972760380e-01,-1.330496836385e-02]), 2.663183377731e+00, TOL));
assert(isequalRel(angl([-7.287478730715e-02,1.251972760380e-01,-1.330496836385e-02], [-1.512994694545e+04,-3.690774526221e+04,-3.487562567009e+03]), 2.209343273602e+00, TOL));

# 6251
assert(isequalRel(angl([2.610792421310e+04,3.550895329696e+04,0.000000000000e+00], [-2.015502384249e-03,-8.077256286917e-04,1.835992968696e-03]), 2.276713783656e+00, TOL));
assert(isequalRel(angl([-2.015502384249e-03,-8.077256286917e-04,1.835992968696e-03], [-3.935698000834e+03,4.091098083655e+02,5.471335773274e+03]), 4.049329027980e-01, TOL));
assert(isequalRel(angl([2.632951709870e+04,3.539120088956e+04,0.000000000000e+00], [-2.410778864960e-03,-1.007929928336e-03,2.137932170463e-03]), 2.299284146150e+00, TOL));
assert(isequalRel(angl([-2.410778864960e-03,-1.007929928336e-03,2.137932170463e-03], [-1.675127669149e+03,-5.683304323518e+03,-3.286215109367e+03]), 1.450679689026e+00, TOL));
assert(isequalRel(angl([2.657171950316e+04,3.520471404079e+04,0.000000000000e+00], [-2.554594279147e-03,-1.124512662307e-03,2.184177665233e-03]), 2.328804938236e+00, TOL));
assert(isequalRel(angl([-2.554594279147e-03,-1.124512662307e-03,2.184177665233e-03], [4.993626428356e+03,2.890549699000e+03,-3.600401456269e+03]), 3.002427578463e+00, TOL));
assert(isequalRel(angl([2.674911494764e+04,3.503241601698e+04,0.000000000000e+00], [-2.649762028715e-03,-1.480784274042e-03,1.935561835743e-03]), 2.455296543895e+00, TOL));
assert(isequalRel(angl([-2.649762028715e-03,-1.480784274042e-03,1.935561835743e-03], [-1.115079595139e+03,4.015116914910e+03,5.326997277178e+03]), 1.265436204127e+00, TOL));
assert(isequalRel(angl([2.701014529653e+04,3.490028327778e+04,0.000000000000e+00], [-3.099949914297e-03,-1.433261101010e-03,2.526899418164e-03]), 2.365109240047e+00, TOL));
assert(isequalRel(angl([-3.099949914297e-03,-1.433261101010e-03,2.526899418164e-03], [-4.329100081975e+03,-5.176702879352e+03,4.096531385745e+02]), 7.050316851707e-01, TOL));
assert(isequalRel(angl([2.719283803223e+04,3.468184350736e+04,0.000000000000e+00], [-3.173594198433e-03,-8.693834586689e-04,3.143330901252e-03]), 2.190327393900e+00, TOL));
assert(isequalRel(angl([-3.173594198433e-03,-8.693834586689e-04,3.143330901252e-03], [3.692600300280e+03,-9.762426525530e+02,-5.623364474929e+03]), 2.746082539211e+00, TOL));
assert(isequalRel(angl([2.741855371072e+04,3.456134807609e+04,0.000000000000e+00], [-2.700815536461e-03,-6.083291614930e-04,2.788323891138e-03]), 2.151344297421e+00, TOL));
assert(isequalRel(angl([-2.700815536461e-03,-6.083291614930e-04,2.788323891138e-03], [2.301835100373e+03,5.723923945532e+03,2.814615145803e+03]), 1.640313958266e+00, TOL));
assert(isequalRel(angl([2.764746435300e+04,3.435984601281e+04,0.000000000000e+00], [-2.536651343318e-03,-5.633694719509e-04,2.603520838967e-03]), 2.155131113255e+00, TOL));
assert(isequalRel(angl([-2.536651343318e-03,-5.633694719509e-04,2.603520838967e-03], [-4.990916379503e+03,-2.303425478800e+03,3.920863355985e+03]), 2.327986184503e-01, TOL));
assert(isequalRel(angl([2.782308314924e+04,3.418975611381e+04,0.000000000000e+00], [-2.488746470506e-03,-2.750790915316e-04,2.816396377913e-03]), 2.064011444385e+00, TOL));
assert(isequalRel(angl([-2.488746470506e-03,-2.750790915316e-04,2.816396377913e-03], [6.422776997684e+02,-4.332898219009e+03,-5.183315239096e+03]), 2.197801244803e+00, TOL));
assert(isequalRel(angl([2.808054742180e+04,3.404311697244e+04,0.000000000000e+00], [-2.115227322536e-03,-3.845387045003e-04,2.226275687427e-03]), 2.130274502983e+00, TOL));
assert(isequalRel(angl([-2.115227322536e-03,-3.845387045003e-04,2.226275687427e-03], [4.719783357520e+03,4.798069389959e+03,-9.435885106242e+02]), 2.294596706667e+00, TOL));
assert(isequalRel(angl([2.825152741641e+04,3.382243144019e+04,0.000000000000e+00], [-2.125814221434e-03,-9.640136813773e-04,1.624504464483e-03]), 2.402935600108e+00, TOL));
assert(isequalRel(angl([-2.125814221434e-03,-9.640136813773e-04,1.624504464483e-03], [-3.299169936023e+03,1.576831683195e+03,5.678678406385e+03]), 6.977716075306e-01, TOL));
assert(isequalRel(angl([2.848007480671e+04,3.369650068023e+04,0.000000000000e+00], [-2.652838972366e-03,-1.164164781512e-03,2.045333941427e-03]), 2.394405349129e+00, TOL));
assert(isequalRel(angl([-2.652838972366e-03,-1.164164781512e-03,2.045333941427e-03], [-2.777146823355e+03,-5.663160317077e+03,-2.462548891232e+03]), 1.190045223729e+00, TOL));
assert(isequalRel(angl([2.869581587908e+04,3.348213076492e+04,0.000000000000e+00], [-2.877296428411e-03,-1.119497424324e-03,2.335472533367e-03]), 2.350745170702e+00, TOL));
assert(isequalRel(angl([-2.877296428411e-03,-1.119497424324e-03,2.335472533367e-03], [4.992315738931e+03,1.716623567695e+03,-4.287860655812e+03]), 3.094940341490e+00, TOL));
assert(isequalRel(angl([2.887164855349e+04,3.331572670756e+04,0.000000000000e+00], [-2.892420268796e-03,-1.279455956781e-03,2.161254870600e-03]), 2.414193063760e+00, TOL));
assert(isequalRel(angl([-2.892420268796e-03,-1.279455956781e-03,2.161254870600e-03], [-8.223847547370e+00,4.662215216680e+03,4.905664118573e+03]), 1.390022011157e+00, TOL));
assert(isequalRel(angl([2.912289533571e+04,3.315328543207e+04,0.000000000000e+00], [-3.181495772611e-03,-1.115574750136e-03,2.654631528141e-03]), 2.324888457348e+00, TOL));
assert(isequalRel(angl([-3.181495772611e-03,-1.115574750136e-03,2.654631528141e-03], [-4.966201379626e+03,-4.379591550374e+03,1.349333475022e+03]), 5.792132070155e-01, TOL));
assert(isequalRel(angl([2.928398194657e+04,3.293115306347e+04,0.000000000000e+00], [-3.117729119169e-03,-4.947330438543e-04,3.207265199575e-03]), 2.144241888415e+00, TOL));
assert(isequalRel(angl([-3.117729119169e-03,-4.947330438543e-04,3.207265199575e-03], [2.954493903314e+03,-2.080659846504e+03,-5.754750380565e+03]), 2.628295360431e+00, TOL));
assert(isequalRel(angl([2.951558723815e+04,3.279901138802e+04,0.000000000000e+00], [-2.534382150433e-03,-2.831754849076e-04,2.719331406470e-03]), 2.107388198411e+00, TOL));
assert(isequalRel(angl([-2.534382150433e-03,-2.831754849076e-04,2.719331406470e-03], [3.363287943208e+03,5.559558411795e+03,1.956055422663e+03]), 1.760852324808e+00, TOL));
assert(isequalRel(angl([2.971618713215e+04,3.257294570545e+04,0.000000000000e+00], [-2.333589104875e-03,-4.141148732270e-04,2.317027898845e-03]), 2.173431904186e+00, TOL));
assert(isequalRel(angl([-2.333589104875e-03,-4.141148732270e-04,2.317027898845e-03], [-4.856667800700e+03,-1.107034501919e+03,4.557212582406e+03]), 4.833955774302e-02, TOL));
assert(isequalRel(angl([2.989259041601e+04,3.240809930242e+04,0.000000000000e+00], [-2.401745673750e-03,-3.102694959366e-04,2.493620992261e-03]), 2.134208509929e+00, TOL));
assert(isequalRel(angl([-2.401745673750e-03,-3.102694959366e-04,2.493620992261e-03], [-4.978448007121e+02,-4.863460053117e+03,-4.700812112174e+03]), 1.963288807041e+00, TOL));
assert(isequalRel(angl([3.013645163526e+04,3.223043736295e+04,0.000000000000e+00], [-2.221182905150e-03,-5.097236428449e-04,2.045068152892e-03]), 2.235762076747e+00, TOL));
assert(isequalRel(angl([-2.221182905150e-03,-5.097236428449e-04,2.045068152892e-03], [5.241619360959e+03,3.910759606834e+03,-1.857934739522e+03]), 2.563598137115e+00, TOL));
assert(isequalRel(angl([3.028850769053e+04,3.200943489878e+04,0.000000000000e+00], [-2.356215412341e-03,-1.095658749439e-03,1.536125876031e-03]), 2.498326441594e+00, TOL));
assert(isequalRel(angl([-2.356215412341e-03,-1.095658749439e-03,1.536125876031e-03], [-2.451380459530e+03,2.610604632610e+03,5.729790220688e+03]), 9.588197271658e-01, TOL));
assert(isequalRel(angl([3.052130378009e+04,3.186868334191e+04,0.000000000000e+00], [-2.946644922150e-03,-1.213852982457e-03,2.067942752109e-03]), 2.445329779743e+00, TOL));
assert(isequalRel(angl([-2.946644922150e-03,-1.213852982457e-03,2.067942752109e-03], [-3.791875206380e+03,-5.378828513819e+03,-1.575827379301e+03]), 9.741987854508e-01, TOL));
assert(isequalRel(angl([3.070763927949e+04,3.163311773597e+04,0.000000000000e+00], [-3.156305307342e-03,-9.685068928393e-04,2.549708030268e-03]), 2.337289703773e+00, TOL));
assert(isequalRel(angl([-3.156305307342e-03,-9.685068928393e-04,2.549708030268e-03], [4.730539583565e+03,5.240500643313e+02,-4.857293697253e+03]), 2.945319559456e+00, TOL));
assert(isequalRel(angl([3.088649983154e+04,3.147050624651e+04,0.000000000000e+00], [-3.017407827696e-03,-9.526615063081e-04,2.383556326746e-03]), 2.353430901559e+00, TOL));
assert(isequalRel(angl([-3.017407827696e-03,-9.526615063081e-04,2.383556326746e-03], [1.159278028972e+03,5.056601754954e+03,4.353494185789e+03]), 1.493880574057e+00, TOL));

# 8195
assert(isequalRel(angl([1.056322732698e+04,-6.650187587080e+04,0.000000000000e+00], [-3.039704378453e-01,1.469440611817e-02,-6.155476078527e-01]), 1.661499566209e+00, TOL));
assert(isequalRel(angl([-3.039704378453e-01,1.469440611817e-02,-6.155476078527e-01], [1.522391713658e+04,-1.785295881713e+04,2.528039558224e+04]), 2.613009397654e+00, TOL));
assert(isequalRel(angl([1.054998914909e+04,-6.649750171985e+04,0.000000000000e+00], [-3.040147646199e-01,1.473777382294e-02,-6.155921264162e-01]), 1.661484196457e+00, TOL));
assert(isequalRel(angl([-3.040147646199e-01,1.473777382294e-02,-6.155921264162e-01], [1.975278050009e+04,-8.600071309618e+03,3.752272921090e+04]), 2.961126539238e+00, TOL));
assert(isequalRel(angl([1.053714294265e+04,-6.649836921232e+04,0.000000000000e+00], [-3.040149019528e-01,1.473169108550e-02,-6.156031146599e-01]), 1.661391171677e+00, TOL));
assert(isequalRel(angl([-3.040149019528e-01,1.473169108550e-02,-6.156031146599e-01], [1.908929762968e+04,3.107894950177e+03,3.995814661370e+04]), 3.049149858705e+00, TOL));
assert(isequalRel(angl([1.052485256238e+04,-6.650448923111e+04,0.000000000000e+00], [-3.039770958761e-01,1.473654989247e-02,-6.155675080419e-01]), 1.661311221703e+00, TOL));
assert(isequalRel(angl([-3.039770958761e-01,1.473654989247e-02,-6.155675080419e-01], [1.382966070574e+04,1.397739999817e+04,3.273632082508e+04]), 2.741232408125e+00, TOL));
assert(isequalRel(angl([1.051471501106e+04,-6.651846516390e+04,0.000000000000e+00], [-3.039028966032e-01,1.487664780270e-02,-6.154993372257e-01]), 1.661429753847e+00, TOL));
assert(isequalRel(angl([-3.039028966032e-01,1.487664780270e-02,-6.154993372257e-01], [3.333058385247e+03,1.839531728674e+04,1.273825031238e+04]), 2.156006134560e+00, TOL));
assert(isequalRel(angl([1.051081020457e+04,-6.652651481693e+04,0.000000000000e+00], [-3.038890758284e-01,1.483099409156e-02,-6.155748569015e-01]), 1.661319567015e+00, TOL));
assert(isequalRel(angl([-3.038890758284e-01,1.483099409156e-02,-6.155748569015e-01], [2.622132222073e+03,-1.512515464924e+04,4.745104839822e+02]), 1.695649454174e+00, TOL));
assert(isequalRel(angl([1.050297126432e+04,-6.651504557465e+04,0.000000000000e+00], [-3.039496853437e-01,1.504615919300e-02,-6.155014935064e-01]), 1.661610221321e+00, TOL));
assert(isequalRel(angl([-3.039496853437e-01,1.504615919300e-02,-6.155014935064e-01], [1.532056770017e+04,-1.777732564586e+04,2.553953198382e+04]), 2.619601954539e+00, TOL));
assert(isequalRel(angl([1.048977045067e+04,-6.651065969011e+04,0.000000000000e+00], [-3.039938383434e-01,1.508862302823e-02,-6.155462934091e-01]), 1.661593644682e+00, TOL));
assert(isequalRel(angl([-3.039938383434e-01,1.508862302823e-02,-6.155462934091e-01], [1.976970267785e+04,-8.458651044544e+03,3.762420130236e+04]), 2.965349613386e+00, TOL));
assert(isequalRel(angl([1.047696007889e+04,-6.651150022828e+04,0.000000000000e+00], [-3.039940592989e-01,1.508268654117e-02,-6.155572391180e-01]), 1.661501099608e+00, TOL));
assert(isequalRel(angl([-3.039940592989e-01,1.508268654117e-02,-6.155572391180e-01], [1.904856201523e+04,3.260432231191e+03,3.992339143967e+04]), 3.045100037191e+00, TOL));
assert(isequalRel(angl([1.046469851507e+04,-6.651760744006e+04,0.000000000000e+00], [-3.039563058023e-01,1.508854739458e-02,-6.155214678241e-01]), 1.661422906406e+00, TOL));
assert(isequalRel(angl([-3.039563058023e-01,1.508854739458e-02,-6.155214678241e-01], [1.372919205837e+04,1.409770014810e+04,3.254752799890e+04]), 2.735711108562e+00, TOL));
assert(isequalRel(angl([1.045467483118e+04,-6.653164752467e+04,0.000000000000e+00], [-3.038826538136e-01,1.523346475528e-02,-6.154548483433e-01]), 1.661549180676e+00, TOL));
assert(isequalRel(angl([-3.038826538136e-01,1.523346475528e-02,-6.154548483433e-01], [3.148861656431e+03,1.832319841703e+04,1.230575195578e+04]), 2.140112890891e+00, TOL));
assert(isequalRel(angl([1.045099929730e+04,-6.653918393271e+04,0.000000000000e+00], [-3.038681222577e-01,1.518519080206e-02,-6.155246696890e-01]), 1.661437793051e+00, TOL));
assert(isequalRel(angl([-3.038681222577e-01,1.518519080206e-02,-6.155246696890e-01], [2.890806382677e+03,-1.544643952300e+04,9.487701017643e+02]), 1.728437343991e+00, TOL));
assert(isequalRel(angl([1.044283991972e+04,-6.652763311527e+04,0.000000000000e+00], [-3.039324172534e-01,1.540002004344e-02,-6.154589042491e-01]), 1.661725621355e+00, TOL));
assert(isequalRel(angl([-3.039324172534e-01,1.540002004344e-02,-6.154589042491e-01], [1.541598410712e+04,-1.769990714437e+04,2.579619644689e+04]), 2.626132585540e+00, TOL));
assert(isequalRel(angl([1.042965243933e+04,-6.652323212027e+04,0.000000000000e+00], [-3.039764021060e-01,1.544149945158e-02,-6.155040642566e-01]), 1.661707561415e+00, TOL));
assert(isequalRel(angl([-3.039764021060e-01,1.544149945158e-02,-6.155040642566e-01], [1.978600618538e+04,-8.316745705810e+03,3.772374539119e+04]), 2.969565037590e+00, TOL));
assert(isequalRel(angl([1.041685363982e+04,-6.652404357419e+04,0.000000000000e+00], [-3.039767016366e-01,1.543561201314e-02,-6.155150516384e-01]), 1.661615190799e+00, TOL));
assert(isequalRel(angl([-3.039767016366e-01,1.543561201314e-02,-6.155150516384e-01], [1.900728688729e+04,3.412859487148e+03,3.988666579255e+04]), 3.041041287918e+00, TOL));
assert(isequalRel(angl([1.040459688085e+04,-6.653013703449e+04,0.000000000000e+00], [-3.039389860720e-01,1.544238525006e-02,-6.154791954087e-01]), 1.661538459992e+00, TOL));
assert(isequalRel(angl([-3.039389860720e-01,1.544238525006e-02,-6.154791954087e-01], [1.362793015254e+04,1.421695401307e+04,3.235613706868e+04]), 2.730146094265e+00, TOL));
assert(isequalRel(angl([1.039466927861e+04,-6.654424232796e+04,0.000000000000e+00], [-3.038659267046e-01,1.559213547252e-02,-6.154143492973e-01]), 1.661672360784e+00, TOL));
assert(isequalRel(angl([-3.038659267046e-01,1.559213547252e-02,-6.154143492973e-01], [2.963264865596e+03,1.824385063641e+04,1.186825797486e+04]), 2.123748889845e+00, TOL));
assert(isequalRel(angl([1.039117273861e+04,-6.655124225104e+04,0.000000000000e+00], [-3.038509531789e-01,1.554155049728e-02,-6.154785950537e-01]), 1.661559947381e+00, TOL));
assert(isequalRel(angl([-3.038509531789e-01,1.554155049728e-02,-6.154785950537e-01], [3.155851260364e+03,-1.575070393364e+04,1.422324969530e+03]), 1.759697486449e+00, TOL));
assert(isequalRel(angl([1.038269040072e+04,-6.653963175261e+04,0.000000000000e+00], [-3.039185506053e-01,1.575533326953e-02,-6.154203062839e-01]), 1.661843820262e+00, TOL));
assert(isequalRel(angl([-3.039185506053e-01,1.575533326953e-02,-6.154203062839e-01], [1.551015191770e+04,-1.762071002219e+04,2.605043525345e+04]), 2.632603055222e+00, TOL));
assert(isequalRel(angl([1.036949337509e+04,-6.653521642636e+04,0.000000000000e+00], [-3.039623438717e-01,1.579573874084e-02,-6.154658710665e-01]), 1.661823989879e+00, TOL));
assert(isequalRel(angl([-3.039623438717e-01,1.579573874084e-02,-6.154658710665e-01], [1.980167198812e+04,-8.174333371671e+03,3.782138577439e+04]), 2.973772889409e+00, TOL));
assert(isequalRel(angl([1.035668322435e+04,-6.653600075325e+04,0.000000000000e+00], [-3.039626885576e-01,1.578979587869e-02,-6.154769495630e-01]), 1.661731481735e+00, TOL));
assert(isequalRel(angl([-3.039626885576e-01,1.578979587869e-02,-6.154769495630e-01], [1.896546529379e+04,3.565196662420e+03,3.984797510998e+04]), 3.036973774559e+00, TOL));
assert(isequalRel(angl([1.034440876351e+04,-6.654208354027e+04,0.000000000000e+00], [-3.039249686101e-01,1.579738619199e-02,-6.154410535211e-01]), 1.661655915843e+00, TOL));
assert(isequalRel(angl([-3.039249686101e-01,1.579738619199e-02,-6.154410535211e-01], [1.352588227400e+04,1.433515978787e+04,3.216213236536e+04]), 2.724536988341e+00, TOL));
assert(isequalRel(angl([1.033456155737e+04,-6.655625893360e+04,0.000000000000e+00], [-3.038525269048e-01,1.595197813124e-02,-6.153781810085e-01]), 1.661797329455e+00, TOL));
assert(isequalRel(angl([-3.038525269048e-01,1.595197813124e-02,-6.153781810085e-01], [2.776305742600e+03,1.815698538451e+04,1.142573046481e+04]), 2.106888908466e+00, TOL));
assert(isequalRel(angl([1.033119611226e+04,-6.656270666422e+04,0.000000000000e+00], [-3.038373243486e-01,1.589929060437e-02,-6.154369689501e-01]), 1.661683918082e+00, TOL));
assert(isequalRel(angl([-3.038373243486e-01,1.589929060437e-02,-6.154369689501e-01], [3.417209315865e+03,-1.603879510665e+04,1.894749340578e+03]), 1.789541978850e+00, TOL));

# 9880
assert(isequalRel(angl([6.451513548190e+04,-1.214595268369e+04,0.000000000000e+00], [-5.554381874903e-02,-2.985516882681e-01,-6.389900336216e-01]), 1.569875285805e+00, TOL));
assert(isequalRel(angl([-5.554381874903e-02,-2.985516882681e-01,-6.389900336216e-01], [1.919032482476e+04,9.249012669022e+03,2.659671345328e+04]), 2.613353781448e+00, TOL));
assert(isequalRel(angl([6.450595965122e+04,-1.215951230431e+04,0.000000000000e+00], [-5.558516775964e-02,-2.985919814070e-01,-6.390380435912e-01]), 1.569824020529e+00, TOL));
assert(isequalRel(angl([-5.558516775964e-02,-2.985919814070e-01,-6.390380435912e-01], [1.133267806218e+04,1.651799124008e+04,3.856978482991e+04]), 2.953696643023e+00, TOL));
assert(isequalRel(angl([6.450248700176e+04,-1.217417246923e+04,0.000000000000e+00], [-5.557425871728e-02,-2.985996346426e-01,-6.390437630944e-01]), 1.569708457527e+00, TOL));
assert(isequalRel(angl([-5.557425871728e-02,-2.985996346426e-01,-6.390437630944e-01], [3.287421739786e+02,1.955492047380e+04,4.055826246145e+04]), 3.069243441509e+00, TOL));
assert(isequalRel(angl([6.450426939866e+04,-1.218982872853e+04,0.000000000000e+00], [-5.557199744454e-02,-2.985672166541e-01,-6.390056721323e-01]), 1.569615304591e+00, TOL));
assert(isequalRel(angl([-5.557199744454e-02,-2.985672166541e-01,-6.390056721323e-01], [-1.068490590680e+04,1.805715728839e+04,3.315875253886e+04]), 2.781981514761e+00, TOL));
assert(isequalRel(angl([6.451355279107e+04,-1.220585520673e+04,0.000000000000e+00], [-5.568012225663e-02,-2.984632871854e-01,-6.389472107050e-01]), 1.569700955348e+00, TOL));
assert(isequalRel(angl([-5.568012225663e-02,-2.984632871854e-01,-6.389472107050e-01], [-1.706978000550e+04,9.944867978974e+03,1.388591649059e+04]), 2.262060477023e+00, TOL));
assert(isequalRel(angl([6.452048973345e+04,-1.221366571683e+04,0.000000000000e+00], [-5.561779234696e-02,-2.984689444357e-01,-6.390322619730e-01]), 1.569571294435e+00, TOL));
assert(isequalRel(angl([-5.561779234696e-02,-2.984689444357e-01,-6.390322619730e-01], [1.372509398980e+04,-2.180708770897e+03,8.632968452340e+02]), 1.638267445445e+00, TOL));
assert(isequalRel(angl([6.450380606479e+04,-1.221913187733e+04,0.000000000000e+00], [-5.587545860498e-02,-2.984757253955e-01,-6.389682128818e-01]), 1.569871910333e+00, TOL));
assert(isequalRel(angl([-5.587545860498e-02,-2.984757253955e-01,-6.389682128818e-01], [1.908963879226e+04,9.456296702471e+03,2.702679562883e+04]), 2.624123778438e+00, TOL));
assert(isequalRel(angl([6.449489880712e+04,-1.223267431100e+04,0.000000000000e+00], [-5.591490010956e-02,-2.985144869853e-01,-6.390143992071e-01]), 1.569818717300e+00, TOL));
assert(isequalRel(angl([-5.591490010956e-02,-2.985144869853e-01,-6.390143992071e-01], [1.110641248373e+04,1.662760874079e+04,3.872735140296e+04]), 2.960372493246e+00, TOL));
assert(isequalRel(angl([6.449165417857e+04,-1.224730464852e+04,0.000000000000e+00], [-5.590412889115e-02,-2.985206134902e-01,-6.390181213928e-01]), 1.569704205155e+00, TOL));
assert(isequalRel(angl([-5.590412889115e-02,-2.985206134902e-01,-6.390181213928e-01], [7.240958620636e+01,1.957508054144e+04,4.049212544001e+04]), 3.062979379458e+00, TOL));
assert(isequalRel(angl([6.449367386907e+04,-1.226293720215e+04,0.000000000000e+00], [-5.590336653561e-02,-2.984862854977e-01,-6.389780878670e-01]), 1.569614167302e+00, TOL));
assert(isequalRel(angl([-5.590336653561e-02,-2.984862854977e-01,-6.389780878670e-01], [-1.090589252576e+04,1.796541205111e+04,3.285007298244e+04]), 2.773665493869e+00, TOL));
assert(isequalRel(angl([6.450332438564e+04,-1.227885355297e+04,0.000000000000e+00], [-5.601807981294e-02,-2.983793091947e-01,-6.389203968686e-01]), 1.569711162153e+00, TOL));
assert(isequalRel(angl([-5.601807981294e-02,-2.983793091947e-01,-6.389203968686e-01], [-1.704461207568e+04,9.635484918489e+03,1.321259462953e+04]), 2.239735657736e+00, TOL));
assert(isequalRel(angl([6.450973285714e+04,-1.228588857118e+04,0.000000000000e+00], [-5.595440096095e-02,-2.983821652559e-01,-6.389910540802e-01]), 1.569584744529e+00, TOL));
assert(isequalRel(angl([-5.595440096095e-02,-2.983821652559e-01,-6.389910540802e-01], [1.436990303735e+04,-1.903856010622e+03,1.722153198525e+03]), 1.700573304283e+00, TOL));
assert(isequalRel(angl([6.449309140510e+04,-1.229198313775e+04,0.000000000000e+00], [-5.621045226164e-02,-2.983952253559e-01,-6.389410420996e-01]), 1.569877321722e+00, TOL));
assert(isequalRel(angl([-5.621045226164e-02,-2.983952253559e-01,-6.389410420996e-01], [1.898396210441e+04,9.661122338040e+03,2.744899557732e+04]), 2.634691028511e+00, TOL));
assert(isequalRel(angl([6.448443199063e+04,-1.230549134844e+04,0.000000000000e+00], [-5.624827587651e-02,-2.984325445057e-01,-6.389855651233e-01]), 1.569822674803e+00, TOL));
assert(isequalRel(angl([-5.624827587651e-02,-2.984325445057e-01,-6.389855651233e-01], [1.087879336704e+04,1.673531433954e+04,3.887923434264e+04]), 2.967017186326e+00, TOL));
assert(isequalRel(angl([6.448139556728e+04,-1.232007670814e+04,0.000000000000e+00], [-5.623786679588e-02,-2.984372330080e-01,-6.389874752457e-01]), 1.569709583727e+00, TOL));
assert(isequalRel(angl([-5.623786679588e-02,-2.984372330080e-01,-6.389874752457e-01], [-1.840374310020e+02,1.959309371709e+04,4.042040606889e+04]), 3.056690565140e+00, TOL));
assert(isequalRel(angl([6.448363338392e+04,-1.233567100584e+04,0.000000000000e+00], [-5.623883691168e-02,-2.984010702631e-01,-6.389456917792e-01]), 1.569623045494e+00, TOL));
assert(isequalRel(angl([-5.623883691168e-02,-2.984010702631e-01,-6.389456917792e-01], [-1.112512138631e+04,1.787019488928e+04,3.253421521208e+04]), 2.765227862163e+00, TOL));
assert(isequalRel(angl([6.449363848962e+04,-1.235145162397e+04,0.000000000000e+00], [-5.636062003809e-02,-2.982911655159e-01,-6.388892904932e-01]), 1.569732184663e+00, TOL));
assert(isequalRel(angl([-5.636062003809e-02,-2.982911655159e-01,-6.388892904932e-01], [-1.700443272827e+04,9.316539263508e+03,1.252611883812e+04]), 2.216339792232e+00, TOL));
assert(isequalRel(angl([6.449940115919e+04,-1.235776751194e+04,0.000000000000e+00], [-5.629756672539e-02,-2.982921243595e-01,-6.389466098567e-01]), 1.569611006001e+00, TOL));
assert(isequalRel(angl([-5.629756672539e-02,-2.982921243595e-01,-6.389466098567e-01], [1.496006492693e+04,-1.620684308049e+03,2.574963593810e+03]), 1.757450772531e+00, TOL));
assert(isequalRel(angl([6.448286860340e+04,-1.236441938442e+04,0.000000000000e+00], [-5.654991059281e-02,-2.983107754633e-01,-6.389096668141e-01]), 1.569893346015e+00, TOL));
assert(isequalRel(angl([-5.654991059281e-02,-2.983107754633e-01,-6.389096668141e-01], [1.887346347257e+04,9.863570045860e+03,2.786346574735e+04]), 2.645067878270e+00, TOL));
assert(isequalRel(angl([6.447443305344e+04,-1.237788019339e+04,0.000000000000e+00], [-5.658635625537e-02,-2.983467635610e-01,-6.389527117880e-01]), 1.569837613824e+00, TOL));
assert(isequalRel(angl([-5.658635625537e-02,-2.983467635610e-01,-6.389527117880e-01], [1.064986857581e+04,1.684114172669e+04,3.902548035006e+04]), 2.973633805192e+00, TOL));
assert(isequalRel(angl([6.447158195204e+04,-1.239240923037e+04,0.000000000000e+00], [-5.657648669888e-02,-2.983501232925e-01,-6.389530163085e-01]), 1.569726213927e+00, TOL));
assert(isequalRel(angl([-5.657648669888e-02,-2.983501232925e-01,-6.389530163085e-01], [-4.405345932276e+02,1.960895524423e+04,4.034310675451e+04]), 3.050375168246e+00, TOL));
assert(isequalRel(angl([6.447401591781e+04,-1.240795454808e+04,0.000000000000e+00], [-5.657937702686e-02,-2.983122198892e-01,-6.389096953385e-01]), 1.569643462020e+00, TOL));
assert(isequalRel(angl([-5.657937702686e-02,-2.983122198892e-01,-6.389096953385e-01], [-1.134245028909e+04,1.777144223942e+04,3.221112535721e+04]), 2.756664213759e+00, TOL));
assert(isequalRel(angl([6.448436081458e+04,-1.242357608784e+04,0.000000000000e+00], [-5.670867566911e-02,-2.981995413296e-01,-6.388551638665e-01]), 1.569765467313e+00, TOL));
assert(isequalRel(angl([-5.670867566911e-02,-2.981995413296e-01,-6.388551638665e-01], [-1.694806005711e+04,8.987642548800e+03,1.182628284367e+04]), 2.191776073666e+00, TOL));
assert(isequalRel(angl([6.448938182061e+04,-1.242923353997e+04,0.000000000000e+00], [-5.664747989866e-02,-2.981995052598e-01,-6.389003114064e-01]), 1.569650484657e+00, TOL));
assert(isequalRel(angl([-5.664747989866e-02,-2.981995052598e-01,-6.389003114064e-01], [1.550053445068e+04,-1.332909810419e+03,3.419723153077e+03]), 1.809626469631e+00, TOL));

# 9998
assert(isequalRel(angl([1.394770721697e+04,-1.487114728555e+04,0.000000000000e+00], [5.081754243019e-03,-2.657147878635e-02,-2.424540695609e-03]), 5.706740480977e-01, TOL));
assert(isequalRel(angl([5.081754243019e-03,-2.657147878635e-02,-2.424540695609e-03], [-1.136218265118e+04,-3.511755867813e+04,-5.413625379945e+03]), 5.014451914765e-01, TOL));
assert(isequalRel(angl([1.394755356317e+04,-1.487131312933e+04,0.000000000000e+00], [5.095744072794e-03,-2.657415767361e-02,-2.423096834513e-03]), 5.701708335391e-01, TOL));
assert(isequalRel(angl([5.095744072794e-03,-2.657415767361e-02,-2.423096834513e-03], [3.092534992889e+02,-3.696043090143e+04,-4.198480076703e+03]), 1.817196142388e-01, TOL));
assert(isequalRel(angl([1.394752279748e+04,-1.487135033091e+04,0.000000000000e+00], [5.110276166939e-03,-2.657252765271e-02,-2.421124751128e-03]), 5.696265235965e-01, TOL));
assert(isequalRel(angl([5.110276166939e-03,-2.657252765271e-02,-2.421124751128e-03], [1.194904009077e+04,-3.512737816804e+04,-2.565898064678e+03]), 1.389307149831e-01, TOL));
assert(isequalRel(angl([1.394750901711e+04,-1.487120966612e+04,0.000000000000e+00], [5.123706486923e-03,-2.656630047150e-02,-2.418771310980e-03]), 5.690966457642e-01, TOL));
assert(isequalRel(angl([5.123706486923e-03,-2.656630047150e-02,-2.418771310980e-03], [2.240045329336e+04,-2.979863236321e+04,-6.779151512206e+02]), 4.588417955321e-01, TOL));
assert(isequalRel(angl([1.394739993764e+04,-1.487091690353e+04,0.000000000000e+00], [5.134286174890e-03,-2.655607809876e-02,-2.416293716897e-03]), 5.686440868343e-01, TOL));
assert(isequalRel(angl([5.134286174890e-03,-2.655607809876e-02,-2.416293716897e-03], [3.064084752458e+04,-2.152502340201e+04,1.277348087222e+03]), 7.764561441336e-01, TOL));
assert(isequalRel(angl([1.394712488808e+04,-1.487055919739e+04,0.000000000000e+00], [5.140795543727e-03,-2.654327834369e-02,-2.413984528270e-03]), 5.683177992036e-01, TOL));
assert(isequalRel(angl([5.140795543727e-03,-2.654327834369e-02,-2.413984528270e-03], [3.589956788035e+04,-1.115271158138e+04,3.108725352380e+03]), 1.090500167808e+00, TOL));
assert(isequalRel(angl([1.394668085247e+04,-1.487024523671e+04,0.000000000000e+00], [5.142895348579e-03,-2.652960918227e-02,-2.412075817892e-03]), 5.681385975487e-01, TOL));
assert(isequalRel(angl([5.142895348579e-03,-2.652960918227e-02,-2.412075817892e-03], [3.773245438600e+04,2.881882105381e+02,4.643875874950e+03]), 1.400107160725e+00, TOL));
assert(isequalRel(angl([1.394612728574e+04,-1.487006092407e+04,0.000000000000e+00], [5.140979746232e-03,-2.651650405204e-02,-2.410693136208e-03]), 5.681017273326e-01, TOL));
assert(isequalRel(angl([5.140979746232e-03,-2.651650405204e-02,-2.410693136208e-03], [3.604592961699e+04,1.170661816230e+04,5.746326465740e+03]), 1.704879207196e+00, TOL));
assert(isequalRel(angl([1.394555741788e+04,-1.487004028465e+04,0.000000000000e+00], [5.135740196303e-03,-2.650489269402e-02,-2.409877499286e-03]), 5.681909666192e-01, TOL));
assert(isequalRel(angl([5.135740196303e-03,-2.650489269402e-02,-2.409877499286e-03], [3.107677273609e+04,2.206344379776e+04,6.325934037052e+03]), 2.004889883980e+00, TOL));
assert(isequalRel(angl([1.394506215074e+04,-1.487015963888e+04,0.000000000000e+00], [5.127811666320e-03,-2.649534647327e-02,-2.409637651210e-03]), 5.683913946833e-01, TOL));
assert(isequalRel(angl([5.127811666320e-03,-2.649534647327e-02,-2.409637651210e-03], [2.334126015320e+04,3.046088002531e+04,6.342917078955e+03]), 2.300636343814e+00, TOL));
assert(isequalRel(angl([1.394470077916e+04,-1.487035163834e+04,0.000000000000e+00], [5.117710600971e-03,-2.648836252560e-02,-2.409983237968e-03]), 5.686921215866e-01, TOL));
assert(isequalRel(angl([5.117710600971e-03,-2.648836252560e-02,-2.409983237968e-03], [1.356839733054e+04,3.620445930900e+04,5.806795487331e+03]), 2.592956156753e+00, TOL));
assert(isequalRel(angl([1.394448585370e+04,-1.487053017534e+04,0.000000000000e+00], [5.106014171704e-03,-2.648452291568e-02,-2.410916798148e-03]), 5.690794645767e-01, TOL));
assert(isequalRel(angl([5.106014171704e-03,-2.648452291568e-02,-2.410916798148e-03], [2.628587624197e+03,3.884010855897e+04,4.771919798544e+03]), 2.882928008781e+00, TOL));
assert(isequalRel(angl([1.394438305703e+04,-1.487061712833e+04,0.000000000000e+00], [5.093581041121e-03,-2.648441527307e-02,-2.412396541141e-03]), 5.695273930291e-01, TOL));
assert(isequalRel(angl([5.093581041121e-03,-2.648441527307e-02,-2.412396541141e-03], [-8.535815981575e+03,3.817179073851e+04,3.331003112854e+03]), 3.111411998970e+00, TOL));

# 11801
assert(isequalRel(angl([-3.119792158995e+04,-3.761738973941e+04,0.000000000000e+00], [-2.977358648358e-02,-6.159718862628e-01,3.936165758588e-01]), 8.311170660592e-01, TOL));
assert(isequalRel(angl([-2.977358648358e-02,-6.159718862628e-01,3.936165758588e-01], [-3.305221486939e+03,3.241084323331e+04,-2.469716974954e+04]), 2.994636251562e+00, TOL));
assert(isequalRel(angl([-3.125677432175e+04,-3.758317738007e+04,0.000000000000e+00], [-2.977338592857e-02,-6.150954842553e-01,3.938658853715e-01]), 8.325537420029e-01, TOL));
assert(isequalRel(angl([-2.977338592857e-02,-6.150954842553e-01,3.938658853715e-01], [1.427129083858e+04,2.411044309009e+04,-4.725763201432e+03]), 2.539391847291e+00, TOL));
assert(isequalRel(angl([-3.129266877315e+04,-3.752979505543e+04,0.000000000000e+00], [-2.978386777092e-02,-6.144819460282e-01,3.939224349624e-01]), 8.336752447877e-01, TOL));
assert(isequalRel(angl([-2.978386777092e-02,-6.144819460282e-01,3.939224349624e-01], [-9.990058000092e+03,2.271734212448e+04,-2.361688515553e+04]), 2.732899864191e+00, TOL));
assert(isequalRel(angl([-3.134766984171e+04,-3.750076038673e+04,0.000000000000e+00], [-2.982346140081e-02,-6.136264101045e-01,3.940730580169e-01]), 8.349048292128e-01, TOL));
assert(isequalRel(angl([-2.982346140081e-02,-6.136264101045e-01,3.940730580169e-01], [9.787878362555e+03,3.375332249667e+04,-1.503079874625e+04]), 2.876960270493e+00, TOL));

# 14128
assert(isequalRel(angl([2.114179506750e+04,1.491368636784e+04,0.000000000000e+00], [5.464957282739e-04,1.074904269715e-03,1.141740510413e-04]), 4.944521850335e-01, TOL));
assert(isequalRel(angl([5.464957282739e-04,1.074904269715e-03,1.141740510413e-04], [1.826333439094e+04,3.815996004751e+04,4.186183040854e+03]), 2.423482789142e-02, TOL));
assert(isequalRel(angl([2.114166120755e+04,1.491371565681e+04,0.000000000000e+00], [5.285545155401e-04,1.076565036475e-03,1.165438997095e-04]), 5.085652038890e-01, TOL));
assert(isequalRel(angl([5.285545155401e-04,1.076565036475e-03,1.165438997095e-04], [-3.023388407034e+03,4.178313186459e+04,7.273034129058e+03]), 5.289647058498e-01, TOL));
assert(isequalRel(angl([2.114193026783e+04,1.491354554399e+04,0.000000000000e+00], [5.125641823255e-04,1.070092275527e-03,1.173430072498e-04]), 5.183729941027e-01, TOL));
assert(isequalRel(angl([5.125641823255e-04,1.070092275527e-03,1.173430072498e-04], [-2.351634391907e+04,3.442442065671e+04,8.448498676927e+03]), 1.037694577457e+00, TOL));
assert(isequalRel(angl([2.114257562256e+04,1.491362756457e+04,0.000000000000e+00], [5.007539206673e-04,1.057582273629e-03,1.166559690213e-04]), 5.229160477085e-01, TOL));
assert(isequalRel(angl([5.007539206673e-04,1.057582273629e-03,1.166559690213e-04], [-3.783746699511e+04,1.802839727170e+04,7.406255402708e+03]), 1.551150302261e+00, TOL));
assert(isequalRel(angl([2.114319270101e+04,1.491416039837e+04,0.000000000000e+00], [4.957344673120e-04,1.040387788360e-03,1.143976214414e-04]), 5.204398044680e-01, TOL));
assert(isequalRel(angl([4.957344673120e-04,1.040387788360e-03,1.143976214414e-04], [-4.224358460661e+04,-3.093728877741e+03,4.422917118012e+03]), 2.070994646747e+00, TOL));
assert(isequalRel(angl([2.114339735720e+04,1.491489702349e+04,0.000000000000e+00], [5.007139886500e-04,1.022557311499e-03,1.108614825383e-04]), 5.096236078464e-01, TOL));
assert(isequalRel(angl([5.007139886500e-04,1.022557311499e-03,1.108614825383e-04], [-3.559757919549e+04,-2.340791145393e+04,2.820955438334e+02]), 2.598631981531e+00, TOL));
assert(isequalRel(angl([2.114320016950e+04,1.491538814656e+04,0.000000000000e+00], [5.148920649745e-04,1.010652384668e-03,1.072296999971e-04]), 4.935861669351e-01, TOL));
assert(isequalRel(angl([5.148920649745e-04,1.010652384668e-03,1.072296999971e-04], [-1.964919834455e+04,-3.760611623860e+04,-3.932715259483e+03]), 3.131180299349e+00, TOL));
assert(isequalRel(angl([2.114299432082e+04,1.491541979584e+04,0.000000000000e+00], [5.326491153299e-04,1.008303837491e-03,1.047642739075e-04]), 4.785992222853e-01, TOL));
assert(isequalRel(angl([5.326491153299e-04,1.008303837491e-03,1.047642739075e-04], [1.431309121596e+03,-4.198204949668e+04,-7.120454670573e+03]), 2.620499860384e+00, TOL));
assert(isequalRel(angl([2.114317280917e+04,1.491522055685e+04,0.000000000000e+00], [5.487222672618e-04,1.014241870948e-03,1.038720782070e-04]), 4.685716993212e-01, TOL));
assert(isequalRel(angl([5.487222672618e-04,1.014241870948e-03,1.038720782070e-04], [2.213697605384e+04,-3.538819823762e+04,-8.447623934009e+03]), 2.093641207394e+00, TOL));
assert(isequalRel(angl([2.114374600293e+04,1.491523947114e+04,0.000000000000e+00], [5.607633067807e-04,1.026309293925e-03,1.044684519373e-04]), 4.643882163404e-01, TOL));
assert(isequalRel(angl([5.607633067807e-04,1.026309293925e-03,1.044684519373e-04], [3.705015790219e+04,-1.953723321425e+04,-7.564834635430e+03]), 1.572100163411e+00, TOL));
assert(isequalRel(angl([2.114432986470e+04,1.491570816556e+04,0.000000000000e+00], [5.662812190698e-04,1.043215107943e-03,1.066265787951e-04]), 4.671700755073e-01, TOL));
assert(isequalRel(angl([5.662812190698e-04,1.043215107943e-03,1.066265787951e-04], [4.225381760945e+04,1.431818675929e+03,-4.699876211736e+03]), 1.056922863207e+00, TOL));
assert(isequalRel(angl([2.114452026482e+04,1.491641186493e+04,0.000000000000e+00], [5.619424035107e-04,1.061206154224e-03,1.101119900458e-04]), 4.775995189039e-01, TOL));
assert(isequalRel(angl([5.619424035107e-04,1.061206154224e-03,1.101119900458e-04], [3.636659147396e+04,2.202354245720e+04,-6.014712182108e+02]), 5.488642973024e-01, TOL));
assert(isequalRel(angl([2.114429113753e+04,1.491689741843e+04,0.000000000000e+00], [5.481061560642e-04,1.073697446075e-03,1.137937529651e-04]), 4.927453176181e-01, TOL));
assert(isequalRel(angl([5.481061560642e-04,1.073697446075e-03,1.137937529651e-04], [2.092212287985e+04,3.682633975981e+04,3.654911258864e+03]), 4.519421514064e-02, TOL));
assert(isequalRel(angl([2.114402262986e+04,1.491691905592e+04,0.000000000000e+00], [5.302323939245e-04,1.076654259857e-03,1.163697583768e-04]), 5.072832170683e-01, TOL));
assert(isequalRel(angl([5.302323939245e-04,1.076654259857e-03,1.163697583768e-04], [-2.377224182361e+01,4.194551688402e+04,6.950298917514e+03]), 4.591253600639e-01, TOL));
assert(isequalRel(angl([2.114412699244e+04,1.491668126153e+04,0.000000000000e+00], [5.138138158844e-04,1.071129180207e-03,1.173750317843e-04]), 5.177472101982e-01, TOL));
assert(isequalRel(angl([5.138138158844e-04,1.071129180207e-03,1.173750317843e-04], [-2.096417821076e+04,3.603906206172e+04,8.418919849633e+03]), 9.672534794013e-01, TOL));
assert(isequalRel(angl([2.114464257724e+04,1.491663631416e+04,0.000000000000e+00], [5.013303995693e-04,1.059369884468e-03,1.168904751004e-04]), 5.230792039779e-01, TOL));
assert(isequalRel(angl([5.013303995693e-04,1.059369884468e-03,1.168904751004e-04], [-3.640163863057e+04,2.066975286162e+04,7.677197693592e+03]), 1.480000229664e+00, TOL));
assert(isequalRel(angl([2.114519825005e+04,1.491703860202e+04,0.000000000000e+00], [4.951737811864e-04,1.042662209547e-03,1.148454679688e-04]), 5.216947719625e-01, TOL));
assert(isequalRel(angl([4.951737811864e-04,1.042662209547e-03,1.148454679688e-04], [-4.229830327543e+04,-1.190335111769e+02,4.922963888414e+03]), 1.998835589395e+00, TOL));
assert(isequalRel(angl([2.114537962445e+04,1.491769674819e+04,0.000000000000e+00], [4.986678031938e-04,1.024550333379e-03,1.114360125800e-04]), 5.119885456407e-01, TOL));
assert(isequalRel(angl([4.986678031938e-04,1.024550333379e-03,1.114360125800e-04], [-3.712562383511e+04,-2.087963058368e+04,8.798697134838e+02]), 2.525463771786e+00, TOL));
assert(isequalRel(angl([2.114513284887e+04,1.491816393625e+04,0.000000000000e+00], [5.118624434904e-04,1.011490021423e-03,1.077269576004e-04]), 4.962904139586e-01, TOL));
assert(isequalRel(angl([5.118624434904e-04,1.011490021423e-03,1.077269576004e-04], [-2.225012320553e+04,-3.618274736487e+04,-3.393153651825e+03]), 3.057695076183e+00, TOL));
assert(isequalRel(angl([2.114481644657e+04,1.491817220537e+04,0.000000000000e+00], [5.295185272341e-04,1.007818366101e-03,1.050529477819e-04]), 4.808128347184e-01, TOL));
assert(isequalRel(angl([5.295185272341e-04,1.007818366101e-03,1.050529477819e-04], [-1.563062586537e+03,-4.203543179159e+04,-6.780021617604e+03]), 2.693517117885e+00, TOL));
assert(isequalRel(angl([2.114485097724e+04,1.491789363503e+04,0.000000000000e+00], [5.460194811995e-04,1.012770010409e-03,1.039462832363e-04]), 4.700009390617e-01, TOL));
assert(isequalRel(angl([5.460194811995e-04,1.012770010409e-03,1.039462832363e-04], [1.953164069587e+04,-3.690565470956e+04,-8.395468920325e+03]), 2.165934863814e+00, TOL));
assert(isequalRel(angl([2.114531051319e+04,1.491777261890e+04,0.000000000000e+00], [5.587309190562e-04,1.024062523047e-03,1.043355412014e-04]), 4.649570525361e-01, TOL));
assert(isequalRel(angl([5.587309190562e-04,1.024062523047e-03,1.043355412014e-04], [3.551653506142e+04,-2.212371916638e+04,-7.815045169350e+03]), 1.643616095620e+00, TOL));
assert(isequalRel(angl([2.114584903992e+04,1.491809304841e+04,0.000000000000e+00], [5.653689655489e-04,1.040428249522e-03,1.062736735220e-04]), 4.666786109422e-01, TOL));
assert(isequalRel(angl([5.653689655489e-04,1.040428249522e-03,1.062736735220e-04], [4.219603535976e+04,-1.547326467506e+03,-5.187394019815e+03]), 1.127462729036e+00, TOL));
assert(isequalRel(angl([2.114603721602e+04,1.491869878065e+04,0.000000000000e+00], [5.625050041782e-04,1.058633028284e-03,1.096228289003e-04]), 4.761262427349e-01, TOL));
assert(isequalRel(angl([5.625050041782e-04,1.058633028284e-03,1.096228289003e-04], [3.780225393045e+04,1.943357330019e+04,-1.198666342264e+03]), 6.184883255747e-01, TOL));

# 16925
assert(isequalRel(angl([2.364691990814e+04,-5.078083306938e+04,0.000000000000e+00], [-3.143599772089e-01,1.126207265650e-01,-4.481161694904e-01]), 2.004401493054e+00, TOL));
assert(isequalRel(angl([-3.143599772089e-01,1.126207265650e-01,-4.481161694904e-01], [1.233983273749e+04,-2.771144478711e+03,1.890457603433e+04]), 3.054342534065e+00, TOL));
assert(isequalRel(angl([2.361477729504e+04,-5.082951641746e+04,0.000000000000e+00], [-3.140119044932e-01,1.130198501674e-01,-4.478519328860e-01]), 2.004681907948e+00, TOL));
assert(isequalRel(angl([-3.140119044932e-01,1.130198501674e-01,-4.478519328860e-01], [-3.385002156585e+03,7.538139557293e+03,2.005900861598e+02]), 1.164374518555e+00, TOL));
assert(isequalRel(angl([2.357361421077e+04,-5.082364939990e+04,0.000000000000e+00], [-3.137137677888e-01,1.129767605108e-01,-4.474966734009e-01]), 2.004448372184e+00, TOL));
assert(isequalRel(angl([-3.137137677888e-01,1.129767605108e-01,-4.474966734009e-01], [1.280522442200e+04,-1.025894667177e+04,1.378016486738e+04]), 2.819537459986e+00, TOL));
assert(isequalRel(angl([2.351627029584e+04,-5.083359692644e+04,0.000000000000e+00], [-3.134330166371e-01,1.128128925294e-01,-4.474674781375e-01]), 2.003629630781e+00, TOL));
assert(isequalRel(angl([-3.134330166371e-01,1.128128925294e-01,-4.474674781375e-01], [5.682465563184e+03,7.199302704725e+03,1.543767134070e+04]), 2.475644859545e+00, TOL));
assert(isequalRel(angl([2.349426383087e+04,-5.087306106104e+04,0.000000000000e+00], [-3.130033362217e-01,1.130483126578e-01,-4.470933769202e-01]), 2.003799645447e+00, TOL));
assert(isequalRel(angl([-3.130033362217e-01,1.130483126578e-01,-4.470933769202e-01], [7.628942439817e+03,-1.285272097492e+04,2.902872089813e+03]), 2.221250150424e+00, TOL));
assert(isequalRel(angl([2.344010255251e+04,-5.085940160386e+04,0.000000000000e+00], [-3.130423638721e-01,1.133146887554e-01,-4.470325998875e-01]), 2.003924307788e+00, TOL));
assert(isequalRel(angl([-3.130423638721e-01,1.133146887554e-01,-4.470325998875e-01], [1.153164866625e+04,-8.582754273594e+02,1.908685993771e+04]), 2.962399877124e+00, TOL));
assert(isequalRel(angl([2.340996947634e+04,-5.088953839711e+04,0.000000000000e+00], [-3.125516359443e-01,1.133197430198e-01,-4.465907472126e-01]), 2.003715249842e+00, TOL));
assert(isequalRel(angl([-3.125516359443e-01,1.133197430198e-01,-4.465907472126e-01], [-3.866980695155e+03,2.603734427863e+03,-4.577364845770e+03]), 2.224003382977e-01, TOL));
assert(isequalRel(angl([2.336591211203e+04,-5.089941074904e+04,0.000000000000e+00], [-3.124368939257e-01,1.137261539973e-01,-4.464187448619e-01]), 2.004081468375e+00, TOL));
assert(isequalRel(angl([-3.124368939257e-01,1.137261539973e-01,-4.464187448619e-01], [1.305477732721e+04,-8.707927577304e+03,1.553763259903e+04]), 2.925115255302e+00, TOL));
assert(isequalRel(angl([2.330989763100e+04,-5.091815238273e+04,0.000000000000e+00], [-3.120423695543e-01,1.135523224860e-01,-4.462812785180e-01]), 2.003257106134e+00, TOL));
assert(isequalRel(angl([-3.120423695543e-01,1.135523224860e-01,-4.462812785180e-01], [3.496910646522e+03,8.712839197782e+03,1.284581838327e+04]), 2.290594697051e+00, TOL));
assert(isequalRel(angl([2.328857171403e+04,-5.094743589895e+04,0.000000000000e+00], [-3.117131153060e-01,1.138633929549e-01,-4.459127902170e-01]), 2.003628316145e+00, TOL));
assert(isequalRel(angl([-3.117131153060e-01,1.138633929549e-01,-4.459127902170e-01], [9.593074247290e+03,-1.302375963608e+04,6.250464849314e+03]), 2.423750578165e+00, TOL));
assert(isequalRel(angl([2.323112348921e+04,-5.093808320092e+04,0.000000000000e+00], [-3.117063327769e-01,1.139901838998e-01,-4.459442808648e-01]), 2.003407498273e+00, TOL));
assert(isequalRel(angl([-3.117063327769e-01,1.139901838998e-01,-4.459442808648e-01], [1.028479205084e+04,1.487899141688e+03,1.882437381327e+04]), 2.844916013383e+00, TOL));
assert(isequalRel(angl([2.318711974260e+04,-5.097299222349e+04,0.000000000000e+00], [-3.112809985410e-01,1.143709710493e-01,-4.454262187886e-01]), 2.003767930978e+00, TOL));
assert(isequalRel(angl([-3.112809985410e-01,1.143709710493e-01,-4.454262187886e-01], [-9.846203514641e+02,-5.187034808132e+03,-5.745595941443e+03]), 1.018738373234e+00, TOL));

# 20413
assert(isequalRel(angl([-2.564836572547e+04,-2.797900350137e+03,0.000000000000e+00], [7.113446817054e-01,3.133770622808e-01,-4.755669211822e-02]), 2.829441962093e+00, TOL));
assert(isequalRel(angl([7.113446817054e-01,3.133770622808e-01,-4.755669211822e-02], [-1.516690528051e+05,-5.645204545496e+03,-2.198515921184e+03]), 2.756537247626e+00, TOL));
assert(isequalRel(angl([-2.564352092512e+04,-2.792155172206e+03,0.000000000000e+00], [7.113335379656e-01,3.133142938169e-01,-4.756060016003e-02]), 2.829310216670e+00, TOL));
assert(isequalRel(angl([7.113335379656e-01,3.133142938169e-01,-4.756060016003e-02], [-1.574977165749e+05,-1.188499595074e+04,-1.061444394024e+03]), 2.795498343882e+00, TOL));
assert(isequalRel(angl([-2.563905766511e+04,-2.786585193522e+03,0.000000000000e+00], [7.113245223411e-01,3.132508142966e-01,-4.756447731509e-02]), 2.829185379661e+00, TOL));
assert(isequalRel(angl([7.113245223411e-01,3.132508142966e-01,-4.756447731509e-02], [-1.624983225558e+05,-1.806299733167e+04,8.100915252769e+01]), 2.831678475947e+00, TOL));
assert(isequalRel(angl([-2.563497914562e+04,-2.781194609747e+03,0.000000000000e+00], [7.113176526545e-01,3.131867340948e-01,-4.756833547145e-02]), 2.829067488026e+00, TOL));
assert(isequalRel(angl([7.113176526545e-01,3.131867340948e-01,-4.756833547145e-02], [-1.667287601092e+05,-2.415599648299e+04,1.222841286769e+03]), 2.865606725861e+00, TOL));
assert(isequalRel(angl([-2.563575410629e+04,-2.734601260471e+03,0.000000000000e+00], [7.081835096527e-01,3.198831237443e-01,-4.924446729593e-02]), 2.817572621549e+00, TOL));
assert(isequalRel(angl([7.081835096527e-01,3.198831237443e-01,-4.924446729593e-02], [-1.699358192459e+05,-3.176729787964e+04,2.749015403445e+03]), 2.897697282650e+00, TOL));
assert(isequalRel(angl([-2.563246433167e+04,-2.729381694110e+03,0.000000000000e+00], [7.081803489839e-01,3.198206882454e-01,-4.924957253059e-02]), 2.817457009645e+00, TOL));
assert(isequalRel(angl([7.081803489839e-01,3.198206882454e-01,-4.924957253059e-02], [-1.727030783182e+05,-3.766295639336e+04,3.883600525786e+03]), 2.928282952468e+00, TOL));
assert(isequalRel(angl([-2.562956164220e+04,-2.724375624676e+03,0.000000000000e+00], [7.081801459520e-01,3.197563566343e-01,-4.925424435820e-02]), 2.817351713976e+00, TOL));
assert(isequalRel(angl([7.081801459520e-01,3.197563566343e-01,-4.925424435820e-02], [-1.748231933740e+05,-4.341755605219e+04,5.003263128095e+03]), 2.957635499184e+00, TOL));
assert(isequalRel(angl([-2.562704598998e+04,-2.719586274528e+03,0.000000000000e+00], [7.081829073503e-01,3.196902316374e-01,-4.925849009696e-02]), 2.817256752018e+00, TOL));
assert(isequalRel(angl([7.081829073503e-01,3.196902316374e-01,-4.925849009696e-02], [-1.763246392577e+05,-4.901851958648e+04,6.104850250015e+03]), 2.985982433197e+00, TOL));
assert(isequalRel(angl([-2.562491656404e+04,-2.715016440914e+03,0.000000000000e+00], [7.081886353423e-01,3.196224185978e-01,-4.926231772408e-02]), 2.817172121949e+00, TOL));
assert(isequalRel(angl([7.081886353423e-01,3.196224185978e-01,-4.926231772408e-02], [-1.772314214246e+05,-5.445412699497e+04,7.185486616066e+03]), 3.013517951608e+00, TOL));
assert(isequalRel(angl([-2.562317179492e+04,-2.710668490840e+03,0.000000000000e+00], [7.081973273634e-01,3.195530255105e-01,-4.926573591309e-02]), 2.817097802281e+00, TOL));
assert(isequalRel(angl([7.081973273634e-01,3.195530255105e-01,-4.926573591309e-02], [-1.775637358323e+05,-5.971314859144e+04,8.242484725914e+03]), 3.040411304260e+00, TOL));
assert(isequalRel(angl([-2.562180935804e+04,-2.706544355855e+03,0.000000000000e+00], [7.082089760363e-01,3.194821630060e-01,-4.926875405950e-02]), 2.817033751578e+00, TOL));
assert(isequalRel(angl([7.082089760363e-01,3.194821630060e-01,-4.926875405950e-02], [-1.773384802648e+05,-6.478454644698e+04,9.273272200031e+03]), 3.066813191577e+00, TOL));
assert(isequalRel(angl([-2.562082617648e+04,-2.702645526995e+03,0.000000000000e+00], [7.082235690997e-01,3.194099442963e-01,-4.927138229845e-02]), 2.816979908228e+00, TOL));
assert(isequalRel(angl([7.082235690997e-01,3.194099442963e-01,-4.927138229845e-02], [-1.765696515146e+05,-6.965721976255e+04,1.027533063459e+04]), 3.092860814165e+00, TOL));
assert(isequalRel(angl([-2.562021842394e+04,-2.698973050069e+03,0.000000000000e+00], [7.082410893492e-01,3.193364850937e-01,-4.927363151653e-02]), 2.816936190293e+00, TOL));
assert(isequalRel(angl([7.082410893492e-01,3.193364850937e-01,-4.927363151653e-02], [-1.752686529907e+05,-7.431977625463e+04,1.124614177160e+04]), 3.118682005899e+00, TOL));
assert(isequalRel(angl([-2.561998152817e+04,-2.695527521424e+03,0.000000000000e+00], [7.082615145901e-01,3.192619035079e-01,-4.927551335956e-02]), 2.816902495394e+00, TOL));
assert(isequalRel(angl([7.082615145901e-01,3.192619035079e-01,-4.927551335956e-02], [-1.734445303961e+05,-7.876031560396e+04,1.218313775212e+04]), 3.138786542829e+00, TOL));
assert(isequalRel(angl([-2.562011017514e+04,-2.692309084274e+03,0.000000000000e+00], [7.082848176013e-01,3.191863199281e-01,-4.927704023752e-02]), 2.816878700664e+00, TOL));
assert(isequalRel(angl([7.082848176013e-01,3.191863199281e-01,-4.927704023752e-02], [-1.711041481365e+05,-8.296621323591e+04,1.308365278381e+04]), 3.113054887318e+00, TOL));
assert(isequalRel(angl([-2.562059831417e+04,-2.689317425643e+03,0.000000000000e+00], [7.083109661082e-01,3.191098568950e-01,-4.927822532763e-02]), 2.816864662733e+00, TOL));
assert(isequalRel(angl([7.083109661082e-01,3.191098568950e-01,-4.927822532763e-02], [-1.682523154380e+05,-8.692389363433e+04,1.394487382716e+04]), 3.087188664041e+00, TOL));
assert(isequalRel(angl([-2.562143916398e+04,-2.686551773905e+03,0.000000000000e+00], [7.083399227635e-01,3.190326389659e-01,-4.927908257683e-02]), 2.816860217758e+00, TOL));
assert(isequalRel(angl([7.083399227635e-01,3.190326389659e-01,-4.927908257683e-02], [-1.648918683289e+05,-9.061858225954e+04,1.476378794247e+04]), 3.061064833917e+00, TOL));
assert(isequalRel(angl([-2.562262521985e+04,-2.684010896878e+03,0.000000000000e+00], [7.083716451347e-01,3.189547925769e-01,-4.927962670469e-02]), 2.816865181478e+00, TOL));
assert(isequalRel(angl([7.083716451347e-01,3.189547925769e-01,-4.927962670469e-02], [-1.610237113982e+05,-9.403402398835e+04,1.553712375729e+04]), 3.034553756930e+00, TOL));
assert(isequalRel(angl([-2.562414826159e+04,-2.681693100338e+03,0.000000000000e+00], [7.084060856939e-01,3.188764459070e-01,-4.927987320827e-02]), 2.816879349296e+00, TOL));
assert(isequalRel(angl([7.084060856939e-01,3.188764459070e-01,-4.927987320827e-02], [-1.566468213673e+05,-9.715215370791e+04,1.626128409305e+04]), 3.007515548032e+00, TOL));
assert(isequalRel(angl([-2.562599936249e+04,-2.679596226730e+03,0.000000000000e+00], [7.084431918081e-01,3.187977287486e-01,-4.927983837095e-02]), 2.816902496357e+00, TOL));
assert(isequalRel(angl([7.084431918081e-01,3.187977287486e-01,-4.927983837095e-02], [-1.517582128574e+05,-9.995270098346e+04,1.693226607548e+04]), 2.979795766939e+00, TOL));
assert(isequalRel(angl([-2.562816889890e+04,-2.677717653734e+03,0.000000000000e+00], [7.084829057230e-01,3.187187723882e-01,-4.927953927778e-02]), 2.816934377608e+00, TOL));
assert(isequalRel(angl([7.084829057230e-01,3.187187723882e-01,-4.927953927778e-02], [-1.463528652128e+05,-1.024127050628e+05,1.754556394158e+04]), 2.951220106007e+00, TOL));
assert(isequalRel(angl([-2.563064656015e+04,-2.676054292142e+03,0.000000000000e+00], [7.085251645345e-01,3.186397095062e-01,-4.927899384152e-02]), 2.816974727812e+00, TOL));
assert(isequalRel(angl([7.085251645345e-01,3.186397095062e-01,-4.927899384152e-02], [-1.404236077744e+05,-1.045059079973e+05,1.809604807097e+04]), 2.921587609391e+00, TOL));
assert(isequalRel(angl([-2.563342135865e+04,-2.674602582203e+03,0.000000000000e+00], [7.085699001348e-01,3.185606741032e-01,-4.927822084503e-02]), 2.817023261457e+00, TOL));
assert(isequalRel(angl([7.085699001348e-01,3.185606741032e-01,-4.927822084503e-02], [-1.339609596185e+05,-1.062019809132e+05,1.857781121953e+04]), 2.890661747452e+00, TOL));
assert(isequalRel(angl([-2.563648163940e+04,-2.673358487111e+03,0.000000000000e+00], [7.086170391176e-01,3.184818014634e-01,-4.927724000921e-02]), 2.817079672495e+00, TOL));
assert(isequalRel(angl([7.086170391176e-01,3.184818014634e-01,-4.927724000921e-02], [-1.269529186001e+05,-1.074655190619e+05,1.898396903112e+04]), 2.858158333358e+00, TOL));
assert(isequalRel(angl([-2.563981508861e+04,-2.672317481546e+03,0.000000000000e+00], [7.086665026140e-01,3.184032281730e-01,-4.927607210054e-02]), 2.817143633795e+00, TOL));
assert(isequalRel(angl([7.086665026140e-01,3.184032281730e-01,-4.927607210054e-02], [-1.193846939645e+05,-1.082547111537e+05,1.930639581892e+04]), 2.823728714464e+00, TOL));

# 21897
assert(isequalRel(angl([-5.795127601818e+04,-1.881871302184e+04,0.000000000000e+00], [1.036315989774e-01,3.821545798631e-01,-6.273686484695e-01]), 1.867070619127e+00, TOL));
assert(isequalRel(angl([1.036315989774e-01,3.821545798631e-01,-6.273686484695e-01], [-1.941046286123e+04,-1.914303318969e+04,2.311405522619e+04]), 2.687451322260e+00, TOL));
assert(isequalRel(angl([-5.794832705092e+04,-1.880139161995e+04,0.000000000000e+00], [1.037114901353e-01,3.821905893750e-01,-6.274073584658e-01]), 1.867048334295e+00, TOL));
assert(isequalRel(angl([1.037114901353e-01,3.821905893750e-01,-6.274073584658e-01], [-1.268606129708e+04,-2.385375335645e+04,3.552981733588e+04]), 2.987505710749e+00, TOL));
assert(isequalRel(angl([-5.794965531699e+04,-1.878437964024e+04,0.000000000000e+00], [1.037394017177e-01,3.821831494718e-01,-6.274435143744e-01]), 1.866942661394e+00, TOL));
assert(isequalRel(angl([1.037394017177e-01,3.821831494718e-01,-6.274435143744e-01], [-2.775466493588e+03,-2.283964574119e+04,3.949464689967e+04]), 3.058909134387e+00, TOL));
assert(isequalRel(angl([-5.795573039356e+04,-1.876784575395e+04,0.000000000000e+00], [1.037536104123e-01,3.821349909813e-01,-6.274512229633e-01]), 1.866812496204e+00, TOL));
assert(isequalRel(angl([1.037536104123e-01,3.821349909813e-01,-6.274512229633e-01], [7.679878835699e+03,-1.678050760106e+04,3.468621815555e+04]), 2.791169349840e+00, TOL));
assert(isequalRel(angl([-5.797074033132e+04,-1.875229044183e+04,0.000000000000e+00], [1.038515854498e-01,3.820203591191e-01,-6.273984363226e-01]), 1.866782152768e+00, TOL));
assert(isequalRel(angl([1.038515854498e-01,3.820203591191e-01,-6.273984363226e-01], [1.455240023028e+04,-4.819501214612e+03,1.715470672449e+04]), 2.278298958344e+00, TOL));
assert(isequalRel(angl([-5.798570546213e+04,-1.874963618501e+04,0.000000000000e+00], [1.038946073948e-01,3.819418812403e-01,-6.274828158333e-01]), 1.866735944570e+00, TOL));
assert(isequalRel(angl([1.038946073948e-01,3.819418812403e-01,-6.274828158333e-01], [-1.530238845375e+04,-5.556434402997e+03,1.095950887533e+03]), 1.942770864677e+00, TOL));
assert(isequalRel(angl([-5.797654773831e+04,-1.873769393720e+04,0.000000000000e+00], [1.040912703836e-01,3.820100119644e-01,-6.273866602990e-01]), 1.866971348023e+00, TOL));
assert(isequalRel(angl([1.040912703836e-01,3.820100119644e-01,-6.273866602990e-01], [-1.928920066748e+04,-1.942704851118e+04,2.375945685636e+04]), 2.701998565017e+00, TOL));
assert(isequalRel(angl([-5.797377621804e+04,-1.872039714508e+04,0.000000000000e+00], [1.041681283795e-01,3.820436225275e-01,-6.274262013343e-01]), 1.866943988248e+00, TOL));
assert(isequalRel(angl([1.041681283795e-01,3.820436225275e-01,-6.274262013343e-01], [-1.237621976437e+04,-2.389338020018e+04,3.583133691892e+04]), 2.996922400116e+00, TOL));
assert(isequalRel(angl([-5.797526322620e+04,-1.870343097737e+04,0.000000000000e+00], [1.041947532128e-01,3.820343286172e-01,-6.274617641152e-01]), 1.866836400115e+00, TOL));
assert(isequalRel(angl([1.041947532128e-01,3.820343286172e-01,-6.274617641152e-01], [-2.400556776651e+03,-2.269862264640e+04,3.948275964390e+04]), 3.049878868060e+00, TOL));
assert(isequalRel(angl([-5.798155687115e+04,-1.868693302917e+04,0.000000000000e+00], [1.042091925155e-01,3.819840138663e-01,-6.274679785628e-01]), 1.866706413717e+00, TOL));
assert(isequalRel(angl([1.042091925155e-01,3.819840138663e-01,-6.274679785628e-01], [8.031668192521e+03,-1.645577592085e+04,3.429894391742e+04]), 2.778849375016e+00, TOL));
assert(isequalRel(angl([-5.799717450270e+04,-1.867155253587e+04,0.000000000000e+00], [1.043178179449e-01,3.818656223316e-01,-6.274127852405e-01]), 1.866689918001e+00, TOL));
assert(isequalRel(angl([1.043178179449e-01,3.818656223316e-01,-6.274127852405e-01], [1.455948780372e+04,-4.238437738131e+03,1.607923154704e+04]), 2.241275710107e+00, TOL));
assert(isequalRel(angl([-5.801075263897e+04,-1.866955730958e+04,0.000000000000e+00], [1.043560009002e-01,3.817905132654e-01,-6.274855432751e-01]), 1.866650645470e+00, TOL));
assert(isequalRel(angl([1.043560009002e-01,3.817905132654e-01,-6.274855432751e-01], [-1.603604980660e+04,-6.372514064680e+03,2.183448342318e+03]), 2.009102882130e+00, TOL));
assert(isequalRel(angl([-5.800183887488e+04,-1.865681023918e+04,0.000000000000e+00], [1.045501236889e-01,3.818626991848e-01,-6.274053812952e-01]), 1.866871479270e+00, TOL));
assert(isequalRel(angl([1.045501236889e-01,3.818626991848e-01,-6.274053812952e-01], [-1.915671583814e+04,-1.969889059957e+04,2.438929473934e+04]), 2.716133347635e+00, TOL));
assert(isequalRel(angl([-5.799923754307e+04,-1.863954064127e+04,0.000000000000e+00], [1.046241295702e-01,3.818939781727e-01,-6.274456803213e-01]), 1.866839364719e+00, TOL));
assert(isequalRel(angl([1.046241295702e-01,3.818939781727e-01,-6.274456803213e-01], [-1.206272925552e+04,-2.392582362911e+04,3.612066680667e+04]), 3.006257125092e+00, TOL));
assert(isequalRel(angl([-5.800087930275e+04,-1.862261964198e+04,0.000000000000e+00], [1.046495894360e-01,3.818828655120e-01,-6.274806527263e-01]), 1.866730039387e+00, TOL));
assert(isequalRel(angl([1.046495894360e-01,3.818828655120e-01,-6.274806527263e-01], [-2.024961369658e+03,-2.255156626703e+04,3.945850085787e+04]), 3.040816397651e+00, TOL));
assert(isequalRel(angl([-5.800739137458e+04,-1.860615646057e+04,0.000000000000e+00], [1.046644267092e-01,3.818303908108e-01,-6.274853597407e-01]), 1.866600455345e+00, TOL));
assert(isequalRel(angl([1.046644267092e-01,3.818303908108e-01,-6.274853597407e-01], [8.379809162036e+03,-1.612395878459e+04,3.389475123231e+04]), 2.766276901599e+00, TOL));
assert(isequalRel(angl([-5.802365426808e+04,-1.859098823682e+04,0.000000000000e+00], [1.047852503453e-01,3.817083939556e-01,-6.274281094372e-01]), 1.866599926316e+00, TOL));
assert(isequalRel(angl([1.047852503453e-01,3.817083939556e-01,-6.274281094372e-01], [1.452786748873e+04,-3.646338171202e+03,1.496074306518e+04]), 2.201086032612e+00, TOL));
assert(isequalRel(angl([-5.803575362751e+04,-1.858947045321e+04,0.000000000000e+00], [1.048186067723e-01,3.816384276642e-01,-6.274906860048e-01]), 1.866566341264e+00, TOL));
assert(isequalRel(angl([1.048186067723e-01,3.816384276642e-01,-6.274906860048e-01], [-1.668012147335e+04,-7.149808004251e+03,3.257642272081e+03]), 2.067738535875e+00, TOL));
assert(isequalRel(angl([-5.802712071832e+04,-1.857605874346e+04,0.000000000000e+00], [1.050086169707e-01,3.817128307768e-01,-6.274249877448e-01]), 1.866771641191e+00, TOL));
assert(isequalRel(angl([1.050086169707e-01,3.817128307768e-01,-6.274249877448e-01], [-1.901358793448e+04,-1.995893766022e+04,2.500381778666e+04]), 2.729884161534e+00, TOL));
assert(isequalRel(angl([-5.802468204802e+04,-1.855881730762e+04,0.000000000000e+00], [1.050799414634e-01,3.817418572559e-01,-6.274659726035e-01]), 1.866735069323e+00, TOL));
assert(isequalRel(angl([1.050799414634e-01,3.817418572559e-01,-6.274659726035e-01], [-1.174576155818e+04,-2.395119438627e+04,3.639787676581e+04]), 3.015515314817e+00, TOL));
assert(isequalRel(angl([-5.802647420268e+04,-1.854193954647e+04,0.000000000000e+00], [1.051043520485e-01,3.817289725508e-01,-6.275003500748e-01]), 1.866624173205e+00, TOL));
assert(isequalRel(angl([1.051043520485e-01,3.817289725508e-01,-6.275003500748e-01], [-1.648819450702e+03,-2.239850594576e+04,3.942183273890e+04]), 3.031717606138e+00, TOL));
assert(isequalRel(angl([-5.803320443672e+04,-1.852550875097e+04,0.000000000000e+00], [1.051197541601e-01,3.816743437108e-01,-6.275035271052e-01]), 1.866495211266e+00, TOL));
assert(isequalRel(angl([1.051197541601e-01,3.816743437108e-01,-6.275035271052e-01], [8.723976527952e+03,-1.578499406275e+04,3.347335215527e+04]), 2.753435516193e+00, TOL));
assert(isequalRel(angl([-5.805015460481e+04,-1.851060018646e+04,0.000000000000e+00], [1.052545605297e-01,3.815490267474e-01,-6.274447320709e-01]), 1.866513108181e+00, TOL));
assert(isequalRel(angl([1.052545605297e-01,3.815490267474e-01,-6.274447320709e-01], [1.445225571587e+04,-3.043423326450e+03,1.379684870805e+04]), 2.157187141731e+00, TOL));
assert(isequalRel(angl([-5.806070088596e+04,-1.850939284256e+04,0.000000000000e+00], [1.052821768240e-01,3.814853809433e-01,-6.274984019837e-01]), 1.866482753617e+00, TOL));
assert(isequalRel(angl([1.052821768240e-01,3.814853809433e-01,-6.274984019837e-01], [-1.724631075678e+04,-7.890726015081e+03,4.315394103066e+03]), 2.120113766971e+00, TOL));

# 22312
assert(isequalRel(angl([9.971345638261e+03,4.437679820324e+04,0.000000000000e+00], [1.196695179114e-02,-3.695710357492e-03,-2.363881036718e-02]), 1.607522735181e+00, TOL));
assert(isequalRel(angl([1.196695179114e-02,-3.695710357492e-03,-2.363881036718e-02], [3.061047845321e+02,-5.816456555246e+03,-2.979558460681e+03]), 9.930012723255e-01, TOL));
assert(isequalRel(angl([1.002595500108e+04,4.429597665741e+04,0.000000000000e+00], [1.074975997096e-02,-4.050770194567e-03,-2.152457274185e-02]), 1.635508454140e+00, TOL));
assert(isequalRel(angl([1.074975997096e-02,-4.050770194567e-03,-2.152457274185e-02], [3.282820854640e+03,2.077469729049e+03,-5.189179887704e+03]), 5.029815553106e-01, TOL));
assert(isequalRel(angl([1.005365052212e+04,4.431084792802e+04,0.000000000000e+00], [1.054523561933e-02,-2.820756199036e-03,-2.065689348295e-02]), 1.588668716231e+00, TOL));
assert(isequalRel(angl([1.054523561933e-02,-2.820756199036e-03,-2.065689348295e-02], [5.308272917598e+02,6.426207900027e+03,1.712370767934e+03]), 1.883160080065e+00, TOL));
assert(isequalRel(angl([1.008831658324e+04,4.420844692085e+04,0.000000000000e+00], [1.062161629164e-02,-3.114360300471e-03,-2.089386150722e-02]), 1.599272251853e+00, TOL));
assert(isequalRel(angl([1.062161629164e-02,-3.114360300471e-03,-2.089386150722e-02], [-3.191691702120e+03,1.702721991216e+02,5.956298077747e+03]), 3.032540416642e+00, TOL));
assert(isequalRel(angl([1.014208569396e+04,4.423545405445e+04,0.000000000000e+00], [9.205929604240e-03,-3.621867187711e-03,-1.852756406412e-02]), 1.640983876305e+00, TOL));
assert(isequalRel(angl([9.205929604240e-03,-3.621867187711e-03,-1.852756406412e-02], [-1.818992224649e+03,-6.322451466164e+03,6.819524715393e+02]), 1.617468843528e+00, TOL));
assert(isequalRel(angl([1.015462197261e+04,4.413700476431e+04,0.000000000000e+00], [8.472437633250e-03,-2.250073708766e-03,-1.656990159837e-02]), 1.586435480047e+00, TOL));
assert(isequalRel(angl([8.472437633250e-03,-2.250073708766e-03,-1.656990159837e-02], [2.515664486339e+03,-2.158830912240e+03,-5.552133205438e+03]), 2.247946796561e-01, TOL));
assert(isequalRel(angl([1.022252980211e+04,4.414890194892e+04,0.000000000000e+00], [8.538581446375e-03,-2.301239825585e-03,-1.673534630025e-02]), 1.587481497500e+00, TOL));
assert(isequalRel(angl([8.538581446375e-03,-2.301239825585e-03,-1.673534630025e-02], [2.414528332105e+03,5.749101509221e+03,-1.998596931649e+03]), 1.235065384670e+00, TOL));
assert(isequalRel(angl([1.022669939966e+04,4.407240908743e+04,0.000000000000e+00], [7.751882110092e-03,-3.160303348835e-03,-1.563709363198e-02]), 1.645642133402e+00, TOL));
assert(isequalRel(angl([7.751882110092e-03,-3.160303348835e-03,-1.563709363198e-02], [-1.877989443311e+03,3.862278483018e+03,5.112484358627e+03]), 2.692951932245e+00, TOL));
assert(isequalRel(angl([1.029900387158e+04,4.404797140268e+04,0.000000000000e+00], [7.077726049730e-03,-1.904261236916e-03,-1.386520231045e-02]), 1.586281283572e+00, TOL));
assert(isequalRel(angl([7.077726049730e-03,-1.904261236916e-03,-1.386520231045e-02], [-3.117365843953e+03,-4.419747738641e+03,3.840859609123e+03]), 2.269288610820e+00, TOL));
assert(isequalRel(angl([1.030592961208e+04,4.401592037590e+04,0.000000000000e+00], [6.693383025519e-03,-1.772721557225e-03,-1.310027699713e-02]), 1.584301917934e+00, TOL));
assert(isequalRel(angl([6.693383025519e-03,-1.772721557225e-03,-1.310027699713e-02], [8.153203467830e+02,-5.231676922491e+03,-3.760046903535e+03]), 8.433243046386e-01, TOL));
assert(isequalRel(angl([1.037072557831e+04,4.395246457545e+04,0.000000000000e+00], [5.646346987786e-03,-2.522597503891e-03,-1.149369017389e-02]), 1.659675810435e+00, TOL));
assert(isequalRel(angl([5.646346987786e-03,-2.522597503891e-03,-1.149369017389e-02], [3.269543418101e+03,3.029000810825e+03,-4.704679697131e+03]), 6.963097470980e-01, TOL));
assert(isequalRel(angl([1.038885484838e+04,4.395064069252e+04,0.000000000000e+00], [5.178329995608e-03,-1.547652650061e-03,-1.021584489802e-02]), 1.598050034780e+00, TOL));
assert(isequalRel(angl([5.178329995608e-03,-1.547652650061e-03,-1.021584489802e-02], [-1.018099755532e+01,6.026233414534e+03,2.643505184071e+03]), 2.069636245312e+00, TOL));
assert(isequalRel(angl([1.043787084151e+04,4.385747423817e+04,0.000000000000e+00], [5.332443810257e-03,-1.122360405157e-03,-1.030296506054e-02]), 1.558548460663e+00, TOL));
assert(isequalRel(angl([5.332443810257e-03,-1.122360405157e-03,-1.030296506054e-02], [-3.320588195837e+03,-1.248426799446e+03,5.563060179268e+03]), 2.848521777107e+00, TOL));
assert(isequalRel(angl([1.047675896685e+04,4.388101668655e+04,0.000000000000e+00], [4.129925804556e-03,-2.042476226677e-03,-8.506362121953e-03]), 1.677215807513e+00, TOL));
assert(isequalRel(angl([4.129925804556e-03,-2.042476226677e-03,-8.506362121953e-03], [-1.025489746164e+03,-6.366989457818e+03,-9.112355915263e+02]), 1.305496769912e+00, TOL));
assert(isequalRel(angl([1.050603983198e+04,4.377297073318e+04,0.000000000000e+00], [2.994836688099e-03,-1.142124189390e-03,-6.011167240207e-03]), 1.631258586099e+00, TOL));
assert(isequalRel(angl([2.994836688099e-03,-1.142124189390e-03,-6.011167240207e-03], [3.003759961276e+03,-4.138570800321e+02,-5.706155914353e+03]), 1.066893958335e-01, TOL));
assert(isequalRel(angl([1.056188777241e+04,4.379988638765e+04,0.000000000000e+00], [3.233897039313e-03,-3.039331667020e-04,-6.089321813423e-03]), 1.503712914562e+00, TOL));
assert(isequalRel(angl([3.233897039313e-03,-3.039331667020e-04,-6.089321813423e-03], [1.731428169801e+03,6.258276769247e+03,-4.093252798221e+02]), 1.432509797150e+00, TOL));
assert(isequalRel(angl([1.057625305759e+04,4.369614036308e+04,0.000000000000e+00], [2.851861344650e-03,-1.345526264365e-03,-5.840698778507e-03]), 1.666893388222e+00, TOL));
assert(isequalRel(angl([2.851861344650e-03,-1.345526264365e-03,-5.840698778507e-03], [-2.582521114602e+03,2.024190206799e+03,5.647556502679e+03]), 3.027959831728e+00, TOL));
assert(isequalRel(angl([1.064597499490e+04,4.370914159015e+04,0.000000000000e+00], [1.562232177623e-03,-9.786599752102e-04,-3.312942696322e-03]), 1.724692671510e+00, TOL));
assert(isequalRel(angl([1.562232177623e-03,-9.786599752102e-04,-3.312942696322e-03], [-2.440568485779e+03,-5.702773118774e+03,1.934810946889e+03]), 1.760342307590e+00, TOL));
assert(isequalRel(angl([1.065063568027e+04,4.362641215024e+04,0.000000000000e+00], [1.131800908539e-03,2.940180208521e-04,-1.947976042249e-03]), 1.324450872461e+00, TOL));
assert(isequalRel(angl([1.131800908539e-03,2.940180208521e-04,-1.947976042249e-03], [1.951229343914e+03,-3.423594430447e+03,-5.121678082006e+03]), 7.053563004316e-01, TOL));
assert(isequalRel(angl([1.072582074621e+04,4.361361700563e+04,0.000000000000e+00], [8.480851454081e-04,-3.753258619029e-04,-1.728802158310e-03]), 1.653430969282e+00, TOL));
assert(isequalRel(angl([8.480851454081e-04,-3.753258619029e-04,-1.728802158310e-03], [2.886509393556e+03,4.888686262157e+03,-3.096298859890e+03]), 1.081212776615e+00, TOL));
assert(isequalRel(angl([1.072957978227e+04,4.355905430704e+04,0.000000000000e+00], [4.912537182218e-06,-6.742648178917e-04,-3.141851492840e-04]), 2.643551526408e+00, TOL));
assert(isequalRel(angl([4.912537182218e-06,-6.742648178917e-04,-3.141851492840e-04], [-1.276555321818e+03,4.553268984633e+03,4.406197873753e+03]), 2.759150859053e+00, TOL));
assert(isequalRel(angl([1.080227492829e+04,4.351510418097e+04,0.000000000000e+00], [-3.717272632119e-04,6.180102749590e-04,9.645592635301e-04]), 1.133310168534e+00, TOL));
assert(isequalRel(angl([-3.717272632119e-04,6.180102749590e-04,9.645592635301e-04], [-3.181546980418e+03,-3.831299765064e+03,4.096802427872e+03]), 1.206589309560e+00, TOL));

# *** error: t:= 494.202867 *** code =   1

# 22674
assert(isequalRel(angl([6.053169236113e+04,-5.950493505451e+03,0.000000000000e+00], [-2.462109484617e-01,-3.001954160800e-01,-6.468449018822e-01]), 1.860704721200e+00, TOL));
assert(isequalRel(angl([-2.462109484617e-01,-3.001954160800e-01,-6.468449018822e-01], [2.541888807860e+04,9.342603079886e+03,2.361146690798e+04]), 2.685592796046e+00, TOL));
assert(isequalRel(angl([6.052230709550e+04,-5.966010157636e+03,0.000000000000e+00], [-2.463015309978e-01,-3.001906801607e-01,-6.468777756952e-01]), 1.860687821516e+00, TOL));
assert(isequalRel(angl([-2.463015309978e-01,-3.001906801607e-01,-6.468777756952e-01], [2.161959550749e+04,1.612524978864e+04,3.639679365831e+04]), 2.975858362533e+00, TOL));
assert(isequalRel(angl([6.051704657828e+04,-5.982838637341e+03,0.000000000000e+00], [-2.463277426825e-01,-3.001675596045e-01,-6.469079323883e-01]), 1.860590282288e+00, TOL));
assert(isequalRel(angl([-2.463277426825e-01,-3.001675596045e-01,-6.469079323883e-01], [1.272150543331e+04,1.925896193362e+04,4.089847648359e+04]), 3.083084062702e+00, TOL));
assert(isequalRel(angl([6.051619699055e+04,-6.000954089142e+03,0.000000000000e+00], [-2.463251123232e-01,-3.001168518388e-01,-6.469117372869e-01]), 1.860467570715e+00, TOL));
assert(isequalRel(angl([-2.463251123232e-01,-3.001168518388e-01,-6.469117372869e-01], [1.272807600538e+03,1.845841971897e+04,3.704474742696e+04]), 2.838521296736e+00, TOL));
assert(isequalRel(angl([6.052261114860e+04,-6.021522049043e+03,0.000000000000e+00], [-2.463493347213e-01,-2.999934295930e-01,-6.468604098023e-01]), 1.860405774666e+00, TOL));
assert(isequalRel(angl([-2.463493347213e-01,-2.999934295930e-01,-6.468604098023e-01], [-1.005843188619e+04,1.190660764454e+04,2.173962097733e+04]), 2.420477041830e+00, TOL));
assert(isequalRel(angl([6.053815968670e+04,-6.036640662136e+03,0.000000000000e+00], [-2.464068263950e-01,-2.998881854978e-01,-6.469880786474e-01]), 1.860366067884e+00, TOL));
assert(isequalRel(angl([-2.464068263950e-01,-2.998881854978e-01,-6.469880786474e-01], [1.092440116466e+04,-2.571924141697e+03,-2.956348562941e+03]), 1.571691104696e+00, TOL));
assert(isequalRel(angl([6.052728355556e+04,-6.040179322794e+03,0.000000000000e+00], [-2.465782061318e-01,-2.998381921042e-01,-6.468160344078e-01]), 1.860619047379e+00, TOL));
assert(isequalRel(angl([-2.465782061318e-01,-2.998381921042e-01,-6.468160344078e-01], [2.533214851525e+04,8.398910999243e+03,2.178390654357e+04]), 2.645476966811e+00, TOL));
assert(isequalRel(angl([6.051751662080e+04,-6.055391026490e+03,0.000000000000e+00], [-2.466795798636e-01,-2.998343084231e-01,-6.468456282226e-01]), 1.860618317427e+00, TOL));
assert(isequalRel(angl([-2.466795798636e-01,-2.998343084231e-01,-6.468456282226e-01], [2.231771926039e+04,1.557482086129e+04,3.549577144092e+04]), 2.951373432026e+00, TOL));
assert(isequalRel(angl([6.051191319898e+04,-6.072024914509e+03,0.000000000000e+00], [-2.467111819231e-01,-2.998125966401e-01,-6.468765865907e-01]), 1.860527983530e+00, TOL));
assert(isequalRel(angl([-2.467111819231e-01,-2.998125966401e-01,-6.468765865907e-01], [1.379568675885e+04,1.908883051008e+04,4.080369584385e+04]), 3.105474980275e+00, TOL));
assert(isequalRel(angl([6.051061893109e+04,-6.089897608707e+03,0.000000000000e+00], [-2.467109022176e-01,-2.997650146749e-01,-6.468832586679e-01]), 1.860407861990e+00, TOL));
assert(isequalRel(angl([-2.467109022176e-01,-2.997650146749e-01,-6.468832586679e-01], [2.515171450487e+03,1.874663776282e+04,3.786458088636e+04]), 2.866755493139e+00, TOL));
assert(isequalRel(angl([6.051598106110e+04,-6.110061054966e+03,0.000000000000e+00], [-2.467258993893e-01,-2.996539078717e-01,-6.468387725370e-01]), 1.860331086520e+00, TOL));
assert(isequalRel(angl([-2.467258993893e-01,-2.996539078717e-01,-6.468387725370e-01], [-9.084486021062e+03,1.298262608646e+04,2.404563900249e+04]), 2.484691555993e+00, TOL));
assert(isequalRel(angl([6.052519497260e+04,-6.128118508886e+03,0.000000000000e+00], [-2.469130892230e-01,-2.995310458542e-01,-6.468620124546e-01]), 1.860467889923e+00, TOL));
assert(isequalRel(angl([-2.469130892230e-01,-2.995310458542e-01,-6.468620124546e-01], [5.647009094950e+03,-3.293905186928e+03,-5.425852350631e+03]), 1.065570636840e+00, TOL));
assert(isequalRel(angl([6.052328212639e+04,-6.129440924816e+03,0.000000000000e+00], [-2.469486187646e-01,-2.994769198091e-01,-6.467838730979e-01]), 1.860543628663e+00, TOL));
assert(isequalRel(angl([-2.469486187646e-01,-2.994769198091e-01,-6.467838730979e-01], [2.511163372210e+04,7.412551094883e+03,1.984425781729e+04]), 2.601631683239e+00, TOL));
assert(isequalRel(angl([6.051309212516e+04,-6.144292735101e+03,0.000000000000e+00], [-2.470619392286e-01,-2.994738965704e-01,-6.468093704131e-01]), 1.860561136846e+00, TOL));
assert(isequalRel(angl([-2.470619392286e-01,-2.994738965704e-01,-6.468093704131e-01], [2.296147461641e+04,1.498574459578e+04,3.451109257381e+04]), 2.926221972581e+00, TOL));
assert(isequalRel(angl([6.050711806990e+04,-6.160717800665e+03,0.000000000000e+00], [-2.470994254522e-01,-2.994536426967e-01,-6.468411393192e-01]), 1.860478674924e+00, TOL));
assert(isequalRel(angl([-2.470994254522e-01,-2.994536426967e-01,-6.468411393192e-01], [1.484115301459e+04,1.887691439870e+04,4.062625901619e+04]), 3.127743379030e+00, TOL));
assert(isequalRel(angl([6.050536873621e+04,-6.178344500930e+03,0.000000000000e+00], [-2.471020022727e-01,-2.994090181277e-01,-6.468506544264e-01]), 1.860361827154e+00, TOL));
assert(isequalRel(angl([-2.471020022727e-01,-2.994090181277e-01,-6.468506544264e-01], [3.750701740805e+03,1.897857939698e+04,3.857811783220e+04]), 2.893825773177e+00, TOL));
assert(isequalRel(angl([6.050979033302e+04,-6.198104145358e+03,0.000000000000e+00], [-2.471109298729e-01,-2.993083640667e-01,-6.468127928057e-01]), 1.860274653863e+00, TOL));
assert(isequalRel(angl([-2.471109298729e-01,-2.993083640667e-01,-6.468127928057e-01], [-8.027302194887e+03,1.393954436955e+04,2.613649045637e+04]), 2.540617352582e+00, TOL));
assert(isequalRel(angl([6.051084378563e+04,-6.207116974537e+03,0.000000000000e+00], [-2.471901722525e-01,-2.991541029255e-01,-6.465573743613e-01]), 1.860440857142e+00, TOL));
assert(isequalRel(angl([-2.471901722525e-01,-2.991541029255e-01,-6.465573743613e-01], [-1.296956570925e+03,-2.813693697683e+03,-5.871095872577e+03]), 1.379633086621e-01, TOL));
assert(isequalRel(angl([6.051951014739e+04,-6.218224304976e+03,0.000000000000e+00], [-2.473228087639e-01,-2.991124850075e-01,-6.467501105504e-01]), 1.860478694472e+00, TOL));
assert(isequalRel(angl([-2.473228087639e-01,-2.991124850075e-01,-6.467501105504e-01], [2.473860364819e+04,6.383416440188e+03,1.778727631900e+04]), 2.553148562530e+00, TOL));
assert(isequalRel(angl([6.050885362407e+04,-6.232651397095e+03,0.000000000000e+00], [-2.474493141299e-01,-2.991102821918e-01,-6.467703920258e-01]), 1.860516796423e+00, TOL));
assert(isequalRel(angl([-2.474493141299e-01,-2.991102821918e-01,-6.467703920258e-01], [2.354685388669e+04,1.435815602832e+04,3.344167679479e+04]), 2.900284963886e+00, TOL));
assert(isequalRel(angl([6.050247936764e+04,-6.248856736465e+03,0.000000000000e+00], [-2.474931483770e-01,-2.990915560581e-01,-6.468029740378e-01]), 1.860442803846e+00, TOL));
assert(isequalRel(angl([-2.474931483770e-01,-2.990915560581e-01,-6.468029740378e-01], [1.585587696303e+04,1.862405633582e+04,4.036713420574e+04]), 3.133228268447e+00, TOL));
assert(isequalRel(angl([6.050026137150e+04,-6.266237601436e+03,0.000000000000e+00], [-2.474990019672e-01,-2.990497727717e-01,-6.468153345190e-01]), 1.860329754486e+00, TOL));
assert(isequalRel(angl([-2.474990019672e-01,-2.990497727717e-01,-6.468153345190e-01], [4.976449335906e+03,1.915675504042e+04,3.918968603184e+04]), 2.919904126463e+00, TOL));
assert(isequalRel(angl([6.050381919331e+04,-6.285605136221e+03,0.000000000000e+00], [-2.475040924484e-01,-2.989581288572e-01,-6.467838197182e-01]), 1.860235412064e+00, TOL));
assert(isequalRel(angl([-2.475040924484e-01,-2.989581288572e-01,-6.467838197182e-01], [-6.909207462100e+03,1.479044707042e+04,2.803446732222e+04]), 2.590221256645e+00, TOL));
assert(isequalRel(angl([6.052385409381e+04,-6.294261114223e+03,0.000000000000e+00], [-2.477660300617e-01,-2.988439551761e-01,-6.469017039751e-01]), 1.860508094078e+00, TOL));
assert(isequalRel(angl([-2.477660300617e-01,-2.988439551761e-01,-6.469017039751e-01], [-7.331650067070e+03,-6.041732341856e+02,-2.723510145754e+03]), 8.825920402955e-01, TOL));

# 23177
assert(isequalRel(angl([-8.314124391911e+03,2.026439553109e+00,0.000000000000e+00], [-3.167352498695e-01,6.487013209060e-01,-7.993629962759e-02]), 1.119306395666e+00, TOL));
assert(isequalRel(angl([-3.167352498695e-01,6.487013209060e-01,-7.993629962759e-02], [-1.684343528577e+03,-3.155595196340e+04,3.888999443194e+03]), 2.637418480129e+00, TOL));
assert(isequalRel(angl([-8.315767609425e+03,9.098317733500e+00,0.000000000000e+00], [-3.170252254862e-01,6.485038373041e-01,-7.988535349719e-02]), 1.117981665950e+00, TOL));
assert(isequalRel(angl([-3.170252254862e-01,6.485038373041e-01,-7.988535349719e-02], [1.232551410155e+04,-3.898215046244e+04,4.802888322754e+03]), 2.993942370793e+00, TOL));
assert(isequalRel(angl([-8.316919124894e+03,1.550904575195e+01,0.000000000000e+00], [-3.173057779990e-01,6.483746204986e-01,-7.985084851130e-02]), 1.116789626118e+00, TOL));
assert(isequalRel(angl([-3.173057779990e-01,6.483746204986e-01,-7.985084851130e-02], [2.277366831936e+04,-3.434802176606e+04,4.228774073906e+03]), 3.011729121712e+00, TOL));
assert(isequalRel(angl([-8.317583597228e+03,2.130387043626e+01,0.000000000000e+00], [-3.176411558058e-01,6.482838467372e-01,-7.982886307540e-02]), 1.115627154411e+00, TOL));
assert(isequalRel(angl([-3.176411558058e-01,6.482838467372e-01,-7.982886307540e-02], [2.619440441089e+04,-1.948294203672e+04,2.393847740627e+03]), 2.666524959268e+00, TOL));
assert(isequalRel(angl([-8.315603525891e+03,2.321155625182e+01,0.000000000000e+00], [-3.181627367973e-01,6.480605502001e-01,-7.979771739279e-02]), 1.114617353974e+00, TOL));
assert(isequalRel(angl([-3.181627367973e-01,6.480605502001e-01,-7.979771739279e-02], [8.893505734480e+03,5.763388905608e+03,-7.136988416357e+02]), 1.445727592792e+00, TOL));
assert(isequalRel(angl([-8.315011736723e+03,2.991788562259e+01,0.000000000000e+00], [-3.186218741442e-01,6.478687776793e-01,-7.972007944721e-02]), 1.113127926414e+00, TOL));
assert(isequalRel(angl([-3.186218741442e-01,6.478687776793e-01,-7.972007944721e-02], [-6.028756865366e+03,-2.564899913786e+04,3.164371072739e+03]), 2.458314087655e+00, TOL));
assert(isequalRel(angl([-8.316686004321e+03,3.740215835367e+01,0.000000000000e+00], [-3.189375293371e-01,6.476408228750e-01,-7.965961712631e-02]), 1.111703816876e+00, TOL));
assert(isequalRel(angl([-3.189375293371e-01,6.476408228750e-01,-7.965961712631e-02], [8.313572990560e+03,-3.814645710922e+04,4.697807775347e+03]), 2.899985976628e+00, TOL));
assert(isequalRel(angl([-8.318039827290e+03,4.401435645210e+01,0.000000000000e+00], [-3.192135434731e-01,6.474918690273e-01,-7.962043630526e-02]), 1.110481878179e+00, TOL));
assert(isequalRel(angl([-3.192135434731e-01,6.474918690273e-01,-7.962043630526e-02], [2.018129108622e+04,-3.684260674073e+04,4.529125682184e+03]), 3.098679035442e+00, TOL));
assert(isequalRel(angl([-8.318864560974e+03,5.008486057701e+01,0.000000000000e+00], [-3.195242165988e-01,6.473912001920e-01,-7.959385441631e-02]), 1.109311534565e+00, TOL));
assert(isequalRel(angl([-3.195242165988e-01,6.473912001920e-01,-7.959385441631e-02], [2.630261794569e+04,-2.517339539436e+04,3.084653099862e+03]), 2.793493214000e+00, TOL));
assert(isequalRel(angl([-8.319114387072e+03,5.435083279299e+01,0.000000000000e+00], [-3.199654453074e-01,6.472739112473e-01,-7.958025479742e-02]), 1.108185819243e+00, TOL));
assert(isequalRel(angl([-3.199654453074e-01,6.472739112473e-01,-7.958025479742e-02], [1.936507045602e+04,-2.700004901218e+03,3.174272741652e+02]), 2.166395817509e+00, TOL));
assert(isequalRel(angl([-8.316389286961e+03,5.783464326496e+01,0.000000000000e+00], [-3.204762197525e-01,6.470354006473e-01,-7.950816962278e-02]), 1.106987767288e+00, TOL));
assert(isequalRel(angl([-3.204762197525e-01,6.470354006473e-01,-7.950816962278e-02], [-9.667818787801e+03,-1.693019112642e+04,2.095874690342e+03]), 2.169100857506e+00, TOL));
assert(isequalRel(angl([-8.317644738918e+03,6.581425551718e+01,0.000000000000e+00], [-3.208467903932e-01,6.467755309769e-01,-7.943243056504e-02]), 1.105416524051e+00, TOL));
assert(isequalRel(angl([-3.208467903932e-01,6.467755309769e-01,-7.943243056504e-02], [4.021314385831e+03,-3.606609209609e+04,4.442915874109e+03]), 2.794279417344e+00, TOL));

# 23333
assert(isequalRel(angl([2.131413167029e+04,1.539657561431e+03,0.000000000000e+00], [8.337304742625e-01,4.768098192576e-01,2.425757120538e-01]), 5.071542112866e-01, TOL));
assert(isequalRel(angl([8.337304742625e-01,4.768098192576e-01,2.425757120538e-01], [-4.467291239679e+04,-6.213119965811e+03,-1.738801317270e+03]), 2.710920576748e+00, TOL));
assert(isequalRel(angl([2.124627720339e+04,1.542220228683e+03,0.000000000000e+00], [8.336746967216e-01,4.770504154429e-01,2.425804684131e-01]), 5.070592051936e-01, TOL));
assert(isequalRel(angl([8.336746967216e-01,4.770504154429e-01,2.425804684131e-01], [-6.705308885387e+04,-1.499469685946e+04,-5.897990727927e+03]), 2.804969305754e+00, TOL));
assert(isequalRel(angl([2.118214100976e+04,1.542072903780e+03,0.000000000000e+00], [8.336218315652e-01,4.772475731300e-01,2.426269384906e-01]), 5.070686522320e-01, TOL));
assert(isequalRel(angl([8.336218315652e-01,4.772475731300e-01,2.426269384906e-01], [-8.522784253168e+04,-2.289708484471e+04,-9.722591845641e+03]), 2.853418125097e+00, TOL));
assert(isequalRel(angl([2.112176281739e+04,1.540963941268e+03,0.000000000000e+00], [8.335678018092e-01,4.774278771379e-01,2.426894877315e-01]), 5.071228184989e-01, TOL));
assert(isequalRel(angl([8.335678018092e-01,4.774278771379e-01,2.426894877315e-01], [-1.009860041914e+05,-3.017119698695e+04,-1.328377044765e+04]), 2.885019187817e+00, TOL));
assert(isequalRel(angl([2.106522493458e+04,1.539388422466e+03,0.000000000000e+00], [8.335112086210e-01,4.775992278889e-01,2.427602438822e-01]), 5.072052372828e-01, TOL));
assert(isequalRel(angl([8.335112086210e-01,4.775992278889e-01,2.427602438822e-01], [-1.150930068639e+05,-3.696256316477e+04,-1.663415682929e+04]), 2.908057142832e+00, TOL));
assert(isequalRel(angl([2.101264525816e+04,1.537551184867e+03,0.000000000000e+00], [8.334514152920e-01,4.777648666351e-01,2.428358145850e-01]), 5.073093700015e-01, TOL));
assert(isequalRel(angl([8.334514152920e-01,4.777648666351e-01,2.428358145850e-01], [-1.279658006489e+05,-4.336332967165e+04,-1.980990480432e+04]), 2.925984490012e+00, TOL));
assert(isequalRel(angl([2.096415478982e+04,1.535556469203e+03,0.000000000000e+00], [8.333880857987e-01,4.779263499253e-01,2.429144306621e-01]), 5.074320745831e-01, TOL));
assert(isequalRel(angl([8.333880857987e-01,4.779263499253e-01,2.429144306621e-01], [-1.398632833221e+05,-4.943645704153e+04,-2.283680438139e+04]), 2.940546063766e+00, TOL));
assert(isequalRel(angl([2.091988668608e+04,1.533464997789e+03,0.000000000000e+00], [8.333210286856e-01,4.780844867358e-01,2.429950432539e-01]), 5.075716479150e-01, TOL));
assert(isequalRel(angl([8.333210286856e-01,4.780844867358e-01,2.429950432539e-01], [-1.509602297826e+05,-5.522745413896e+04,-2.573401408879e+04]), 2.952737452853e+00, TOL));
assert(isequalRel(angl([2.087997061588e+04,1.531315681029e+03,0.000000000000e+00], [8.332501324513e-01,4.782397076106e-01,2.430769684072e-01]), 5.077270831945e-01, TOL));
assert(isequalRel(angl([8.332501324513e-01,4.782397076106e-01,2.430769684072e-01], [-1.613817141463e+05,-6.077064040903e+04,-2.851626290017e+04]), 2.963176615147e+00, TOL));
assert(isequalRel(angl([2.084452948970e+04,1.529135226098e+03,0.000000000000e+00], [8.331753349111e-01,4.783922332308e-01,2.431597252916e-01]), 5.078977411021e-01, TOL));
assert(isequalRel(angl([8.331753349111e-01,4.783922332308e-01,2.431597252916e-01], [-1.712211873695e+05,-6.609276474442e+04,-3.119519847387e+04]), 2.972271689837e+00, TOL));
assert(isequalRel(angl([2.081367733599e+04,1.526942870940e+03,0.000000000000e+00], [8.330966071525e-01,4.785421600709e-01,2.432429544684e-01]), 5.080831871628e-01, TOL));
assert(isequalRel(angl([8.330966071525e-01,4.785421600709e-01,2.432429544684e-01], [-1.805508288875e+05,-7.121523290630e+04,-3.378024938270e+04]), 2.980305455016e+00, TOL));
assert(isequalRel(angl([2.078751778823e+04,1.524752909251e+03,0.000000000000e+00], [8.330139444612e-01,4.786895076339e-01,2.433263732209e-01]), 5.082831042665e-01, TOL));
assert(isequalRel(angl([8.330139444612e-01,4.786895076339e-01,2.433263732209e-01], [-1.894278753307e+05,-7.615554943344e+04,-3.627919882816e+04]), 2.987481446559e+00, TOL));
assert(isequalRel(angl([2.076614293279e+04,1.522576122105e+03,0.000000000000e+00], [8.329273608585e-01,4.788342462614e-01,2.434097495935e-01]), 5.084972424030e-01, TOL));
assert(isequalRel(angl([8.329273608585e-01,4.788342462614e-01,2.434097495935e-01], [-1.978986940141e+05,-8.092829015181e+04,-3.869857972447e+04]), 2.993950801145e+00, TOL));
assert(isequalRel(angl([2.076009538232e+04,1.521854922955e+03,0.000000000000e+00], [8.328976330150e-01,4.788819027507e-01,2.434374974526e-01]), 5.085717444892e-01, TOL));
assert(isequalRel(angl([8.328976330150e-01,4.788819027507e-01,2.434374974526e-01], [-2.006388298624e+05,-8.248414969882e+04,-3.948834331447e+04]), 2.995970942154e+00, TOL));

# 23599
assert(isequalRel(angl([7.755539166699e+03,3.528854542523e+01,0.000000000000e+00], [4.785555541153e-02,-5.721998376763e-01,-6.963978728277e-02]), 1.492481315717e+00, TOL));
assert(isequalRel(angl([4.785555541153e-02,-5.721998376763e-01,-6.963978728277e-02], [1.193195642997e+04,7.340749737496e+03,8.864636598694e+02]), 2.042734029820e+00, TOL));
assert(isequalRel(angl([7.754945059041e+03,3.367251755526e+01,0.000000000000e+00], [4.800780214931e-02,-5.721044035294e-01,-6.961412893936e-02]), 1.491998466214e+00, TOL));
assert(isequalRel(angl([4.800780214931e-02,-5.721044035294e-01,-6.961412893936e-02], [1.132171039205e+04,1.322284749156e+04,1.602401190490e+03]), 2.353987642725e+00, TOL));
assert(isequalRel(angl([7.754648944277e+03,3.145666822169e+01,0.000000000000e+00], [4.811676421114e-02,-5.720218391204e-01,-6.959394657858e-02]), 1.491515089103e+00, TOL));
assert(isequalRel(angl([4.811676421114e-02,-5.720218391204e-01,-6.959394657858e-02], [9.438293956752e+03,1.768805450261e+04,2.146592934019e+03]), 2.571151958504e+00, TOL));
assert(isequalRel(angl([7.754551490329e+03,2.905328279492e+01,0.000000000000e+00], [4.820068980474e-02,-5.719566119495e-01,-6.957903094204e-02]), 1.491053256984e+00, TOL));
assert(isequalRel(angl([4.820068980474e-02,-5.719566119495e-01,-6.957903094204e-02], [6.872086346386e+03,2.091011016811e+04,2.539799450345e+03]), 2.742767240296e+00, TOL));
assert(isequalRel(angl([7.754561385547e+03,2.659475361418e+01,0.000000000000e+00], [4.827004947418e-02,-5.719092092391e-01,-6.956857385197e-02]), 1.490612016221e+00, TOL));
assert(isequalRel(angl([4.827004947418e-02,-5.719092092391e-01,-6.956857385197e-02], [3.933375097983e+03,2.302407662542e+04,2.798259667462e+03]), 2.890012644494e+00, TOL));
assert(isequalRel(angl([7.754626543884e+03,2.412897759256e+01,0.000000000000e+00], [4.833164524677e-02,-5.718792421302e-01,-6.956200011037e-02]), 1.490185759481e+00, TOL));
assert(isequalRel(angl([4.833164524677e-02,-5.718792421302e-01,-6.956200011037e-02], [8.166409154575e+02,2.411898675475e+04,2.932694594275e+03]), 3.024294654572e+00, TOL));
assert(isequalRel(angl([7.754721173070e+03,2.167648457813e+01,0.000000000000e+00], [4.839055537107e-02,-5.718662262100e-01,-6.955898300275e-02]), 1.489768314487e+00, TOL));
assert(isequalRel(angl([4.839055537107e-02,-5.718662262100e-01,-6.955898300275e-02], [-2.334417058038e+03,2.424686096326e+04,2.949364488411e+03]), 3.130112249760e+00, TOL));
assert(isequalRel(angl([7.754836970277e+03,1.925076033166e+01,0.000000000000e+00], [4.845118976396e-02,-5.718697771052e-01,-6.955939840920e-02]), 1.489353764807e+00, TOL));
assert(isequalRel(angl([4.845118976396e-02,-5.718697771052e-01,-6.955939840920e-02], [-5.394317980388e+03,2.342942716149e+04,2.850868325860e+03]), 3.000807569251e+00, TOL));
assert(isequalRel(angl([7.754979654074e+03,1.686922307241e+01,0.000000000000e+00], [4.851803644432e-02,-5.718896105807e-01,-6.956330032453e-02]), 1.488936574924e+00, TOL));
assert(isequalRel(angl([4.851803644432e-02,-5.718896105807e-01,-6.956330032453e-02], [-8.233351302374e+03,2.166124480883e+04,2.636514561180e+03]), 2.864816247432e+00, TOL));
assert(isequalRel(angl([7.755169232862e+03,1.456576131021e+01,0.000000000000e+00], [4.859642781821e-02,-5.719254012390e-01,-6.957091853497e-02]), 1.488511859089e+00, TOL));
assert(isequalRel(angl([4.859642781821e-02,-5.719254012390e-01,-6.957091853497e-02], [-1.069396497348e+04,1.890988168891e+04,2.302337075483e+03]), 2.714205591232e+00, TOL));
assert(isequalRel(angl([7.755441567597e+03,1.241683955576e+01,0.000000000000e+00], [4.869366542445e-02,-5.719763543465e-01,-6.958264747408e-02]), 1.488076727516e+00, TOL));
assert(isequalRel(angl([4.869366542445e-02,-5.719763543465e-01,-6.958264747408e-02], [-1.255389669904e+04,1.511463990716e+04,1.840935732308e+03]), 2.536407684730e+00, TOL));
assert(isequalRel(angl([7.755836922602e+03,1.061226767583e+01,0.000000000000e+00], [4.882110769944e-02,-5.720398755989e-01,-6.959884063993e-02]), 1.487635557979e+00, TOL));
assert(isequalRel(angl([4.882110769944e-02,-5.720398755989e-01,-6.959884063993e-02], [-1.345020591864e+04,1.019057904289e+04,1.241959587359e+03]), 2.307247902518e+00, TOL));
assert(isequalRel(angl([7.756260499032e+03,9.665992918538e+00,0.000000000000e+00], [4.899835435704e-02,-5.721067202904e-01,-6.961808147386e-02]), 1.487219050425e+00, TOL));
assert(isequalRel(angl([4.899835435704e-02,-5.721067202904e-01,-6.961808147386e-02], [-1.268660437121e+04,4.079311061609e+03,4.982707861417e+02]), 1.968878579640e+00, TOL));
assert(isequalRel(angl([7.755218932898e+03,1.062491094282e+01,0.000000000000e+00], [4.925536688435e-02,-5.721395217536e-01,-6.962283757717e-02]), 1.486904104625e+00, TOL));
assert(isequalRel(angl([4.925536688435e-02,-5.721395217536e-01,-6.962283757717e-02], [-8.672558677528e+03,-2.827568233149e+03,-3.425964471559e+02]), 1.338725924804e+00, TOL));
assert(isequalRel(angl([7.750432040746e+03,6.557726881890e+00,0.000000000000e+00], [4.951513235498e-02,-5.720793036335e-01,-6.957498892134e-02]), 1.485926909691e+00, TOL));
assert(isequalRel(angl([4.951513235498e-02,-5.720793036335e-01,-6.957498892134e-02], [1.153314980597e+03,-6.411986920596e+03,-7.798728894123e+02]), 9.098140980551e-02, TOL));
assert(isequalRel(angl([7.755770013078e+03,5.268245704606e+00,0.000000000000e+00], [4.979308595259e-02,-5.720895116065e-01,-6.961678294405e-02]), 1.485284782545e+00, TOL));
assert(isequalRel(angl([4.979308595259e-02,-5.720895116065e-01,-6.961678294405e-02], [9.542792010555e+03,-5.337125308064e+02,-6.573165427708e+01]), 1.428319169135e+00, TOL));
assert(isequalRel(angl([7.755604477922e+03,5.761719246290e+00,0.000000000000e+00], [5.002844643625e-02,-5.720067742425e-01,-6.959643355207e-02]), 1.484929960432e+00, TOL));
assert(isequalRel(angl([5.002844643625e-02,-5.720067742425e-01,-6.959643355207e-02], [1.186880960100e+04,6.861595908475e+03,8.337278060176e+02]), 2.011549338173e+00, TOL));
assert(isequalRel(angl([7.754978560002e+03,4.210690125155e+00,0.000000000000e+00], [5.018487831260e-02,-5.719103326962e-01,-6.957016268274e-02]), 1.484447202428e+00, TOL));
assert(isequalRel(angl([5.018487831260e-02,-5.719103326962e-01,-6.957016268274e-02], [1.137623941678e+04,1.285897121366e+04,1.563406601721e+03]), 2.334050515830e+00, TOL));
assert(isequalRel(angl([7.754658819653e+03,2.008110356370e+00,0.000000000000e+00], [5.029613028683e-02,-5.718261384956e-01,-6.954933366115e-02]), 1.483960675429e+00, TOL));
assert(isequalRel(angl([5.029613028683e-02,-5.718261384956e-01,-6.954933366115e-02], [9.547703007819e+03,1.742148570758e+04,2.118569075147e+03]), 2.556248718242e+00, TOL));
assert(isequalRel(angl([7.754548955325e+03,-3.948133042759e-01,0.000000000000e+00], [5.038134055649e-02,-5.717592340722e-01,-6.953387390892e-02]), 1.483495980079e+00, TOL));
assert(isequalRel(angl([5.038134055649e-02,-5.717592340722e-01,-6.953387390892e-02], [7.008514702633e+03,2.072547471227e+04,2.520560642888e+03]), 2.730476349827e+00, TOL));
assert(isequalRel(angl([7.754552712405e+03,-2.855339916509e+00,0.000000000000e+00], [5.045139693828e-02,-5.717102179439e-01,-6.952294852376e-02]), 1.483052749695e+00, TOL));
assert(isequalRel(angl([5.045139693828e-02,-5.717102179439e-01,-6.952294852376e-02], [4.082281351036e+03,2.291104184601e+04,2.786375683090e+03]), 2.879148887278e+00, TOL));
assert(isequalRel(angl([7.754614807773e+03,-5.322641858810e+00,0.000000000000e+00], [5.051329893205e-02,-5.716787071351e-01,-6.951595146730e-02]), 1.482625388057e+00, TOL));
assert(isequalRel(angl([5.051329893205e-02,-5.716787071351e-01,-6.951595146730e-02], [9.691797814899e+02,2.407123673676e+04,2.927313265790e+03]), 3.014155823370e+00, TOL));
assert(isequalRel(angl([7.754707541626e+03,-7.775412381141e+00,0.000000000000e+00], [5.057221385666e-02,-5.716641977166e-01,-6.951253239643e-02]), 1.482207652376e+00, TOL));
assert(isequalRel(angl([5.057221385666e-02,-5.716641977166e-01,-6.951253239643e-02], [-2.184715154439e+03,2.426121671601e+04,2.950081428247e+03]), 3.140031696021e+00, TOL));
assert(isequalRel(angl([7.754821273109e+03,-1.020018021388e+01,0.000000000000e+00], [5.063257560414e-02,-5.716662817716e-01,-6.951254791169e-02]), 1.481793574701e+00, TOL));
assert(isequalRel(angl([5.063257560414e-02,-5.716662817716e-01,-6.951254791169e-02], [-5.253422233696e+03,2.350537595671e+04,2.857661207376e+03]), 3.010961050480e+00, TOL));
assert(isequalRel(angl([7.754960468454e+03,-1.258010955313e+01,0.000000000000e+00], [5.069884228461e-02,-5.716846560379e-01,-6.951603362657e-02]), 1.481377596226e+00, TOL));
assert(isequalRel(angl([5.069884228461e-02,-5.716846560379e-01,-6.951603362657e-02], [-8.108279610168e+03,2.180081688388e+04,2.649729819609e+03]), 2.875717577731e+00, TOL));
assert(isequalRel(angl([7.755143597493e+03,-1.488290784971e+01,0.000000000000e+00], [5.077625062462e-02,-5.717189914038e-01,-6.952319918176e-02]), 1.480954800680e+00, TOL));
assert(isequalRel(angl([5.077625062462e-02,-5.717189914038e-01,-6.952319918176e-02], [-1.059477795556e+04,1.911780779221e+04,2.322721369788e+03]), 2.726579732075e+00, TOL));
assert(isequalRel(angl([7.755404517245e+03,-1.703641739633e+01,0.000000000000e+00], [5.087189700536e-02,-5.717685353906e-01,-6.953441798865e-02]), 1.480522121628e+00, TOL));
assert(isequalRel(angl([5.087189700536e-02,-5.717685353906e-01,-6.953441798865e-02], [-1.249732045995e+04,1.539864085906e+04,1.869699838970e+03]), 2.551498222245e+00, TOL));
assert(isequalRel(angl([7.755782755202e+03,-1.886350701137e+01,0.000000000000e+00], [5.099671685214e-02,-5.718308914629e-01,-6.955004829200e-02]), 1.480083080459e+00, TOL));
assert(isequalRel(angl([5.099671685214e-02,-5.718308914629e-01,-6.955004829200e-02], [-1.346792475245e+04,1.056090147785e+04,1.280783991807e+03]), 2.327645685682e+00, TOL));
assert(isequalRel(angl([7.756204165360e+03,-1.988908190538e+01,0.000000000000e+00], [5.116946155220e-02,-5.718976389522e-01,-6.956894280879e-02]), 1.479664904127e+00, TOL));
assert(isequalRel(angl([5.116946155220e-02,-5.718976389522e-01,-6.956894280879e-02], [-1.284818843590e+04,4.541219018423e+03,5.485382642655e+02]), 2.001410984250e+00, TOL));
assert(isequalRel(angl([7.755400353060e+03,-1.907480611145e+01,0.000000000000e+00], [5.141994392061e-02,-5.719351451630e-01,-6.957616596001e-02]), 1.479343363169e+00, TOL));
assert(isequalRel(angl([5.141994392061e-02,-5.719351451630e-01,-6.957616596001e-02], [-9.152705527280e+03,-2.344249501437e+03,-2.879812196960e+02]), 1.407265592349e+00, TOL));
assert(isequalRel(angl([7.750225777063e+03,-2.227686989154e+01,0.000000000000e+00], [5.168699088602e-02,-5.718739316257e-01,-6.952589040414e-02]), 1.478461433470e+00, TOL));
assert(isequalRel(angl([5.168699088602e-02,-5.718739316257e-01,-6.952589040414e-02], [2.803849090860e+02,-6.500102640176e+03,-7.903609298377e+02]), 4.668762982051e-02, TOL));
assert(isequalRel(angl([7.755565218402e+03,-2.446435222761e+01,0.000000000000e+00], [5.195816660000e-02,-5.718859290071e-01,-6.956770833510e-02]), 1.477719126589e+00, TOL));
assert(isequalRel(angl([5.195816660000e-02,-5.718859290071e-01,-6.956770833510e-02], [9.166257843150e+03,-1.093125526507e+03,-1.294942888733e+02]), 1.361334154581e+00, TOL));
assert(isequalRel(angl([7.755556842971e+03,-2.375114606648e+01,0.000000000000e+00], [5.220068281498e-02,-5.718062478677e-01,-6.954918571788e-02]), 1.477380165503e+00, TOL));
assert(isequalRel(angl([5.220068281498e-02,-5.718062478677e-01,-6.954918571788e-02], [1.179448942915e+04,6.382211383537e+03,7.808843901486e+02]), 1.979534666510e+00, TOL));
assert(isequalRel(angl([7.754899766786e+03,-2.523148220185e+01,0.000000000000e+00], [5.236141854888e-02,-5.717088966755e-01,-6.952232854987e-02]), 1.476898005456e+00, TOL));
assert(isequalRel(angl([5.236141854888e-02,-5.717088966755e-01,-6.952232854987e-02], [1.142430138324e+04,1.249426088864e+04,1.524331654876e+03]), 2.313907266475e+00, TOL));
assert(isequalRel(angl([7.754555522007e+03,-2.741961531582e+01,0.000000000000e+00], [5.247501652110e-02,-5.716230967289e-01,-6.950084918153e-02]), 1.476408349817e+00, TOL));
assert(isequalRel(angl([5.247501652110e-02,-5.716230967289e-01,-6.950084918153e-02], [9.652098673500e+03,1.715384762075e+04,2.090480383360e+03]), 2.541333908517e+00, TOL));
assert(isequalRel(angl([7.754432760197e+03,-2.982191829400e+01,0.000000000000e+00], [5.256153960198e-02,-5.715545256841e-01,-6.948484250299e-02]), 1.475940737426e+00, TOL));
assert(isequalRel(angl([5.256153960198e-02,-5.715545256841e-01,-6.948484250299e-02], [7.140419458837e+03,2.053925485336e+04,2.501214693678e+03]), 2.718253536163e+00, TOL));

# 24208
assert(isequalRel(angl([1.566485528778e+03,8.583550587690e+03,0.000000000000e+00], [2.238716915460e-03,1.419904248599e-03,-1.315866923281e-04]), 8.261967011269e-01, TOL));
assert(isequalRel(angl([2.238716915460e-03,1.419904248599e-03,-1.315866923281e-04], [-1.428919940414e+04,3.946905530051e+04,1.428628385914e+03]), 1.355056725607e+00, TOL));
assert(isequalRel(angl([1.566449169317e+03,8.584230401558e+03,0.000000000000e+00], [2.222525754986e-03,1.408367587457e-03,-1.306625273785e-04]), 8.266216596318e-01, TOL));
assert(isequalRel(angl([2.222525754986e-03,1.408367587457e-03,-1.306625273785e-04], [-3.222292014955e+04,2.691625425799e+04,2.468599965935e+03]), 1.882982264873e+00, TOL));
assert(isequalRel(angl([1.566555875587e+03,8.584961794768e+03,0.000000000000e+00], [2.214273437070e-03,1.390409547232e-03,-1.303432168781e-04]), 8.307362573114e-01, TOL));
assert(isequalRel(angl([2.214273437070e-03,1.390409547232e-03,-1.303432168781e-04], [-4.141395109398e+04,7.055516566392e+03,2.838909066712e+03]), 2.413251211721e+00, TOL));
assert(isequalRel(angl([1.566677586314e+03,8.585848137910e+03,0.000000000000e+00], [2.215957405062e-03,1.370753449146e-03,-1.307075941370e-04]), 8.374718147033e-01, TOL));
assert(isequalRel(angl([2.215957405062e-03,1.370753449146e-03,-1.307075941370e-04], [-3.940272251896e+04,-1.471642475223e+04,2.441326783576e+03]), 2.945196393376e+00, TOL));
assert(isequalRel(angl([1.566661525697e+03,8.586829443911e+03,0.000000000000e+00], [2.227240067511e-03,1.354505186823e-03,-1.316720490626e-04]), 8.450700291382e-01, TOL));
assert(isequalRel(angl([2.227240067511e-03,1.354505186823e-03,-1.316720490626e-04], [-2.675108889828e+04,-3.251513982431e+04,1.384388655702e+03]), 2.805473662376e+00, TOL));
assert(isequalRel(angl([1.566482969240e+03,8.587742973003e+03,0.000000000000e+00], [2.245259491638e-03,1.346192747682e-03,-1.329889387177e-04]), 8.513968823920e-01, TOL));
assert(isequalRel(angl([2.245259491638e-03,1.346192747682e-03,-1.329889387177e-04], [-6.874779755423e+03,-4.153038329422e+04,-4.660245459036e+01]), 2.273781407428e+00, TOL));
assert(isequalRel(angl([1.566270500947e+03,8.588485421698e+03,0.000000000000e+00], [2.264992743195e-03,1.348269012739e-03,-1.342913944660e-04]), 8.546093820799e-01, TOL));
assert(isequalRel(angl([2.264992743195e-03,1.348269012739e-03,-1.342913944660e-04], [1.485952039042e+04,-3.930258907247e+04,-1.465024825241e+03]), 1.744120794913e+00, TOL));
assert(isequalRel(angl([1.566178500305e+03,8.589117197734e+03,0.000000000000e+00], [2.280880037958e-03,1.360045319519e-03,-1.352174044926e-04]), 8.538826869755e-01, TOL));
assert(isequalRel(angl([2.280880037958e-03,1.360045319519e-03,-1.352174044926e-04], [3.255314863770e+04,-2.639888401807e+04,-2.485458660025e+03]), 1.216971046319e+00, TOL));
assert(isequalRel(angl([1.566231209193e+03,8.589803411350e+03,0.000000000000e+00], [2.288718036575e-03,1.378143226736e-03,-1.355308988065e-04]), 8.495765217145e-01, TOL));
assert(isequalRel(angl([2.288718036575e-03,1.378143226736e-03,-1.355308988065e-04], [4.136567576837e+04,-6.298099658107e+03,-2.828052540329e+03]), 6.920254905659e-01, TOL));
assert(isequalRel(angl([1.566296128677e+03,8.590646395918e+03,0.000000000000e+00], [2.286521144807e-03,1.397779845774e-03,-1.351608597278e-04]), 8.428884854535e-01, TOL));
assert(isequalRel(angl([2.286521144807e-03,1.397779845774e-03,-1.351608597278e-04], [3.885883295070e+04,1.552339314924e+04,-2.396868507516e+03]), 1.685301299992e-01, TOL));
assert(isequalRel(angl([1.566218749027e+03,8.591579238928e+03,0.000000000000e+00], [2.274705625167e-03,1.413758336232e-03,-1.341983207697e-04]), 8.355270518906e-01, TOL));
assert(isequalRel(angl([2.274705625167e-03,1.413758336232e-03,-1.341983207697e-04], [2.570146068162e+04,3.308942617648e+04,-1.308685566378e+03]), 3.545203619987e-01, TOL));
assert(isequalRel(angl([1.565982263264e+03,8.592433416487e+03,0.000000000000e+00], [2.256316781421e-03,1.421528196024e-03,-1.328981614401e-04]), 8.294581843308e-01, TOL));
assert(isequalRel(angl([2.256316781421e-03,1.421528196024e-03,-1.328981614401e-04], [5.501081370996e+03,4.159027784405e+04,1.383252292972e+02]), 8.783370687673e-01, TOL));

# 25954
assert(isequalRel(angl([-4.829747254664e+00,-4.103074969325e+01,0.000000000000e+00], [-2.446036149918e-05,-2.104815679806e-04,9.985716872988e-11]), 1.478783746842e-03, TOL));
assert(isequalRel(angl([-2.446036149918e-05,-2.104815679806e-04,9.985716872988e-11], [8.118185192210e+03,-4.136840537378e+04,4.110466873304e+00]), 3.094712057265e-01, TOL));
assert(isequalRel(angl([-4.637561440996e+00,-4.107912103873e+01,0.000000000000e+00], [-6.728124236963e-06,-2.017735981546e-04,5.085896598269e-09]), 7.908485939916e-02, TOL));
assert(isequalRel(angl([-6.728124236963e-06,-2.017735981546e-04,5.085896598269e-09], [2.776634015328e+04,-3.172497000557e+04,9.932978462844e+00]), 7.522873900398e-01, TOL));
assert(isequalRel(angl([-4.446383226855e+00,-4.111907153307e+01,0.000000000000e+00], [4.251442276446e-06,-1.853503522240e-04,7.705408844253e-09]), 1.306491048397e-01, TOL));
assert(isequalRel(angl([4.251442276446e-06,-1.853503522240e-04,7.705408844253e-09], [3.993257237973e+04,-1.353260040454e+04,1.312958252292e+01]), 1.221123179806e+00, TOL));
assert(isequalRel(angl([-4.256181002332e+00,-4.115165671059e+01,0.000000000000e+00], [5.521919009298e-06,-1.656368561394e-04,7.190630569238e-09]), 1.363854505808e-01, TOL));
assert(isequalRel(angl([5.521919009298e-06,-1.656368561394e-04,7.190630569238e-09], [4.134101365441e+04,8.305716819548e+03,1.284988501152e+01]), 1.735739082203e+00, TOL));
assert(isequalRel(angl([-4.066526458683e+00,-4.117729801887e+01,0.000000000000e+00], [-3.256553828505e-06,-1.479422407562e-04,3.606165550377e-09]), 7.642855388953e-02, TOL));
assert(isequalRel(angl([-3.256553828505e-06,-1.479422407562e-04,3.606165550377e-09], [3.161499210558e+04,2.790729155353e+04,9.166187966821e+00]), 2.315992652649e+00, TOL));
assert(isequalRel(angl([-3.877356985712e+00,-4.119576464660e+01,0.000000000000e+00], [-1.971826246518e-05,-1.370297089895e-04,-2.167454458146e-09]), 4.907284772503e-02, TOL));
assert(isequalRel(angl([-1.971826246518e-05,-1.370297089895e-04,-2.167454458146e-09], [1.337575227587e+04,3.999427017651e+04,3.054168543211e+00]), 2.961761549236e+00, TOL));
assert(isequalRel(angl([-3.689372905836e+00,-4.120682385352e+01,0.000000000000e+00], [-3.943033267824e-05,-1.358356875086e-04,-8.667249646741e-09]), 1.932203831126e-01, TOL));
assert(isequalRel(angl([-3.943033267824e-05,-1.358356875086e-04,-8.667249646741e-09], [-8.464899633091e+03,4.131293549892e+04,-3.866229191080e+00]), 2.656977472155e+00, TOL));
assert(isequalRel(angl([-3.503673724805e+00,-4.121091067319e+01,0.000000000000e+00], [-5.708546663034e-05,-1.446809215652e-04,-1.423621777131e-08]), 2.909947726945e-01, TOL));
assert(isequalRel(angl([-5.708546663034e-05,-1.446809215652e-04,-1.423621777131e-08], [-2.802623406158e+04,3.150789995661e+04,-9.760478685420e+00]), 2.038800845786e+00, TOL));
assert(isequalRel(angl([-3.320995635305e+00,-4.120914938426e+01,0.000000000000e+00], [-6.792910437059e-05,-1.611839211809e-04,-1.746338319782e-08]), 3.184351396656e-01, TOL));
assert(isequalRel(angl([-6.792910437059e-05,-1.611839211809e-04,-1.746338319782e-08], [-4.004001314363e+04,1.321800579413e+04,-1.306594831815e+01]), 1.490801864459e+00, TOL));
assert(isequalRel(angl([-3.141309595327e+00,-4.120270456259e+01,0.000000000000e+00], [-6.903908218003e-05,-1.809002288628e-04,-1.755844213355e-08]), 2.884876779729e-01, TOL));
assert(isequalRel(angl([-6.903908218003e-05,-1.809002288628e-04,-1.755844213355e-08], [-4.126843291976e+04,-8.632068596927e+03,-1.290661266416e+01]), 1.000019524676e+00, TOL));
assert(isequalRel(angl([-2.964180665663e+00,-4.119210741885e+01,0.000000000000e+00], [-6.011420576136e-05,-1.985175638192e-04,-1.456141419029e-08]), 2.222017811728e-01, TOL));
assert(isequalRel(angl([-6.011420576136e-05,-1.985175638192e-04,-1.456141419029e-08], [-3.137785317015e+04,-2.815613970334e+04,-9.326055295520e+00]), 5.454231087460e-01, TOL));
assert(isequalRel(angl([-2.789530782067e+00,-4.117722903964e+01,0.000000000000e+00], [-4.355791676622e-05,-2.092870144893e-04,-9.331622249453e-09]), 1.375548305161e-01, TOL));
assert(isequalRel(angl([-4.355791676622e-05,-2.092870144893e-04,-9.331622249453e-09], [-1.303141552688e+04,-4.009233381029e+04,-3.276366600268e+00]), 1.090676719131e-01, TOL));
assert(isequalRel(angl([-2.618043311132e+00,-4.115792763644e+01,0.000000000000e+00], [-2.383196802642e-05,-2.103045912519e-04,-3.319015168019e-09]), 4.931571201923e-02, TOL));
assert(isequalRel(angl([-2.383196802642e-05,-2.103045912519e-04,-3.319015168019e-09], [8.827156604721e+03,-4.122300971237e+04,3.634829628582e+00]), 3.237859936919e-01, TOL));
assert(isequalRel(angl([-2.450803966804e+00,-4.113472261830e+01,0.000000000000e+00], [-6.253077302009e-06,-2.012956157432e-04,1.821286522295e-09]), 2.845542048775e-02, TOL));
assert(isequalRel(angl([-6.253077302009e-06,-2.012956157432e-04,1.821286522295e-09], [2.830685426674e+04,-3.124380147394e+04,9.572168911755e+00]), 7.671738094483e-01, TOL));
assert(isequalRel(angl([-2.288536720815e+00,-4.110882033565e+01,0.000000000000e+00], [4.441841603626e-06,-1.846885140342e-04,4.668699158181e-09]), 7.965862466730e-02, TOL));
assert(isequalRel(angl([4.441841603626e-06,-1.846885140342e-04,4.668699158181e-09], [4.015905128805e+04,-1.284539151157e+04,1.296086315922e+01]), 1.237171927001e+00, TOL));
assert(isequalRel(angl([-2.131198967315e+00,-4.108146554368e+01,0.000000000000e+00], [5.372800570193e-06,-1.649583363418e-04,4.414279682415e-09]), 8.439006661432e-02, TOL));
assert(isequalRel(angl([5.372800570193e-06,-1.649583363418e-04,4.414279682415e-09], [4.119255903455e+04,9.013796067591e+03,1.290495665506e+01]), 1.753662603595e+00, TOL));
assert(isequalRel(angl([-1.978339088231e+00,-4.105326697583e+01,0.000000000000e+00], [-3.708912108276e-06,-1.474191797090e-04,1.075120887797e-09]), 2.299866983366e-02, TOL));
assert(isequalRel(angl([-3.708912108276e-06,-1.474191797090e-04,1.075120887797e-09], [3.113169755798e+04,2.844555681731e+04,9.424192384593e+00]), 2.336291941255e+00, TOL));
assert(isequalRel(angl([-1.829857030444e+00,-4.102416878226e+01,0.000000000000e+00], [-2.035626334012e-05,-1.367929071469e-04,-4.510742435347e-09]), 1.031519083362e-01, TOL));
assert(isequalRel(angl([-2.035626334012e-05,-1.367929071469e-04,-4.510742435347e-09], [1.268781846530e+04,4.021783324639e+04,3.447262490826e+00]), 2.983724275840e+00, TOL));
assert(isequalRel(angl([-1.686408625880e+00,-4.099409308484e+01,0.000000000000e+00], [-4.008671248222e-05,-1.359394752298e-04,-1.090738526362e-08]), 2.456442586173e-01, TOL));
assert(isequalRel(angl([-4.008671248222e-05,-1.359394752298e-04,-1.090738526362e-08], [-9.172235002451e+03,4.116163475527e+04,-3.435757567745e+00]), 2.635581323241e+00, TOL));
assert(isequalRel(angl([-1.549051663416e+00,-4.096361076985e+01,0.000000000000e+00], [-5.758825132026e-05,-1.450885790434e-04,-1.646266130801e-08]), 3.400492721665e-01, TOL));
assert(isequalRel(angl([-5.758825132026e-05,-1.450885790434e-04,-1.646266130801e-08], [-2.856251093192e+04,3.102245987587e+04,-9.395621609154e+00]), 2.019609182432e+00, TOL));
assert(isequalRel(angl([-1.418487253232e+00,-4.093397107767e+01,0.000000000000e+00], [-6.814783795616e-05,-1.617775363503e-04,-1.974713005550e-08]), 3.640459176376e-01, TOL));
assert(isequalRel(angl([-6.814783795616e-05,-1.617775363503e-04,-1.974713005550e-08], [-4.026077504549e+04,1.252911484344e+04,-1.284915105397e+01]), 1.473810420180e+00, TOL));
assert(isequalRel(angl([-1.294652770591e+00,-4.090645948984e+01,0.000000000000e+00], [-6.891994792169e-05,-1.815123865495e-04,-1.993374418039e-08]), 3.312448406708e-01, TOL));
assert(isequalRel(angl([-6.891994792169e-05,-1.815123865495e-04,-1.993374418039e-08], [-4.111414376538e+04,-9.338871944829e+03,-1.287952403555e+01]), 9.845578173164e-01, TOL));
assert(isequalRel(angl([-1.177072539837e+00,-4.088172276846e+01,0.000000000000e+00], [-5.969457300968e-05,-1.989764167781e-04,-1.701752420762e-08]), 2.626802112834e-01, TOL));
assert(isequalRel(angl([-5.969457300968e-05,-1.989764167781e-04,-1.701752420762e-08], [-3.089001512240e+04,-2.869040750792e+04,-9.480372120172e+00]), 5.308353188270e-01, TOL));
assert(isequalRel(angl([-1.065616912682e+00,-4.085973392381e+01,0.000000000000e+00], [-4.295631652804e-05,-2.094626320952e-04,-1.181686365128e-08]), 1.762001262722e-01, TOL));
assert(isequalRel(angl([-4.295631652804e-05,-2.094626320952e-04,-1.181686365128e-08], [-1.234146194020e+04,-4.031006316386e+04,-3.558332010069e+00]), 9.482748033512e-02, TOL));
assert(isequalRel(angl([-9.609112731452e-01,-4.084043191104e+01,0.000000000000e+00], [-2.321612736992e-05,-2.101440505140e-04,-5.756002008862e-09]), 8.650691602152e-02, TOL));
assert(isequalRel(angl([-2.321612736992e-05,-2.101440505140e-04,-5.756002008862e-09], [9.533277508184e+03,-4.106552390214e+04,3.307564821074e+00]), 3.381384865579e-01, TOL));

# 26900
assert(isequalRel(angl([-1.517093776932e+01,-3.382825768800e+01,0.000000000000e+00], [3.670056705520e-04,-4.897517205061e-05,1.014965617251e-07]), 1.859715133037e+00, TOL));
assert(isequalRel(angl([3.670056705520e-04,-4.897517205061e-05,1.014965617251e-07], [4.096868133298e+04,-9.905991560862e+03,1.184946837135e+01]), 1.045792988495e-01, TOL));
assert(isequalRel(angl([-1.516745997348e+01,-3.372240299309e+01,0.000000000000e+00], [3.680609518494e-04,-3.905669085788e-05,1.003096673782e-07]), 1.887743170546e+00, TOL));
assert(isequalRel(angl([3.680609518494e-04,-3.905669085788e-05,1.003096673782e-07], [4.213566858481e+04,1.072991956181e+03,1.083481752324e+01]), 1.311787735524e-01, TOL));
assert(isequalRel(angl([-1.516453901014e+01,-3.365403944448e+01,0.000000000000e+00], [3.673122551547e-04,-3.243894017586e-05,9.914624655479e-08]), 1.906063990679e+00, TOL));
assert(isequalRel(angl([3.673122551547e-04,-3.243894017586e-05,9.914624655479e-08], [4.130475156132e+04,8.398277429438e+03,9.740062137489e+00]), 2.886761651077e-01, TOL));

# 26975
assert(isequalRel(angl([-4.384773351873e+04,-6.529046149525e+04,0.000000000000e+00], [3.153425517615e-01,1.633467427754e-01,4.330571809792e-01]), 2.160413069018e+00, TOL));
assert(isequalRel(angl([3.153425517615e-01,1.633467427754e-01,4.330571809792e-01], [7.309621979505e+03,6.076007136636e+03,6.800087052633e+03]), 3.055085867742e-01, TOL));
assert(isequalRel(angl([-4.384378278574e+04,-6.528193511837e+04,0.000000000000e+00], [3.153178028815e-01,1.632431359841e-01,4.330821800202e-01]), 2.160235171072e+00, TOL));
assert(isequalRel(angl([3.153178028815e-01,1.632431359841e-01,4.330821800202e-01], [-3.882629337907e+03,1.196000543452e+04,-2.508814383845e+04]), 2.271836458316e+00, TOL));
assert(isequalRel(angl([-4.384996591791e+04,-6.527499569994e+04,0.000000000000e+00], [3.153904238560e-01,1.632676000657e-01,4.331019453198e-01]), 2.160332162887e+00, TOL));
assert(isequalRel(angl([3.153904238560e-01,1.632676000657e-01,4.331019453198e-01], [-1.678545507465e+04,-7.347915970418e+02,-3.430057085853e+04]), 2.816149153755e+00, TOL));
assert(isequalRel(angl([-4.385846800381e+04,-6.527460336945e+04,0.000000000000e+00], [3.153904577097e-01,1.632720292281e-01,4.330411841493e-01]), 2.160428590227e+00, TOL));
assert(isequalRel(angl([3.153904577097e-01,1.632720292281e-01,4.330411841493e-01], [-2.352416689356e+04,-1.362945124622e+04,-3.024627899200e+04]), 3.086769659667e+00, TOL));
assert(isequalRel(angl([-4.386706956401e+04,-6.527730081006e+04,0.000000000000e+00], [3.153415779716e-01,1.632061220693e-01,4.330018342185e-01]), 2.160370952139e+00, TOL));
assert(isequalRel(angl([3.153415779716e-01,1.632061220693e-01,4.330018342185e-01], [-2.289023597092e+04,-2.220935900155e+04,-1.676991946116e+04]), 2.684259314823e+00, TOL));
assert(isequalRel(angl([-4.387150351948e+04,-6.527964252457e+04,0.000000000000e+00], [3.153220078047e-01,1.631180383875e-01,4.330734435289e-01]), 2.160179185121e+00, TOL));
assert(isequalRel(angl([3.153220078047e-01,1.631180383875e-01,4.330734435289e-01], [-1.164639698980e+04,-1.985544222106e+04,3.574001096073e+03]), 1.994506609547e+00, TOL));
assert(isequalRel(angl([-4.387841439297e+04,-6.527733005056e+04,0.000000000000e+00], [3.154146228153e-01,1.632046321556e-01,4.330697391139e-01]), 2.160388322022e+00, TOL));
assert(isequalRel(angl([3.154146228153e-01,1.632046321556e-01,4.330697391139e-01], [7.665761242415e+03,1.115978946577e+04,3.459381311655e+02]), 9.537448265413e-01, TOL));
assert(isequalRel(angl([-4.387397384633e+04,-6.526215601630e+04,0.000000000000e+00], [3.153619542187e-01,1.629928337327e-01,4.331158948381e-01]), 2.160036374079e+00, TOL));
assert(isequalRel(angl([3.153619542187e-01,1.629928337327e-01,4.331158948381e-01], [-6.369353881120e+03,1.020480073022e+04,-2.784452150384e+04]), 2.389582311632e+00, TOL));
assert(isequalRel(angl([-4.388072304285e+04,-6.525668488399e+04,0.000000000000e+00], [3.154231253952e-01,1.630240401941e-01,4.331124818888e-01]), 2.160156858553e+00, TOL));
assert(isequalRel(angl([3.154231253952e-01,1.630240401941e-01,4.331124818888e-01], [-1.834564763145e+04,-2.977766844301e+03,-3.439490760612e+04]), 2.883301197419e+00, TOL));
assert(isequalRel(angl([-4.388930663716e+04,-6.525693809588e+04,0.000000000000e+00], [3.154131929812e-01,1.630175371299e-01,4.330503917140e-01]), 2.160232198230e+00, TOL));
assert(isequalRel(angl([3.154131929812e-01,1.630175371299e-01,4.330503917140e-01], [-2.397974839255e+04,-1.543644139571e+04,-2.861650540218e+04]), 3.025684411757e+00, TOL));
assert(isequalRel(angl([-4.389761260567e+04,-6.525989102877e+04,0.000000000000e+00], [3.153604403007e-01,1.629396532666e-01,4.330237908407e-01]), 2.160141685126e+00, TOL));
assert(isequalRel(angl([3.153604403007e-01,1.629396532666e-01,4.330237908407e-01], [-2.192197167880e+04,-2.285245147658e+04,-1.378485308485e+04]), 2.603560622564e+00, TOL));
assert(isequalRel(angl([-4.390010831181e+04,-6.526084228784e+04,0.000000000000e+00], [3.153691745497e-01,1.628810248926e-01,4.331055253293e-01]), 2.159993859342e+00, TOL));
assert(isequalRel(angl([3.153691745497e-01,1.628810248926e-01,4.331055253293e-01], [-8.266438210307e+03,-1.721074590112e+04,6.967955460702e+03]), 1.782582632348e+00, TOL));
assert(isequalRel(angl([-4.390497711856e+04,-6.525793322398e+04,0.000000000000e+00], [3.153896781530e-01,1.629141429051e-01,4.330332662946e-01]), 2.160145314650e+00, TOL));
assert(isequalRel(angl([3.153896781530e-01,1.629141429051e-01,4.330332662946e-01], [6.286854645346e+03,1.380956328971e+04,-6.321606637811e+03]), 1.407630631290e+00, TOL));
assert(isequalRel(angl([-4.390394368036e+04,-6.524254716124e+04,0.000000000000e+00], [3.154063130603e-01,1.627448740866e-01,4.331482417257e-01]), 2.159841087772e+00, TOL));
assert(isequalRel(angl([3.154063130603e-01,1.627448740866e-01,4.331482417257e-01], [-8.730875267877e+03,8.244633443645e+03,-3.003992372791e+04]), 2.491749272943e+00, TOL));
assert(isequalRel(angl([-4.391113344742e+04,-6.523832371706e+04,0.000000000000e+00], [3.154550615913e-01,1.627763724514e-01,4.331268749350e-01]), 2.159970525926e+00, TOL));
assert(isequalRel(angl([3.154550615913e-01,1.627763724514e-01,4.331268749350e-01], [-1.973581883249e+04,-5.191765930066e+03,-3.416614974143e+04]), 2.947772957086e+00, TOL));
assert(isequalRel(angl([-4.391977177771e+04,-6.523914128107e+04,0.000000000000e+00], [3.154358884098e-01,1.627582667632e-01,4.330658042420e-01]), 2.160022116815e+00, TOL));
assert(isequalRel(angl([3.154358884098e-01,1.627582667632e-01,4.330658042420e-01], [-2.423273847703e+04,-1.711208243255e+04,-2.674288893252e+04]), 2.963463423262e+00, TOL));
assert(isequalRel(angl([-4.392768847952e+04,-6.524226378761e+04,0.000000000000e+00], [3.153812602799e-01,1.626694232047e-01,4.330548881545e-01]), 2.159898390398e+00, TOL));
assert(isequalRel(angl([3.153812602799e-01,1.626694232047e-01,4.330548881545e-01], [-2.065445640708e+04,-2.318454386047e+04,-1.061155144716e+04]), 2.514930850940e+00, TOL));
assert(isequalRel(angl([-4.392772619079e+04,-6.524045407843e+04,0.000000000000e+00], [3.154221877375e-01,1.626617994821e-01,4.331094310240e-01]), 2.159863545929e+00, TOL));
assert(isequalRel(angl([3.154221877375e-01,1.626617994821e-01,4.331094310240e-01], [-4.337159889566e+03,-1.341046817244e+04,9.870459492155e+03]), 1.495416911460e+00, TOL));
assert(isequalRel(angl([-4.393190866628e+04,-6.523632010079e+04,0.000000000000e+00], [3.153846377886e-01,1.625861426557e-01,4.330643366694e-01]), 2.159803737926e+00, TOL));
assert(isequalRel(angl([3.153846377886e-01,1.625861426557e-01,4.330643366694e-01], [4.074622635232e+03,1.469807548285e+04,-1.224865327973e+04]), 1.720153608349e+00, TOL));
assert(isequalRel(angl([-4.393376338133e+04,-6.522300125106e+04,0.000000000000e+00], [3.154500036638e-01,1.624968459823e-01,4.331808127854e-01]), 2.159644474590e+00, TOL));
assert(isequalRel(angl([3.154500036638e-01,1.624968459823e-01,4.331808127854e-01], [-1.095023438984e+04,6.148668794467e+03,-3.173665532865e+04]), 2.582573301986e+00, TOL));
assert(isequalRel(angl([-4.394131435051e+04,-6.521984774410e+04,0.000000000000e+00], [3.154862993383e-01,1.625244853986e-01,4.331459481999e-01]), 2.159772903721e+00, TOL));
assert(isequalRel(angl([3.154862993383e-01,1.625244853986e-01,4.331459481999e-01], [-2.095240702045e+04,-7.358715078949e+03,-3.363306643074e+04]), 3.010336368451e+00, TOL));
assert(isequalRel(angl([-4.394997996958e+04,-6.522115781076e+04,0.000000000000e+00], [3.154586370834e-01,1.624943217421e-01,4.330881086027e-01]), 2.159798510035e+00, TOL));
assert(isequalRel(angl([3.154586370834e-01,1.624943217421e-01,4.330881086027e-01], [-2.427348944134e+04,-1.863715546906e+04,-2.463327702390e+04]), 2.899455119241e+00, TOL));
assert(isequalRel(angl([-4.395738008850e+04,-6.522434452383e+04,0.000000000000e+00], [3.154048903783e-01,1.623964646753e-01,4.330959576469e-01]), 2.159642763602e+00, TOL));
assert(isequalRel(angl([3.154048903783e-01,1.623964646753e-01,4.330959576469e-01], [-1.905755468077e+04,-2.314829322082e+04,-7.269386141784e+03]), 2.415708421344e+00, TOL));
assert(isequalRel(angl([-4.395516163590e+04,-6.521759779590e+04,0.000000000000e+00], [3.154508983481e-01,1.624328204120e-01,4.330497057511e-01]), 2.159770939903e+00, TOL));
assert(isequalRel(angl([3.154508983481e-01,1.624328204120e-01,4.330497057511e-01], [4.369305307820e+01,-8.145902992073e+03,1.163457079913e+04]), 1.082671014908e+00, TOL));

# 28057
assert(isequalRel(angl([-1.996363258458e+04,-4.885621010830e+04,0.000000000000e+00], [2.905802926343e-04,6.612293778481e-04,-1.273134968287e-04]), 2.965187543632e+00, TOL));
assert(isequalRel(angl([2.905802926343e-04,6.612293778481e-04,-1.273134968287e-04], [-1.816879209419e+03,-1.835787621322e+03,6.661079264647e+03]), 2.087810984097e+00, TOL));
assert(isequalRel(angl([-1.989941716687e+04,-4.891868657075e+04,0.000000000000e+00], [-3.748139820796e-04,-4.537684305473e-04,1.189363727037e-03]), 1.133855641863e+00, TOL));
assert(isequalRel(angl([-3.748139820796e-04,-4.537684305473e-04,1.189363727037e-03], [1.483173642905e+03,5.395212487860e+03,4.448659071715e+03]), 1.327306440310e+00, TOL));
assert(isequalRel(angl([-1.984171978741e+04,-4.895120544468e+04,0.000000000000e+00], [-2.323453212803e-04,-2.347818977696e-04,8.582618346041e-04]), 1.232891867606e+00, TOL));
assert(isequalRel(angl([-2.323453212803e-04,-2.347818977696e-04,8.582618346041e-04], [2.801256071573e+03,5.455039313331e+03,-3.692128656945e+03]), 2.457233819566e+00, TOL));
assert(isequalRel(angl([-1.974861545125e+04,-4.893822368001e+04,0.000000000000e+00], [-1.787092192817e-04,5.871551422690e-04,2.599825078935e-03]), 1.750558980215e+00, TOL));
assert(isequalRel(angl([-1.787092192817e-04,5.871551422690e-04,2.599825078935e-03], [4.110933281184e+02,-1.728997691520e+03,-6.935455488101e+03]), 3.117484724611e+00, TOL));
assert(isequalRel(angl([-1.970355956138e+04,-4.902556516321e+04,0.000000000000e+00], [-2.759750253795e-04,-3.130112891976e-04,9.409920467393e-04]), 1.178702693285e+00, TOL));
assert(isequalRel(angl([-2.759750253795e-04,-3.130112891976e-04,9.409920467393e-04], [-2.506525584538e+03,-6.628986550942e+03,-9.880778449704e+02]), 1.318750573379e+00, TOL));
assert(isequalRel(angl([-1.961954648790e+04,-4.900292522362e+04,0.000000000000e+00], [2.903926839284e-04,8.094969850350e-04,2.111266669525e-04]), 2.898176357430e+00, TOL));
assert(isequalRel(angl([2.903926839284e-04,8.094969850350e-04,2.111266669525e-04], [-2.090798842662e+03,-2.723228321928e+03,6.266133565761e+03]), 1.808298417230e+00, TOL));
assert(isequalRel(angl([-1.954779454357e+04,-4.905000925538e+04,0.000000000000e+00], [-4.114644364282e-04,-6.706279565088e-04,9.040083670131e-04]), 8.672496961041e-01, TOL));
assert(isequalRel(angl([-4.114644364282e-04,-6.706279565088e-04,9.040083670131e-04], [1.091805602223e+03,4.809882295025e+03,5.172428978938e+03]), 1.453658925869e+00, TOL));
assert(isequalRel(angl([-1.949560812988e+04,-4.909845555711e+04,0.000000000000e+00], [-1.158387414692e-04,2.379706419342e-05,7.862194089590e-04]), 1.544842993995e+00, TOL));
assert(isequalRel(angl([-1.158387414692e-04,2.379706419342e-05,7.862194089590e-04], [2.811140622996e+03,5.950657071710e+03,-2.813237053894e+03]), 2.005371775591e+00, TOL));
assert(isequalRel(angl([-1.940079353167e+04,-4.907444033602e+04,0.000000000000e+00], [-3.207830330765e-04,2.917493177443e-04,2.735458525289e-03]), 1.626204945547e+00, TOL));
assert(isequalRel(angl([-3.207830330765e-04,2.917493177443e-04,2.735458525289e-03], [8.057269830432e+02,-8.121662790683e+02,-7.067584839683e+03]), 3.132838465916e+00, TOL));
assert(isequalRel(angl([-1.935218473511e+04,-4.916114519307e+04,0.000000000000e+00], [-1.943545921830e-04,-1.624172385044e-04,8.194660512814e-04]), 1.308603315714e+00, TOL));
assert(isequalRel(angl([-1.943545921830e-04,-1.624172385044e-04,8.194660512814e-04], [-2.249598375316e+03,-6.505848907139e+03,-1.956723650620e+03]), 1.588650377032e+00, TOL));
assert(isequalRel(angl([-1.927464143483e+04,-4.914875433469e+04,0.000000000000e+00], [2.361316187291e-04,8.382270623835e-04,5.816593130789e-04]), 2.545409641133e+00, TOL));
assert(isequalRel(angl([2.361316187291e-04,8.382270623835e-04,5.816593130789e-04], [-2.311573757974e+03,-3.560991128912e+03,5.748167495996e+03]), 1.595824335259e+00, TOL));
assert(isequalRel(angl([-1.919574179762e+04,-4.917883748603e+04,0.000000000000e+00], [-3.979968202230e-04,-7.947896211581e-04,5.516869183193e-04]), 5.622660715883e-01, TOL));
assert(isequalRel(angl([-3.979968202230e-04,-7.947896211581e-04,5.516869183193e-04], [6.881605659366e+02,4.124876189636e+03,5.794559944490e+03]), 1.618368989317e+00, TOL));
assert(isequalRel(angl([-1.914748224893e+04,-4.924166852557e+04,0.000000000000e+00], [-3.231659576031e-05,2.545564356953e-04,8.263514784701e-04]), 1.834498175459e+00, TOL));
assert(isequalRel(angl([-3.231659576031e-05,2.545564356953e-04,8.263514784701e-04], [2.759940882296e+03,6.329872717980e+03,-1.879195183309e+03]), 1.575763395697e+00, TOL));
assert(isequalRel(angl([-1.905302784189e+04,-4.921061798656e+04,0.000000000000e+00], [-4.480109360750e-04,-3.631124700536e-05,2.729405420435e-03]), 1.500018886999e+00, TOL));
assert(isequalRel(angl([-4.480109360750e-04,-3.631124700536e-05,2.729405420435e-03], [1.171506771373e+03,1.258205374764e+02,-7.061966262020e+03]), 3.136831201507e+00, TOL));
assert(isequalRel(angl([-1.899926218751e+04,-4.929203256506e+04,0.000000000000e+00], [-9.846762848350e-05,6.881584969830e-05,7.874564274370e-04]), 1.606955727435e+00, TOL));
assert(isequalRel(angl([-9.846762848350e-05,6.881584969830e-05,7.874564274370e-04], [-1.951437084725e+03,-6.251719458202e+03,-2.886954723550e+03]), 2.026954597904e+00, TOL));
assert(isequalRel(angl([-1.892861672514e+04,-4.929309048050e+04,0.000000000000e+00], [1.392173867738e-04,7.469319894047e-04,9.299407917547e-04]), 2.242364113581e+00, TOL));
assert(isequalRel(angl([1.392173867738e-04,7.469319894047e-04,9.299407917547e-04], [-2.475707222879e+03,-4.331905699582e+03,5.117312349244e+03]), 1.433051030759e+00, TOL));
assert(isequalRel(angl([-1.884351555349e+04,-4.930586480056e+04,0.000000000000e+00], [-3.347170770037e-04,-8.004897315197e-04,1.814237077666e-04]), 2.084127483635e-01, TOL));
assert(isequalRel(angl([-3.347170770037e-04,-8.004897315197e-04,1.814237077666e-04], [2.814609784741e+02,3.353510571023e+03,6.302879006502e+03]), 1.831932871163e+00, TOL));
assert(isequalRel(angl([-1.879730651526e+04,-4.938035098994e+04,0.000000000000e+00], [6.265637767355e-06,4.132344218104e-04,9.532490945689e-04]), 1.953957891234e+00, TOL));
assert(isequalRel(angl([6.265637767355e-06,4.132344218104e-04,9.532490945689e-04], [2.650331188597e+03,6.584334348513e+03,-9.082902713431e+02]), 1.316307731762e+00, TOL));
assert(isequalRel(angl([-1.870518022603e+04,-4.934680143057e+04,0.000000000000e+00], [-5.407537274964e-04,-3.463301285141e-04,2.582581815646e-03]), 1.375850753510e+00, TOL));
assert(isequalRel(angl([-5.407537274964e-04,-3.463301285141e-04,2.582581815646e-03], [1.501172265975e+03,1.066311327559e+03,-6.918714729524e+03]), 3.121295808750e+00, TOL));
assert(isequalRel(angl([-1.864510312857e+04,-4.941862714357e+04,0.000000000000e+00], [-9.621219269508e-06,3.390833538296e-04,8.688196377557e-04]), 1.914001407506e+00, TOL));
assert(isequalRel(angl([-9.621219269508e-06,3.390833538296e-04,8.688196377557e-04], [-1.619734683344e+03,-5.871140519913e+03,-3.760565870714e+03]), 2.473905235934e+00, TOL));
assert(isequalRel(angl([-1.858119245298e+04,-4.943524557449e+04,0.000000000000e+00], [1.780156171912e-05,5.559265462510e-04,1.207777884620e-03]), 1.978021685182e+00, TOL));
assert(isequalRel(angl([1.780156171912e-05,5.559265462510e-04,1.207777884620e-03], [-2.581042025049e+03,-5.020055725306e+03,4.385923290467e+03]), 1.308956164114e+00, TOL));
assert(isequalRel(angl([-1.849130077728e+04,-4.943173473792e+04,0.000000000000e+00], [-2.310322667421e-04,-6.820672527329e-04,-1.523482010202e-04]), 2.107942947971e-01, TOL));
assert(isequalRel(angl([-2.310322667421e-04,-6.820672527329e-04,-1.523482010202e-04], [-1.192208062753e+02,2.510906204877e+03,6.687456154588e+03]), 2.110838769814e+00, TOL));
assert(isequalRel(angl([-1.844513552985e+04,-4.951416829570e+04,0.000000000000e+00], [-3.265878170557e-06,4.687007535386e-04,1.125622291653e-03]), 1.938293636228e+00, TOL));
assert(isequalRel(angl([-3.265878170557e-06,4.687007535386e-04,1.125622291653e-03], [2.486238067258e+03,6.708182100279e+03,8.043349580657e+01]), 1.191933899729e+00, TOL));
assert(isequalRel(angl([-1.835704513059e+04,-4.948284028855e+04,0.000000000000e+00], [-5.855383052908e-04,-5.906028848651e-04,2.317511651648e-03]), 1.258123301354e+00, TOL));
assert(isequalRel(angl([-5.855383052908e-04,-5.906028848651e-04,2.317511651648e-03], [1.788423345804e+03,1.990505309570e+03,-6.640593377252e+03]), 3.099310142526e+00, TOL));

# 28129
assert(isequalRel(angl([6.863056839611e+04,-4.843566683524e+04,0.000000000000e+00], [-1.814718262594e-03,-1.990748473193e-03,-3.778822749601e-03]), 1.642999704016e+00, TOL));
assert(isequalRel(angl([-1.814718262594e-03,-1.990748473193e-03,-3.778822749601e-03], [1.861675971861e+04,3.166151770435e+03,1.883341523210e+04]), 2.688053122763e+00, TOL));
assert(isequalRel(angl([6.862540781323e+04,-4.844300723221e+04,0.000000000000e+00], [-1.768984004926e-03,-2.023800848637e-03,-3.779769371972e-03]), 1.630786286923e+00, TOL));
assert(isequalRel(angl([-1.768984004926e-03,-2.023800848637e-03,-3.779769371972e-03], [-3.006505963285e+03,1.852220742011e+04,1.894184078154e+04]), 2.566365203956e+00, TOL));
assert(isequalRel(angl([6.862853466087e+04,-4.844906206090e+04,0.000000000000e+00], [-1.830346025367e-03,-1.970078466859e-03,-3.768047831549e-03]), 1.648443335437e+00, TOL));
assert(isequalRel(angl([-1.830346025367e-03,-1.970078466859e-03,-3.768047831549e-03], [-2.160702086957e+04,1.543259962630e+04,2.066247030937e+02]), 1.502680616169e+00, TOL));
assert(isequalRel(angl([6.862205134548e+04,-4.844819186915e+04,0.000000000000e+00], [-1.760153643794e-03,-2.011331834550e-03,-3.758223882038e-03]), 1.631082218385e+00, TOL));
assert(isequalRel(angl([-1.760153643794e-03,-2.011331834550e-03,-3.758223882038e-03], [-1.845306134549e+04,-3.150832561335e+03,-1.868583030936e+04]), 4.647256180766e-01, TOL));
assert(isequalRel(angl([6.861698815126e+04,-4.845563086372e+04,0.000000000000e+00], [-1.806273291883e-03,-1.979449452814e-03,-3.759073355719e-03]), 1.643129861111e+00, TOL));
assert(isequalRel(angl([-1.806273291883e-03,-1.979449452814e-03,-3.759073355719e-03], [3.425117423839e+03,-1.851473232706e+04,-1.858867200557e+04]), 6.068134805952e-01, TOL));
assert(isequalRel(angl([6.862011131448e+04,-4.846145727517e+04,0.000000000000e+00], [-1.743387611204e-03,-2.030675392250e-03,-3.767232630406e-03]), 1.625489640738e+00, TOL));
assert(isequalRel(angl([-1.743387611204e-03,-2.030675392250e-03,-3.767232630406e-03], [2.185823838149e+04,-1.510151661554e+04,3.873451704808e+02]), 1.643346322335e+00, TOL));
assert(isequalRel(angl([6.861344899781e+04,-4.846063834465e+04,0.000000000000e+00], [-1.815034636691e-03,-1.991479497778e-03,-3.780162374658e-03]), 1.642732573199e+00, TOL));
assert(isequalRel(angl([-1.815034636691e-03,-1.991479497778e-03,-3.780162374658e-03], [1.836069935796e+04,3.506552567622e+03,1.902481678979e+04]), 2.705502836523e+00, TOL));
assert(isequalRel(angl([6.860850570616e+04,-4.846808775187e+04,0.000000000000e+00], [-1.767972891128e-03,-2.022566381052e-03,-3.777738622918e-03]), 1.630587181904e+00, TOL));
assert(isequalRel(angl([-1.767972891128e-03,-2.022566381052e-03,-3.777738622918e-03], [-3.412847654090e+03,1.864685269710e+04,1.874800359987e+04]), 2.548836013134e+00, TOL));
assert(isequalRel(angl([6.861162379039e+04,-4.847394692508e+04,0.000000000000e+00], [-1.830364503058e-03,-1.970731497421e-03,-3.769071452903e-03]), 1.648139458969e+00, TOL));
assert(isequalRel(angl([-1.830364503058e-03,-1.970731497421e-03,-3.769071452903e-03], [-2.175808331586e+04,1.521544829478e+04,-1.808218140631e+02]), 1.485111552924e+00, TOL));
assert(isequalRel(angl([6.860499185729e+04,-4.847307629065e+04,0.000000000000e+00], [-1.758754966790e-03,-2.010339055298e-03,-3.756144663784e-03]), 1.630785790446e+00, TOL));
assert(isequalRel(angl([-1.758754966790e-03,-2.010339055298e-03,-3.756144663784e-03], [-1.819341290284e+04,-3.493858769121e+03,-1.887714757717e+04]), 4.470138225428e-01, TOL));
assert(isequalRel(angl([6.860015052004e+04,-4.848062341893e+04,0.000000000000e+00], [-1.806140076694e-03,-1.980497238489e-03,-3.760421824395e-03]), 1.642744442200e+00, TOL));
assert(isequalRel(angl([-1.806140076694e-03,-1.980497238489e-03,-3.760421824395e-03], [3.833573868477e+03,-1.863577026711e+04,-1.838868722885e+04]), 6.244211807145e-01, TOL));
assert(isequalRel(angl([6.860325214685e+04,-4.848624764414e+04,0.000000000000e+00], [-1.742455768705e-03,-2.029648405758e-03,-3.765486179706e-03]), 1.625273416178e+00, TOL));
assert(isequalRel(angl([-1.742455768705e-03,-2.029648405758e-03,-3.765486179706e-03], [2.200220074562e+04,-1.487972595593e+04,7.743282709904e+02]), 1.660972656137e+00, TOL));

# 28350
assert(isequalRel(angl([4.466471630962e+04,-1.174303846392e+04,0.000000000000e+00], [7.048623996782e-05,-4.886846299213e-04,-9.750131576371e-04]), 1.393801585423e+00, TOL));
assert(isequalRel(angl([7.048623996782e-05,-4.886846299213e-04,-9.750131576371e-04], [-3.990938458545e+03,3.052983419071e+03,4.155327006290e+03]), 2.527649303233e+00, TOL));
assert(isequalRel(angl([4.454157034433e+04,-1.196682374702e+04,0.000000000000e+00], [-2.754052654871e-04,3.261811166511e-04,5.218376056584e-04]), 2.117678045134e+00, TOL));
assert(isequalRel(angl([-2.754052654871e-04,3.261811166511e-04,5.218376056584e-04], [-6.035523200973e+02,-2.685134745690e+03,-5.891702742823e+03]), 2.612214602642e+00, TOL));
assert(isequalRel(angl([4.448422226372e+04,-1.220790129503e+04,0.000000000000e+00], [-9.208194221032e-04,-1.495231915977e-05,-5.534290726254e-04]), 2.537089870928e+00, TOL));
assert(isequalRel(angl([-9.208194221032e-04,-1.495231915977e-05,-5.534290726254e-04], [4.788223456270e+03,7.825616921357e+02,4.335142846214e+03]), 2.920143785327e+00, TOL));
assert(isequalRel(angl([4.442298600973e+04,-1.247869713688e+04,0.000000000000e+00], [-9.234995327087e-04,8.054405348513e-05,-3.695474773830e-04]), 2.720739479283e+00, TOL));
assert(isequalRel(angl([-9.234995327087e-04,8.054405348513e-05,-3.695474773830e-04], [-6.291846016441e+03,1.547827907719e+03,-4.536711649769e+02]), 3.437193055147e-01, TOL));
assert(isequalRel(angl([4.429608805874e+04,-1.273630886488e+04,0.000000000000e+00], [-5.120830683227e-04,2.330077573070e-05,-2.554589601050e-04]), 2.627057138283e+00, TOL));
assert(isequalRel(angl([-5.120830683227e-04,2.330077573070e-05,-2.554589601050e-04], [4.480745734282e+03,-3.028552003741e+03,-3.586943436410e+03]), 1.971189384963e+00, TOL));
assert(isequalRel(angl([4.415908730849e+04,-1.296418021966e+04,0.000000000000e+00], [1.606862588009e-04,-5.001387873832e-04,-9.312742688776e-04]), 1.291206178090e+00, TOL));
assert(isequalRel(angl([1.606862588009e-04,-5.001387873832e-04,-9.312742688776e-04], [-4.464246091556e+02,2.932288725878e+03,5.759193897566e+03]), 3.056861482628e+00, TOL));
assert(isequalRel(angl([4.407835414179e+04,-1.319879769224e+04,0.000000000000e+00], [8.079531169968e-04,2.829391986446e-04,1.077729917381e-03]), 1.043283990638e+00, TOL));
assert(isequalRel(angl([8.079531169968e-04,2.829391986446e-04,1.077729917381e-03], [-3.713795818306e+03,-1.382661251301e+03,-5.122451311359e+03]), 3.123987121396e+00, TOL));
assert(isequalRel(angl([4.401989249608e+04,-1.346378588049e+04,0.000000000000e+00], [4.131652443287e-04,4.331250203671e-04,1.147925013924e-03]), 1.361948625924e+00, TOL));
assert(isequalRel(angl([4.131652443287e-04,4.331250203671e-04,1.147925013924e-03], [6.058320175220e+03,-8.274740672249e+02,2.104046786506e+03]), 9.947683428001e-01, TOL));
assert(isequalRel(angl([4.391340362481e+04,-1.373226118756e+04,0.000000000000e+00], [-2.195539680473e-04,7.078387474790e-04,1.308965282213e-03]), 1.854335137159e+00, TOL));
assert(isequalRel(angl([-2.195539680473e-04,7.078387474790e-04,1.308965282213e-03], [-5.631736590064e+03,2.623709536436e+03,1.766491250842e+03]), 9.807516430894e-01, TOL));
assert(isequalRel(angl([4.376533856175e+04,-1.397388993766e+04,0.000000000000e+00], [-5.422339548756e-04,8.187922703566e-04,1.318500720778e-03]), 2.055192780568e+00, TOL));
assert(isequalRel(angl([-5.422339548756e-04,8.187922703566e-04,1.318500720778e-03], [2.776849915601e+03,-3.255369419526e+03,-4.837196677900e+03]), 3.028062661518e+00, TOL));
assert(isequalRel(angl([4.364149961634e+04,-1.420114297886e+04,0.000000000000e+00], [-1.625333135915e-04,-1.235492771091e-04,-3.594807677561e-04]), 1.856029856770e+00, TOL));
assert(isequalRel(angl([-1.625333135915e-04,-1.235492771091e-04,-3.594807677561e-04], [1.148044308372e+03,2.486073433861e+03,5.826340759133e+03]), 2.906463260007e+00, TOL));
assert(isequalRel(angl([4.356468270609e+04,-1.444686869955e+04,0.000000000000e+00], [8.332158877670e-04,2.756699532930e-04,1.123257885197e-03]), 1.054181868022e+00, TOL));
assert(isequalRel(angl([8.332158877670e-04,2.756699532930e-04,1.123257885197e-03], [-4.527908718278e+03,-7.232919904114e+02,-4.527446083187e+03]), 2.974557517523e+00, TOL));

# *** error: t:= 1560.000000 *** code =   1

# 28623
assert(isequalRel(angl([-1.306260578082e+04,2.811695759564e+04,0.000000000000e+00], [1.757804690616e-01,-5.980488327176e-01,5.032598978417e-02]), 2.972314951678e+00, TOL));
assert(isequalRel(angl([1.757804690616e-01,-5.980488327176e-01,5.032598978417e-02], [-1.164535454950e+04,9.793766835596e+02,5.517895000578e+03]), 1.866475513928e+00, TOL));
assert(isequalRel(angl([-1.302459911445e+04,2.814562169628e+04,0.000000000000e+00], [1.761551769397e-01,-5.978228914315e-01,4.959612775728e-02]), 2.974773074032e+00, TOL));
assert(isequalRel(angl([1.761551769397e-01,-5.978228914315e-01,4.959612775728e-02], [5.619192522737e+03,1.965144862280e+04,-7.261384967647e+03]), 2.531984598019e+00, TOL));
assert(isequalRel(angl([-1.300666783921e+04,2.816746974561e+04,0.000000000000e+00], [1.762431076977e-01,-5.975887508380e-01,4.923902914472e-02]), 2.975963132245e+00, TOL));
assert(isequalRel(angl([1.762431076977e-01,-5.975887508380e-01,4.923902914472e-02], [-9.708686297137e+03,2.630614553149e+04,-1.204294788557e+03]), 3.065879269562e+00, TOL));
assert(isequalRel(angl([-1.297999378900e+04,2.816353625745e+04,0.000000000000e+00], [1.764956267968e-01,-5.976731452069e-01,4.887631473417e-02]), 2.977192753144e+00, TOL));
assert(isequalRel(angl([1.764956267968e-01,-5.976731452069e-01,4.887631473417e-02], [-1.439403162892e+04,6.659307650738e+03,5.593383458579e+03]), 2.207144451029e+00, TOL));
assert(isequalRel(angl([-1.293581855479e+04,2.818170564674e+04,0.000000000000e+00], [1.769327935603e-01,-5.975011344885e-01,4.810052815569e-02]), 2.979787251732e+00, TOL));
assert(isequalRel(angl([1.769327935603e-01,-5.975011344885e-01,4.810052815569e-02], [7.712094762697e+03,1.556572627434e+04,-7.342404655712e+03]), 2.350737456572e+00, TOL));
assert(isequalRel(angl([-1.291787524561e+04,2.820805215992e+04,0.000000000000e+00], [1.770558725992e-01,-5.972139861803e-01,4.769796422616e-02]), 2.981131490430e+00, TOL));
assert(isequalRel(angl([1.770558725992e-01,-5.972139861803e-01,4.769796422616e-02], [-7.558367396029e+03,2.703511367962e+04,-2.385120541840e+03]), 3.123949627337e+00, TOL));
assert(isequalRel(angl([-1.289402202526e+04,2.820892481037e+04,0.000000000000e+00], [1.772312259912e-01,-5.972642999942e-01,4.737767478334e-02]), 2.982220394988e+00, TOL));
assert(isequalRel(angl([1.772312259912e-01,-5.972642999942e-01,4.737767478334e-02], [-1.549561862220e+04,1.155015897828e+04,5.053831781214e+03]), 2.424241405133e+00, TOL));
assert(isequalRel(angl([-1.284806357643e+04,2.821614448445e+04,0.000000000000e+00], [1.776819563272e-01,-5.971669577844e-01,4.663210239838e-02]), 2.984703134726e+00, TOL));
assert(isequalRel(angl([1.776819563272e-01,-5.971669577844e-01,4.663210239838e-02], [9.167025682224e+03,1.036365204210e+04,-6.871525760423e+03]), 2.100922125379e+00, TOL));
assert(isequalRel(angl([-1.282873016676e+04,2.824786914880e+04,0.000000000000e+00], [1.778641167089e-01,-5.968434852976e-01,4.615901091914e-02]), 2.986292965306e+00, TOL));
assert(isequalRel(angl([1.778641167089e-01,-5.968434852976e-01,4.615901091914e-02], [-5.275802720938e+03,2.715178486008e+04,-3.494506872161e+03]), 3.031490045493e+00, TOL));
assert(isequalRel(angl([-1.280655556408e+04,2.825282624345e+04,0.000000000000e+00], [1.779857403758e-01,-5.968478167152e-01,4.585729823050e-02]), 2.987315694036e+00, TOL));
assert(isequalRel(angl([1.779857403758e-01,-5.968478167152e-01,4.585729823050e-02], [-1.560137656145e+04,1.564129379850e+04,4.217032668496e+03]), 2.584097136367e+00, TOL));
assert(isequalRel(angl([-1.276389407102e+04,2.824962611116e+04,0.000000000000e+00], [1.784101661287e-01,-5.967846416527e-01,4.520416954891e-02]), 2.989475653765e+00, TOL));
assert(isequalRel(angl([1.784101661287e-01,-5.967846416527e-01,4.520416954891e-02], [9.301058722997e+03,3.883152655738e+03,-5.477864770168e+03]), 1.697545348109e+00, TOL));
assert(isequalRel(angl([-1.273924318996e+04,2.828692470651e+04,0.000000000000e+00], [1.786660087902e-01,-5.964772225827e-01,4.462315099862e-02]), 2.991444172479e+00, TOL));
assert(isequalRel(angl([1.786660087902e-01,-5.964772225827e-01,4.462315099862e-02], [-2.914310658284e+03,2.666520392758e+04,-4.511098143349e+03]), 2.937315397418e+00, TOL));

# 28626
assert(isequalRel(angl([1.745105722601e+01,-3.174542486912e+00,0.000000000000e+00], [5.110007513096e-05,-1.196661846965e-05,-3.595297759904e-10]), 5.009126228295e-02, TOL));
assert(isequalRel(angl([5.110007513096e-05,-1.196661846965e-05,-3.595297759904e-10], [3.774000085593e+04,1.880276872802e+04,3.455125837297e+00]), 6.922562299435e-01, TOL));
assert(isequalRel(angl([1.659680200535e+01,-2.704401970577e+00,0.000000000000e+00], [3.800875721673e-05,2.818891934115e-06,1.153742876974e-09]), 2.355562904361e-01, TOL));
assert(isequalRel(angl([3.800875721673e-05,2.818891934115e-06,1.153742876974e-09], [2.323282515008e+04,3.518733981802e+04,4.989274276434e+00]), 9.132128511527e-01, TOL));
assert(isequalRel(angl([1.573072968778e+01,-2.262995079461e+00,0.000000000000e+00], [1.926961019287e-05,9.050429221540e-06,1.434522538587e-09]), 5.819715913114e-01, TOL));
assert(isequalRel(angl([1.926961019287e-05,9.050429221540e-06,1.434522538587e-09], [2.467442901779e+03,4.209360909959e+04,5.150629869589e+00]), 1.073151733387e+00, TOL));
assert(isequalRel(angl([1.485398808551e+01,-1.851191639819e+00,0.000000000000e+00], [-6.929592834441e-08,5.049484497707e-06,5.775573037724e-10]), 1.708505464751e+00, TOL));
assert(isequalRel(angl([-6.929592834441e-08,5.049484497707e-06,5.775573037724e-10], [-1.896259052991e+04,3.766166243819e+04,4.044332575234e+00]), 4.527199825854e-01, TOL));
assert(isequalRel(angl([1.396751329475e+01,-1.469867966532e+00,0.000000000000e+00], [-1.479861752869e-05,-8.106417868085e-06,-1.041149229085e-09]), 2.535604976581e+00, TOL));
assert(isequalRel(angl([-1.479861752869e-05,-8.106417868085e-06,-1.041149229085e-09], [-3.528500095313e+04,2.308544402778e+04,2.087118800595e+00]), 1.080500549250e+00, TOL));
assert(isequalRel(angl([1.307222604298e+01,-1.120091752910e+00,0.000000000000e+00], [-2.095054072555e-05,-2.687404794963e-05,-2.890768508900e-09]), 2.147486991486e+00, TOL));
assert(isequalRel(angl([-2.095054072555e-05,-2.687404794963e-05,-2.890768508900e-09], [-4.210320138132e+04,2.291062288930e+03,-1.327496350641e-01]), 9.629913679705e-01, TOL));
assert(isequalRel(angl([1.216927953018e+01,-8.030432639037e-01,0.000000000000e+00], [-1.686732989579e-05,-4.619855780472e-05,-4.441002270875e-09]), 1.854970089729e+00, TOL));
assert(isequalRel(angl([-1.686732989579e-05,-4.619855780472e-05,-4.441002270875e-09], [-3.758031858370e+04,-1.912040485693e+04,-2.027557016159e+00]), 7.500756633555e-01, TOL));
assert(isequalRel(angl([1.126011527641e+01,-5.197701627912e-01,0.000000000000e+00], [-3.648069735420e-06,-6.087470542059e-05,-5.301853037533e-09]), 1.584524711089e+00, TOL));
assert(isequalRel(angl([-3.648069735420e-06,-6.087470542059e-05,-5.301853037533e-09], [-2.293420761876e+04,-3.538123870806e+04,-3.164959320817e+00]), 5.152546368332e-01, TOL));
assert(isequalRel(angl([1.034629316731e+01,-2.710212125304e-01,0.000000000000e+00], [1.514693109789e-05,-6.694897531788e-05,-5.311234002083e-09]), 1.322107320554e+00, TOL));
assert(isequalRel(angl([1.514693109789e-05,-6.694897531788e-05,-5.311234002083e-09], [-2.109903323895e+03,-4.211071508198e+04,-3.365078891801e+00]), 2.725618419857e-01, TOL));
assert(isequalRel(angl([9.429280861040e+00,-5.730015483006e-02,0.000000000000e+00], [3.445492642230e-05,-6.278495176828e-05,-4.551259758613e-09]), 1.062815943610e+00, TOL));
assert(isequalRel(angl([3.445492642230e-05,-6.278495176828e-05,-4.551259758613e-09], [1.928277774728e+04,-3.749559250598e+04,-2.718614618432e+00]), 2.690699855988e-02, TOL));
assert(isequalRel(angl([8.510403109543e+00,1.209468408334e-01,0.000000000000e+00], [4.907472014676e-05,-4.950456864677e-05,-3.295484976027e-09]), 8.039692608838e-01, TOL));
assert(isequalRel(angl([4.907472014676e-05,-4.950456864677e-05,-3.295484976027e-09], [3.548060990600e+04,-2.277903375285e+04,-1.528418589129e+00]), 2.190182011693e-01, TOL));
assert(isequalRel(angl([7.590971385211e+00,2.632133334161e-01,0.000000000000e+00], [5.506823198957e-05,-3.068593002813e-05,-1.908542111757e-09]), 5.430413535425e-01, TOL));
assert(isequalRel(angl([5.506823198957e-05,-3.068593002813e-05,-1.908542111757e-09], [4.211996263499e+04,-1.925775672630e+03,-1.982743315433e-01]), 4.626913229175e-01, TOL));

# 28872
assert(isequalRel(angl([-4.698989076082e+04,1.898582608151e+04,0.000000000000e+00], [1.105264952080e-02,-7.595431904404e-03,-2.558978597012e-02]), 2.041139698704e+00, TOL));
assert(isequalRel(angl([1.105264952080e-02,-7.595431904404e-03,-2.558978597012e-02], [-5.799242561336e+03,2.589148111188e+03,2.011545150996e+03]), 2.349904176644e+00, TOL));
assert(isequalRel(angl([-4.696844823462e+04,1.897557742370e+04,0.000000000000e+00], [1.176861099235e-02,-7.902417168654e-03,-2.572711376684e-02]), 2.062639340137e+00, TOL));
assert(isequalRel(angl([1.176861099235e-02,-7.902417168654e-03,-2.572711376684e-02], [-4.769050619670e+03,2.420465805618e+03,4.035308558368e+03]), 2.713880114471e+00, TOL));
assert(isequalRel(angl([-4.694354810251e+04,1.896186269506e+04,0.000000000000e+00], [1.211993856049e-02,-8.148370878515e-03,-2.657192836710e-02]), 2.061536504407e+00, TOL));
assert(isequalRel(angl([1.211993856049e-02,-8.148370878515e-03,-2.657192836710e-02], [-3.175451573399e+03,1.965987380859e+03,5.582125696073e+03]), 3.052341460815e+00, TOL));
assert(isequalRel(angl([-4.692599061756e+04,1.894917439468e+04,0.000000000000e+00], [1.167012616960e-02,-8.073913139648e-03,-2.745004446731e-02]), 2.035344034174e+00, TOL));
assert(isequalRel(angl([1.167012616960e-02,-8.073913139648e-03,-2.745004446731e-02], [-1.210190248024e+03,1.281545412937e+03,6.474681727721e+03]), 2.918110791480e+00, TOL));
assert(isequalRel(angl([-4.692340663017e+04,1.894153632012e+04,0.000000000000e+00], [1.072135245144e-02,-7.704058851294e-03,-2.757003633746e-02]), 2.003776937655e+00, TOL));
assert(isequalRel(angl([1.072135245144e-02,-7.704058851294e-03,-2.757003633746e-02], [8.967379953280e+02,4.471235730478e+02,6.607224005065e+03]), 2.609061441458e+00, TOL));
assert(isequalRel(angl([-4.693712754858e+04,1.894087679859e+04,0.000000000000e+00], [1.005502482315e-02,-7.330961946227e-03,-2.673910879823e-02]), 1.992349143162e+00, TOL));
assert(isequalRel(angl([1.005502482315e-02,-7.330961946227e-03,-2.673910879823e-02], [2.896996635344e+03,-4.400473859436e+02,5.954926754864e+03]), 2.275990122181e+00, TOL));
assert(isequalRel(angl([-4.696124181929e+04,1.894610225138e+04,0.000000000000e+00], [1.022374607497e-02,-7.253843377730e-03,-2.557475348155e-02]), 2.013268252412e+00, TOL));
assert(isequalRel(angl([1.022374607497e-02,-7.253843377730e-03,-2.557475348155e-02], [4.545789701674e+03,-1.273559528721e+03,4.580165129838e+03]), 1.904845549492e+00, TOL));
assert(isequalRel(angl([-4.698452115088e+04,1.895328615706e+04,0.000000000000e+00], [1.098937698241e-02,-7.486378045183e-03,-2.496799002672e-02]), 2.047979023251e+00, TOL));
assert(isequalRel(angl([1.098937698241e-02,-7.486378045183e-03,-2.496799002672e-02], [5.627432993706e+03,-1.947942824694e+03,2.634167149295e+03]), 1.512918790805e+00, TOL));
assert(isequalRel(angl([-4.699518112468e+04,1.895719102641e+04,0.000000000000e+00], [1.149020689799e-02,-7.715433021114e-03,-2.519621507518e-02]), 2.061310291580e+00, TOL));
assert(isequalRel(angl([1.149020689799e-02,-7.715433021114e-03,-2.519621507518e-02], [5.984723185337e+03,-2.371376916090e+03,3.498799620911e+02]), 1.134928159249e+00, TOL));
assert(isequalRel(angl([-4.698698200974e+04,1.895380776554e+04,0.000000000000e+00], [1.112355344837e-02,-7.613762218446e-03,-2.557078110546e-02]), 2.043628209259e+00, TOL));
assert(isequalRel(angl([1.112355344837e-02,-7.613762218446e-03,-2.557078110546e-02], [5.548433259218e+03,-2.480164692448e+03,-1.979243145270e+03]), 7.810424800304e-01, TOL));

# 29141
assert(isequalRel(angl([3.094005442454e+03,-5.096003318711e+04,0.000000000000e+00], [-3.991457075705e-04,7.238253777886e-04,-2.665547267431e-03]), 1.841651142504e+00, TOL));
assert(isequalRel(angl([-3.991457075705e-04,7.238253777886e-04,-2.665547267431e-03], [9.318088358700e+02,-1.017178522393e+03,6.529192445268e+03]), 3.032042881901e+00, TOL));
assert(isequalRel(angl([3.078356912217e+03,-5.101050208021e+04,0.000000000000e+00], [-1.359557329556e-04,1.772917960543e-04,-9.411988059245e-04]), 1.763393280791e+00, TOL));
assert(isequalRel(angl([-1.359557329556e-04,1.772917960543e-04,-9.411988059245e-04], [-8.344906141046e+01,6.286202084526e+03,2.223498371606e+03]), 1.721257292385e+00, TOL));
assert(isequalRel(angl([3.067964164389e+03,-5.094490018841e+04,0.000000000000e+00], [8.068149536785e-05,-1.720049216427e-03,-1.719265931774e-04]), 1.003936786429e-01, TOL));
assert(isequalRel(angl([8.068149536785e-05,-1.720049216427e-03,-1.719265931774e-04], [-9.585768122083e+02,3.259260053478e+03,-5.722637324667e+03]), 1.991131109015e+00, TOL));
assert(isequalRel(angl([3.045201877234e+03,-5.095324448963e+04,0.000000000000e+00], [-9.404677131091e-05,1.878931542775e-04,-6.220504158489e-04]), 1.869420669160e+00, TOL));
assert(isequalRel(angl([-9.404677131091e-05,1.878931542775e-04,-6.220504158489e-04], [-2.552561998463e+02,-5.132597629736e+03,-4.221272331177e+03]), 1.174505520790e+00, TOL));
assert(isequalRel(angl([3.039840285867e+03,-5.093186422986e+04,0.000000000000e+00], [-1.135462981758e-04,7.918527852530e-04,-4.978712873374e-04]), 2.579400618151e+00, TOL));
assert(isequalRel(angl([-1.135462981758e-04,7.918527852530e-04,-4.978712873374e-04], [8.674429509677e+02,-5.038404029333e+03,4.256738105326e+03]), 3.002130869207e+00, TOL));
assert(isequalRel(angl([3.013660219208e+03,-5.088452201395e+04,0.000000000000e+00], [-2.285276855003e-04,-6.841521521175e-04,-2.019882376824e-03]), 1.253369665717e+00, TOL));
assert(isequalRel(angl([-2.285276855003e-04,-6.841521521175e-04,-2.019882376824e-03], [5.591688201275e+02,3.376305879365e+03,5.699220173906e+03]), 2.933084181447e+00, TOL));
assert(isequalRel(angl([3.008602453389e+03,-5.090678227992e+04,0.000000000000e+00], [-2.058977538908e-04,-2.086812192915e-04,-1.639934660005e-03]), 1.452768344657e+00, TOL));
assert(isequalRel(angl([-2.058977538908e-04,-2.086812192915e-04,-1.639934660005e-03], [-6.698518420486e+02,6.196002294840e+03,-2.281957417704e+03]), 1.334606314639e+00, TOL));
assert(isequalRel(angl([2.983948764952e+03,-5.081410238390e+04,0.000000000000e+00], [1.378880026463e-04,-1.587240808677e-04,9.649358236086e-04]), 1.401357423633e+00, TOL));
assert(isequalRel(angl([1.378880026463e-04,-1.587240808677e-04,9.649358236086e-04], [-7.842070801930e+02,-1.278531255533e+03,-6.449198925965e+03]), 2.785249202163e+00, TOL));
assert(isequalRel(angl([2.974401059145e+03,-5.085598921209e+04,0.000000000000e+00], [-8.026550077179e-06,-6.764593450374e-04,-3.577054696893e-04]), 4.910340093214e-01, TOL));
assert(isequalRel(angl([-8.026550077179e-06,-6.764593450374e-04,-3.577054696893e-04], [4.061581165884e+02,-6.607031157990e+03,1.483302147702e+02]), 5.136350963792e-01, TOL));
assert(isequalRel(angl([2.955001162372e+03,-5.074463728200e+04,0.000000000000e+00], [-3.928773071308e-04,7.343236875572e-04,-2.627729495904e-03]), 1.848582902692e+00, TOL));
assert(isequalRel(angl([-3.928773071308e-04,7.343236875572e-04,-2.627729495904e-03], [9.163491181317e+02,-8.840864924780e+02,6.491098103617e+03]), 3.005762348272e+00, TOL));
assert(isequalRel(angl([2.938192084225e+03,-5.077283658749e+04,0.000000000000e+00], [-1.373437041957e-04,3.742698137200e-04,-8.694434498137e-04]), 1.981153827092e+00, TOL));
assert(isequalRel(angl([-1.373437041957e-04,3.742698137200e-04,-8.694434498137e-04], [-1.040249096999e+02,6.304318214051e+03,1.960087398815e+03]), 1.464569422178e+00, TOL));
assert(isequalRel(angl([2.925190693571e+03,-5.067165836481e+04,0.000000000000e+00], [1.016703703651e-04,-1.586571264226e-03,7.567770297112e-05]), 4.798439029491e-02, TOL));
assert(isequalRel(angl([1.016703703651e-04,-1.586571264226e-03,7.567770297112e-05], [-9.446164284893e+02,2.872172483790e+03,-5.846941033616e+03]), 2.078709747895e+00, TOL));
assert(isequalRel(angl([2.901354278993e+03,-5.065735255364e+04,0.000000000000e+00], [-1.015426231835e-04,7.602385308882e-05,-7.301924930437e-04]), 1.681265864702e+00, TOL));
assert(isequalRel(angl([-1.015426231835e-04,7.602385308882e-05,-7.301924930437e-04], [-1.871656988818e+02,-5.404861634673e+03,-3.731970576180e+03]), 1.071156580722e+00, TOL));
assert(isequalRel(angl([2.892906745441e+03,-5.058326767739e+04,0.000000000000e+00], [-1.505312391585e-04,1.044282128523e-03,-6.820479374977e-04]), 2.562024610655e+00, TOL));
assert(isequalRel(angl([-1.505312391585e-04,1.044282128523e-03,-6.820479374977e-04], [8.845972046733e+02,-4.465745161630e+03,4.725836326961e+03]), 2.907910311284e+00, TOL));
assert(isequalRel(angl([2.864521989914e+03,-5.051175731699e+04,0.000000000000e+00], [-1.655183250905e-04,-5.925752420222e-04,-1.495431735200e-03]), 1.202452610354e+00, TOL));
assert(isequalRel(angl([-1.655183250905e-04,-5.925752420222e-04,-1.495431735200e-03], [4.464076723613e+02,4.086668396204e+03,5.093055966501e+03]), 2.841811360858e+00, TOL));
assert(isequalRel(angl([2.857330440092e+03,-5.046639123140e+04,0.000000000000e+00], [-1.734724342917e-04,-5.028886531232e-04,-1.517479116344e-03]), 1.259661378937e+00, TOL));
assert(isequalRel(angl([-1.734724342917e-04,-5.028886531232e-04,-1.517479116344e-03], [-7.522446749459e+02,5.588354733011e+03,-3.275040925732e+03]), 1.350630472813e+00, TOL));
assert(isequalRel(angl([2.827680282456e+03,-5.033882688029e+04,0.000000000000e+00], [5.531879350080e-05,3.819313609774e-04,5.763798386226e-04]), 2.147512766683e+00, TOL));
assert(isequalRel(angl([5.531879350080e-05,3.819313609774e-04,5.763798386226e-04], [-6.437287252548e+02,-2.585025285602e+03,-5.923013066083e+03]), 2.967513492439e+00, TOL));
assert(isequalRel(angl([2.818330293777e+03,-5.030816948541e+04,0.000000000000e+00], [2.700755417414e-05,-3.697137981409e-04,4.732307677791e-05]), 1.280936040457e-01, TOL));
assert(isequalRel(angl([2.700755417414e-05,-3.697137981409e-04,4.732307677791e-05], [5.844029581851e+02,-6.202356058171e+03,1.781005360194e+03]), 1.528744208093e-01, TOL));
assert(isequalRel(angl([2.790032258101e+03,-5.013564101670e+04,0.000000000000e+00], [-3.368341910078e-04,-1.138924128934e-04,-2.575929300512e-03]), 1.534254433650e+00, TOL));
assert(isequalRel(angl([-3.368341910078e-04,-1.138924128934e-04,-2.575929300512e-03], [7.795921176491e+02,1.100737283015e+03,6.311595294805e+03]), 3.013823104859e+00, TOL));
assert(isequalRel(angl([2.776216254018e+03,-5.010052438421e+04,0.000000000000e+00], [-2.064306204942e-04,8.167796764920e-04,-1.211673490810e-03]), 2.165606754188e+00, TOL));
assert(isequalRel(angl([-2.064306204942e-04,8.167796764920e-04,-1.211673490810e-03], [-4.030315558768e+02,6.399180008372e+03,-3.641273587499e+02]), 9.187584960425e-01, TOL));
assert(isequalRel(angl([2.750519664185e+03,-4.989555392092e+04,0.000000000000e+00], [1.744599977160e-04,-5.702603178617e-04,1.073542842613e-03]), 1.079834071648e+00, TOL));
assert(isequalRel(angl([1.744599977160e-04,-5.702603178617e-04,1.073542842613e-03], [-8.529391007119e+02,1.926523202273e+02,-6.322470547838e+03]), 2.688132647485e+00, TOL));

# *** error: t:= 440.000000 *** code =   6

# 29238
assert(isequalRel(angl([-3.385917797938e+04,-2.227548553070e+04,0.000000000000e+00], [8.447073799443e-03,-9.921693635666e-03,1.628452520810e-02]), 1.647769568203e+00, TOL));
assert(isequalRel(angl([8.447073799443e-03,-9.921693635666e-03,1.628452520810e-02], [4.474279154954e+03,-1.447722861416e+03,4.619839272345e+03]), 3.856684162202e-01, TOL));
assert(isequalRel(angl([-3.401712963857e+04,-2.205518758611e+04,0.000000000000e+00], [8.560523481393e-03,-9.828717765359e-03,1.625527017698e-02]), 1.659025131101e+00, TOL));
assert(isequalRel(angl([8.560523481393e-03,-9.828717765359e-03,1.625527017698e-02], [1.922177124743e+03,5.113011383417e+03,-4.087084702033e+03]), 2.353467440563e+00, TOL));
assert(isequalRel(angl([-3.421963124243e+04,-2.178763933720e+04,0.000000000000e+00], [8.208579351836e-03,-9.847137517279e-03,1.602768540972e-02]), 1.650569749026e+00, TOL));
assert(isequalRel(angl([8.208579351836e-03,-9.847137517279e-03,1.602768540972e-02], [-6.157935468821e+03,-2.094707987903e+03,-1.941637309598e+03]), 2.024325454250e+00, TOL));
assert(isequalRel(angl([-3.433207611063e+04,-2.151168840955e+04,0.000000000000e+00], [8.550060218206e-03,-9.469289271187e-03,1.581731356993e-02]), 1.680134962843e+00, TOL));
assert(isequalRel(angl([8.550060218206e-03,-9.469289271187e-03,1.581731356993e-02], [2.482640524109e+03,-3.268459445550e+03,5.146380061902e+03]), 5.334992045385e-02, TOL));
assert(isequalRel(angl([-3.452135168882e+04,-2.129206795629e+04,0.000000000000e+00], [8.960261080496e-03,-9.305571167468e-03,1.591084153067e-02]), 1.704954140322e+00, TOL));
assert(isequalRel(angl([8.960261080496e-03,-9.305571167468e-03,1.591084153067e-02], [4.036264552866e+03,4.827433472010e+03,-2.507990639548e+03]), 1.928906360214e+00, TOL));
assert(isequalRel(angl([-3.468443389786e+04,-2.099589003916e+04,0.000000000000e+00], [8.768724514793e-03,-9.505258121414e-03,1.596619990505e-02]), 1.696652161771e+00, TOL));
assert(isequalRel(angl([8.768724514793e-03,-9.505258121414e-03,1.596619990505e-02], [-5.776813716215e+03,-1.186415531930e+02,-3.641220524182e+03]), 2.445329280093e+00, TOL));
assert(isequalRel(angl([-3.480298529597e+04,-2.074762878894e+04,0.000000000000e+00], [8.981997053358e-03,-9.335189903824e-03,1.588759441379e-02]), 1.714458963261e+00, TOL));
assert(isequalRel(angl([8.981997053358e-03,-9.335189903824e-03,1.588759441379e-02], [6.798699486521e+01,-4.456492134728e+03,4.863717942833e+03]), 4.874546077468e-01, TOL));
assert(isequalRel(angl([-3.500517998857e+04,-2.050515574984e+04,0.000000000000e+00], [9.481728373366e-03,-9.177118832504e-03,1.602548638728e-02]), 1.742303854431e+00, TOL));
assert(isequalRel(angl([9.481728373366e-03,-9.177118832504e-03,1.602548638728e-02], [5.520622070379e+03,3.782382035542e+03,-5.967319316081e+02]), 1.512897595518e+00, TOL));
assert(isequalRel(angl([-3.512572891944e+04,-2.020178564189e+04,0.000000000000e+00], [9.187452060046e-03,-9.598013193567e-03,1.624558497460e-02]), 1.722861308306e+00, TOL));
assert(isequalRel(angl([9.187452060046e-03,-9.598013193567e-03,1.624558497460e-02], [-4.528051044554e+03,1.808462733292e+03,-4.816997277621e+03]), 2.836790593458e+00, TOL));
assert(isequalRel(angl([-3.527221075294e+04,-1.997317650546e+04,0.000000000000e+00], [9.053476591484e-03,-9.678587655596e-03,1.622962470326e-02]), 1.719725905812e+00, TOL));
assert(isequalRel(angl([9.053476591484e-03,-9.678587655596e-03,1.622962470326e-02], [-2.356614680779e+03,-4.852512022719e+03,3.856538161837e+03]), 8.828898849701e-01, TOL));
assert(isequalRel(angl([-3.545860840793e+04,-1.969710863925e+04,0.000000000000e+00], [9.525181232709e-03,-9.487514961067e-03,1.628665693663e-02]), 1.747846293805e+00, TOL));
assert(isequalRel(angl([9.525181232709e-03,-9.487514961067e-03,1.628665693663e-02], [6.149658001344e+03,2.173594232607e+03,1.369294887325e+03]), 1.128396722726e+00, TOL));
assert(isequalRel(angl([-3.555387264435e+04,-1.940876292414e+04,0.000000000000e+00], [9.098437923814e-03,-9.896358819736e-03,1.642414492723e-02]), 1.724247704599e+00, TOL));
assert(isequalRel(angl([9.098437923814e-03,-9.896358819736e-03,1.642414492723e-02], [-2.629550114488e+03,3.400980401577e+03,-5.344382171288e+03]), 3.087220305974e+00, TOL));

# 88888
assert(isequalRel(angl([-2.133112411108e+04,4.422389251501e+04,0.000000000000e+00], [-4.540814471364e-03,3.015172071551e-03,8.998870419362e-03]), 1.108912409016e+00, TOL));
assert(isequalRel(angl([-4.540814471364e-03,3.015172071551e-03,8.998870419362e-03], [1.020692345577e+03,2.286562606342e+03,-6.191555659270e+03]), 2.435311222730e+00, TOL));
assert(isequalRel(angl([-2.119461456223e+04,4.432429991232e+04,0.000000000000e+00], [-4.047982752107e-03,3.117870513250e-03,7.472346126600e-03]), 1.042986910602e+00, TOL));
assert(isequalRel(angl([-4.047982752107e-03,3.117870513250e-03,7.472346126600e-03], [-3.226543491554e+03,3.503709775249e+03,4.532809793430e+03]), 2.370372055254e-01, TOL));
assert(isequalRel(angl([-2.103130736444e+04,4.444099558718e+04,0.000000000000e+00], [-4.262466434708e-03,3.367433206278e-03,7.819515098970e-03]), 1.034231072197e+00, TOL));
assert(isequalRel(angl([-4.262466434708e-03,3.367433206278e-03,7.819515098970e-03], [2.456107065334e+03,-6.071938555030e+03,1.222897685538e+03]), 1.914091192733e+00, TOL));
assert(isequalRel(angl([-2.083669617880e+04,4.446209151546e+04,0.000000000000e+00], [-4.413826914318e-03,3.026911479416e-03,8.780165393286e-03]), 1.105486484401e+00, TOL));
assert(isequalRel(angl([-4.413826914318e-03,3.026911479416e-03,8.780165393286e-03], [7.871645734899e+02,2.719918009460e+03,-6.043866620243e+03]), 2.351647995654e+00, TOL));
assert(isequalRel(angl([-2.069627243979e+04,4.455203019115e+04,0.000000000000e+00], [-3.925085312382e-03,3.168010909447e-03,7.206225009361e-03]), 1.030217934101e+00, TOL));
assert(isequalRel(angl([-3.925085312382e-03,3.168010909447e-03,7.206225009361e-03], [-3.110976480293e+03,3.121730262353e+03,4.878152170355e+03]), 1.409930827985e-01, TOL));
assert(isequalRel(angl([-2.053669840047e+04,4.467323279851e+04,0.000000000000e+00], [-4.173683465658e-03,3.420898259659e-03,7.660775817558e-03]), 1.026599628709e+00, TOL));
assert(isequalRel(angl([-4.173683465658e-03,3.420898259659e-03,7.660775817558e-03], [2.567562296951e+03,-6.112503839223e+03,7.139637443537e+02]), 2.002708132273e+00, TOL));
assert(isequalRel(angl([-2.034005256788e+04,4.469543644166e+04,0.000000000000e+00], [-4.293421409559e-03,3.074185970802e-03,8.529048538653e-03]), 1.097062999175e+00, TOL));
assert(isequalRel(angl([-4.293421409559e-03,3.074185970802e-03,8.529048538653e-03], [5.560566178034e+02,3.144522882008e+03,-5.855346361782e+03]), 2.262229963007e+00, TOL));
assert(isequalRel(angl([-2.019525152387e+04,4.477444371552e+04,0.000000000000e+00], [-3.814155859067e-03,3.258399874629e-03,6.920679952865e-03]), 1.011057134470e+00, TOL));
assert(isequalRel(angl([-3.814155859067e-03,3.258399874629e-03,6.920679952865e-03], [-2.982479405393e+03,2.712616637110e+03,5.192323304719e+03]), 3.790230685256e-02, TOL));
assert(isequalRel(angl([-2.003918062287e+04,4.489909046564e+04,0.000000000000e+00], [-4.096991552791e-03,3.513090058257e-03,7.486377040703e-03]), 1.013915656513e+00, TOL));
assert(isequalRel(angl([-4.096991552791e-03,3.513090058257e-03,7.486377040703e-03], [2.663089643522e+03,-6.115482908846e+03,1.964007286646e+02]), 2.096871623755e+00, TOL));
assert(isequalRel(angl([-1.984123444572e+04,4.492381910247e+04,0.000000000000e+00], [-4.183559017035e-03,3.161978492372e-03,8.254625295185e-03]), 1.083095822700e+00, TOL));
assert(isequalRel(angl([-4.183559017035e-03,3.161978492372e-03,8.254625295185e-03], [3.285499967384e+02,3.557094905520e+03,-5.626214272111e+03]), 2.166500295380e+00, TOL));
assert(isequalRel(angl([-1.969168232259e+04,4.499166198236e+04,0.000000000000e+00], [-3.719171772442e-03,3.392907276589e-03,6.627164470046e-03]), 9.852497398353e-01, TOL));
assert(isequalRel(angl([-3.719171772442e-03,3.392907276589e-03,6.627164470046e-03], [-2.842068767573e+03,2.278423434920e+03,5.472334371496e+03]), 7.247449604514e-02, TOL));
assert(isequalRel(angl([-1.953878641608e+04,4.511850953024e+04,0.000000000000e+00], [-4.035252003676e-03,3.646173772688e-03,7.306518026783e-03]), 9.963172878601e-01, TOL));
assert(isequalRel(angl([-4.035252003676e-03,3.646173772688e-03,7.306518026783e-03], [2.742553988317e+03,-6.079670091229e+03,-3.263901264921e+02]), 2.196448877477e+00, TOL));

