TOL = 0.000001;

# 5

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 1.975491070959e+04,  1.450506000000e-01,  3.623303527140e+00,  0.000000000000e+00,  2.000636014976e-01,  4.766670465451e+00,  5.245868658927e-03);
assert(isequalRel(sinim,      1.987316640953e-01, TOL));
assert(isequalRel(cosim,      9.800539401920e-01, TOL));
assert(isequalRel(sinomm,    -4.632960351199e-01, TOL));
assert(isequalRel(cosomm,    -8.862035792312e-01, TOL));
assert(isequalRel(snodm,     -9.985271218932e-01, TOL));
assert(isequalRel(cnodm,      5.425483244489e-02, TOL));
assert(isequalRel(day,        3.801641070959e+04, TOL));
assert(isequalRel(e3,        -3.259811599808e-04, TOL));
assert(isequalRel(ee2,        9.631690304302e-05, TOL));
assert(isequalRel(em,         1.450506000000e-01, TOL));
assert(isequalRel(emsq,       2.103967656036e-02, TOL));
assert(isequalRel(gam,        7.975304385858e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.894242383526e-01, TOL));
assert(isequalRel(se2,       -1.598763953845e-03, TOL));
assert(isequalRel(se3,       -1.532829312733e-03, TOL));
assert(isequalRel(sgh2,       1.009321688332e-02, TOL));
assert(isequalRel(sgh3,      -1.031125833038e-02, TOL));
assert(isequalRel(sgh4,      -1.698290639332e-04, TOL));
assert(isequalRel(sh2,       -1.436571665398e-03, TOL));
assert(isequalRel(sh3,       -2.604666666759e-04, TOL));
assert(isequalRel(si2,       -2.752019370380e-04, TOL));
assert(isequalRel(si3,        1.412253967491e-03, TOL));
assert(isequalRel(sl2,       -9.737328456846e-03, TOL));
assert(isequalRel(sl3,        9.584139594897e-03, TOL));
assert(isequalRel(sl4,        4.041147860756e-04, TOL));
assert(isequalRel(s1,        -1.968466918871e-04, TOL));
assert(isequalRel(s2,        -4.620853989286e-05, TOL));
assert(isequalRel(s3,         9.143969877776e-05, TOL));
assert(isequalRel(s4,         9.047265431838e-05, TOL));
assert(isequalRel(s5,         1.015004737244e-02, TOL));
assert(isequalRel(s6,        -2.446495344160e-01, TOL));
assert(isequalRel(s7,         8.280077172131e-01, TOL));
assert(isequalRel(ss1,       -1.225562568207e-03, TOL));
assert(isequalRel(ss2,       -2.876932107990e-04, TOL));
assert(isequalRel(ss3,        5.693012719481e-04, TOL));
assert(isequalRel(ss4,        5.632804773904e-04, TOL));
assert(isequalRel(ss5,        1.759082494140e-02, TOL));
assert(isequalRel(ss6,        6.522571736933e-01, TOL));
assert(isequalRel(ss7,        6.253574287016e-01, TOL));
assert(isequalRel(sz1,        1.313903514872e+01, TOL));
assert(isequalRel(sz2,        8.551999562135e+00, TOL));
assert(isequalRel(sz3,        4.721576706992e+00, TOL));
assert(isequalRel(sz11,       2.389115076210e+00, TOL));
assert(isequalRel(sz12,       4.782906351416e-01, TOL));
assert(isequalRel(sz13,      -6.532930148080e-02, TOL));
assert(isequalRel(sz21,      -2.576626675289e-01, TOL));
assert(isequalRel(sz22,      -2.496707623737e+00, TOL));
assert(isequalRel(sz23,      -7.103439559619e-01, TOL));
assert(isequalRel(sz31,       7.986387467636e+00, TOL));
assert(isequalRel(sz32,       8.959317150558e+00, TOL));
assert(isequalRel(sz33,      -1.166475754387e+00, TOL));
assert(isequalRel(xgh2,       2.069563786522e-03, TOL));
assert(isequalRel(xgh3,       6.246874813546e-04, TOL));
assert(isequalRel(xgh4,      -8.940507699742e-05, TOL));
assert(isequalRel(xh2,       -5.956657020046e-05, TOL));
assert(isequalRel(xh3,       -2.660535481999e-04, TOL));
assert(isequalRel(xi2,       -2.550806983774e-04, TOL));
assert(isequalRel(xi3,        6.513825317331e-05, TOL));
assert(isequalRel(xl2,       -1.862212872508e-03, TOL));
assert(isequalRel(xl3,       -5.873201141188e-04, TOL));
assert(isequalRel(xl4,        2.127428175609e-04, TOL));
assert(isequalRel(nm,         5.245868658927e-03, TOL));
assert(isequalRel(z1,         6.668001023728e+00, TOL));
assert(isequalRel(z2,         1.018273735259e+01, TOL));
assert(isequalRel(z3,         9.879517039032e+00, TOL));
assert(isequalRel(z11,        1.630805643792e+00, TOL));
assert(isequalRel(z12,        2.760103424268e+00, TOL));
assert(isequalRel(z13,        9.259764788332e-01, TOL));
assert(isequalRel(z21,        8.286842069497e-01, TOL));
assert(isequalRel(z22,       -6.445407097754e-01, TOL));
assert(isequalRel(z23,       -2.050151056150e+00, TOL));
assert(isequalRel(z31,        1.248944362820e+00, TOL));
assert(isequalRel(z32,        1.143751005270e+01, TOL));
assert(isequalRel(z33,        4.701299585848e+00, TOL));
assert(isequalRel(zmol,       3.145380241287e+00, TOL));
assert(isequalRel(zmos,       4.795490950675e-01, TOL));

# 4632
# 6251

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063033215444e+04,  6.877146000000e-01,  4.621022739372e+00,  0.000000000000e+00,  1.119778813470e+00,  4.870720014138e+00,  8.748547019630e-03);
assert(isequalRel(sinim,      9.000040530708e-01, TOL));
assert(isequalRel(cosim,      4.358815257110e-01, TOL));
assert(isequalRel(sinomm,    -9.958290077604e-01, TOL));
assert(isequalRel(cosomm,    -9.123917636090e-02, TOL));
assert(isequalRel(snodm,     -9.874918050266e-01, TOL));
assert(isequalRel(cnodm,      1.576703364790e-01, TOL));
assert(isequalRel(day,        3.889183215444e+04, TOL));
assert(isequalRel(e3,        -4.408046133189e-04, TOL));
assert(isequalRel(ee2,       -1.093428053938e-04, TOL));
assert(isequalRel(em,         6.877146000000e-01, TOL));
assert(isequalRel(emsq,       4.729513710532e-01, TOL));
assert(isequalRel(gam,        8.145518530246e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     7.259811491677e-01, TOL));
assert(isequalRel(se2,        2.501941522642e-03, TOL));
assert(isequalRel(se3,        1.007241988530e-03, TOL));
assert(isequalRel(sgh2,      -1.261915509701e-03, TOL));
assert(isequalRel(sgh3,       2.455746281541e-03, TOL));
assert(isequalRel(sgh4,      -7.471990261373e-05, TOL));
assert(isequalRel(sh2,        9.458037270825e-04, TOL));
assert(isequalRel(sh3,       -3.970223690620e-03, TOL));
assert(isequalRel(si2,       -1.110569917439e-03, TOL));
assert(isequalRel(si3,        2.735745904365e-05, TOL));
assert(isequalRel(sl2,        4.083492666433e-03, TOL));
assert(isequalRel(sl3,       -2.119115873088e-03, TOL));
assert(isequalRel(sl4,        2.888302541444e-04, TOL));
assert(isequalRel(s1,        -4.106209626082e-04, TOL));
assert(isequalRel(s2,        -3.776251664788e-05, TOL));
assert(isequalRel(s3,         5.482975046298e-05, TOL));
assert(isequalRel(s4,         3.980536524969e-05, TOL));
assert(isequalRel(s5,         3.199828401516e-01, TOL));
assert(isequalRel(s6,         1.331432334813e-01, TOL));
assert(isequalRel(s7,         5.367536651307e-01, TOL));
assert(isequalRel(ss1,       -2.556515817813e-03, TOL));
assert(isequalRel(ss2,       -2.351084818406e-04, TOL));
assert(isequalRel(ss3,        3.413686516514e-04, TOL));
assert(isequalRel(ss4,        2.478272060157e-04, TOL));
assert(isequalRel(ss5,        2.645498128236e-01, TOL));
assert(isequalRel(ss6,       -4.893264311548e-01, TOL));
assert(isequalRel(ss7,       -1.969950628727e-01, TOL));
assert(isequalRel(sz1,        2.823898158515e+00, TOL));
assert(isequalRel(sz2,       -5.981059840555e+00, TOL));
assert(isequalRel(sz3,        5.927750640042e+00, TOL));
assert(isequalRel(sz11,       5.580094190508e-01, TOL));
assert(isequalRel(sz12,       2.361824441093e+00, TOL));
assert(isequalRel(sz13,       4.998289169492e-01, TOL));
assert(isequalRel(sz21,       9.668540331305e-01, TOL));
assert(isequalRel(sz22,       2.011419834108e+00, TOL));
assert(isequalRel(sz23,      -7.476532737815e+00, TOL));
assert(isequalRel(sz31,      -1.967387569690e+00, TOL));
assert(isequalRel(sz32,      -2.545958391712e+00, TOL));
assert(isequalRel(sz33,       2.987165889194e+00, TOL));
assert(isequalRel(xgh2,       4.549202443830e-04, TOL));
assert(isequalRel(xgh3,      -2.464815107882e-05, TOL));
assert(isequalRel(xgh4,      -3.933566193975e-05, TOL));
assert(isequalRel(xh2,       -6.438340814882e-04, TOL));
assert(isequalRel(xh3,        3.079429279349e-04, TOL));
assert(isequalRel(xi2,        1.142408298542e-04, TOL));
assert(isequalRel(xi3,        1.200089628145e-04, TOL));
assert(isequalRel(xl2,       -7.862643771994e-04, TOL));
assert(isequalRel(xl3,       -4.559423560477e-04, TOL));
assert(isequalRel(xl4,        1.520522489668e-04, TOL));
assert(isequalRel(nm,         8.748547019630e-03, TOL));
assert(isequalRel(z1,         2.900052189777e+00, TOL));
assert(isequalRel(z2,         7.170052485742e+00, TOL));
assert(isequalRel(z3,         7.057852947556e+00, TOL));
assert(isequalRel(z11,        1.364174869534e+00, TOL));
assert(isequalRel(z12,       -1.512622038932e+00, TOL));
assert(isequalRel(z13,       -2.248209584395e-01, TOL));
assert(isequalRel(z21,       -5.118745162783e+00, TOL));
assert(isequalRel(z22,       -8.524777194958e+00, TOL));
assert(isequalRel(z23,       -1.041382803617e+00, TOL));
assert(isequalRel(z31,        1.083975928476e+00, TOL));
assert(isequalRel(z32,        5.714308128181e+00, TOL));
assert(isequalRel(z33,        7.743675261388e-01, TOL));
assert(isequalRel(zmol,       1.703291771992e+00, TOL));
assert(isequalRel(zmos,       2.972158040326e+00, TOL));
# 8195

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063056157475e+04,  7.069051000000e-01,  4.712788660783e+00,  0.000000000000e+00,  1.127426846252e+00,  6.097806906008e+00,  8.762667060363e-03);
assert(isequalRel(sinim,      9.033113351973e-01, TOL));
assert(isequalRel(cosim,      4.289855844945e-01, TOL));
assert(isequalRel(sinomm,    -9.999999201278e-01, TOL));
assert(isequalRel(cosomm,     3.996803880657e-04, TOL));
assert(isequalRel(snodm,     -1.843184645783e-01, TOL));
assert(isequalRel(cnodm,      9.828665746761e-01, TOL));
assert(isequalRel(day,        3.889206157475e+04, TOL));
assert(isequalRel(e3,         1.249431839564e-04, TOL));
assert(isequalRel(ee2,        6.476652597055e-04, TOL));
assert(isequalRel(em,         7.069051000000e-01, TOL));
assert(isequalRel(emsq,       4.997148204060e-01, TOL));
assert(isequalRel(gam,        8.145563137997e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     7.073084048659e-01, TOL));
assert(isequalRel(se2,       -3.006446485103e-03, TOL));
assert(isequalRel(se3,        2.366248156382e-03, TOL));
assert(isequalRel(sgh2,      -2.805617954096e-03, TOL));
assert(isequalRel(sgh3,      -3.755905951700e-03, TOL));
assert(isequalRel(sgh4,      -7.268074853619e-05, TOL));
assert(isequalRel(sh2,        2.948902195180e-03, TOL));
assert(isequalRel(sh3,        3.166374712604e-03, TOL));
assert(isequalRel(si2,        6.569128551896e-04, TOL));
assert(isequalRel(si3,       -6.992498193738e-04, TOL));
assert(isequalRel(sl2,        4.534351771255e-03, TOL));
assert(isequalRel(sl3,        6.836119210765e-03, TOL));
assert(isequalRel(sl4,        2.911149634817e-04, TOL));
assert(isequalRel(s1,        -4.105604224204e-04, TOL));
assert(isequalRel(s2,        -3.869698011745e-05, TOL));
assert(isequalRel(s3,         5.474139856001e-05, TOL));
assert(isequalRel(s4,         3.871905129561e-05, TOL));
assert(isequalRel(s5,         5.202004853494e-02, TOL));
assert(isequalRel(s6,        -7.887575425406e-01, TOL));
assert(isequalRel(s7,        -1.521617490792e-01, TOL));
assert(isequalRel(ss1,       -2.556138896122e-03, TOL));
assert(isequalRel(ss2,       -2.409264279726e-04, TOL));
assert(isequalRel(ss3,        3.408185749187e-04, TOL));
assert(isequalRel(ss4,        2.410638425744e-04, TOL));
assert(isequalRel(ss5,        4.864426121357e-02, TOL));
assert(isequalRel(ss6,        5.880835524362e-01, TOL));
assert(isequalRel(ss7,       -4.628559426039e-01, TOL));
assert(isequalRel(sz1,        1.251742101403e+01, TOL));
assert(isequalRel(sz2,       -6.652148833638e+00, TOL));
assert(isequalRel(sz3,        2.488450010326e+00, TOL));
assert(isequalRel(sz11,      -6.448698696437e-01, TOL));
assert(isequalRel(sz12,      -1.363305928531e+00, TOL));
assert(isequalRel(sz13,       8.062989067707e-01, TOL));
assert(isequalRel(sz21,      -7.726437183168e+00, TOL));
assert(isequalRel(sz22,       6.119922625331e+00, TOL));
assert(isequalRel(sz23,      -1.155188982526e+00, TOL));
assert(isequalRel(sz31,       5.782028627321e+00, TOL));
assert(isequalRel(sz32,      -5.819242579338e+00, TOL));
assert(isequalRel(sz33,      -2.008243674800e+00, TOL));
assert(isequalRel(xgh2,      -1.815715485263e-04, TOL));
assert(isequalRel(xgh3,       8.134154625503e-04, TOL));
assert(isequalRel(xgh4,      -3.826216649032e-05, TOL));
assert(isequalRel(xh2,        4.816111792216e-05, TOL));
assert(isequalRel(xh3,       -6.696421947166e-04, TOL));
assert(isequalRel(xi2,       -1.383644676752e-04, TOL));
assert(isequalRel(xi3,       -7.113039969238e-07, TOL));
assert(isequalRel(xl2,        4.111399428162e-04, TOL));
assert(isequalRel(xl3,       -1.491371542789e-03, TOL));
assert(isequalRel(xl4,        1.532550149097e-04, TOL));
assert(isequalRel(nm,         8.762667060363e-03, TOL));
assert(isequalRel(z1,         1.736414847372e+00, TOL));
assert(isequalRel(z2,        -3.755292645342e+00, TOL));
assert(isequalRel(z3,         1.535838635358e+01, TOL));
assert(isequalRel(z11,        9.953838810723e-02, TOL));
assert(isequalRel(z12,        1.787794128318e+00, TOL));
assert(isequalRel(z13,        1.087290794062e-01, TOL));
assert(isequalRel(z21,        6.157731267206e-02, TOL));
assert(isequalRel(z22,        6.222852245315e-01, TOL));
assert(isequalRel(z23,       -8.590805802032e+00, TOL));
assert(isequalRel(z31,       -2.838481585876e+00, TOL));
assert(isequalRel(z32,       -2.344731371903e+00, TOL));
assert(isequalRel(z33,        7.665591155216e+00, TOL));
assert(isequalRel(zmol,       1.755605827278e+00, TOL));
assert(isequalRel(zmos,       2.976104523220e+00, TOL));
# 9880

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.023779417928e+04,  2.709710000000e-02,  5.716345999363e+00,  0.000000000000e+00,  1.657329751109e-01,  5.465934884933e+00,  5.069384722250e-03);
assert(isequalRel(sinim,      1.649753069066e-01, TOL));
assert(isequalRel(cosim,      9.862976975087e-01, TOL));
assert(isequalRel(sinomm,    -5.369683678799e-01, TOL));
assert(isequalRel(cosomm,     8.436023778395e-01, TOL));
assert(isequalRel(snodm,     -7.292672480414e-01, TOL));
assert(isequalRel(cnodm,      6.842289682074e-01, TOL));
assert(isequalRel(day,        3.849929417928e+04, TOL));
assert(isequalRel(e3,         4.759541749927e-05, TOL));
assert(isequalRel(ee2,       -5.215931631248e-05, TOL));
assert(isequalRel(em,         2.709710000000e-02, TOL));
assert(isequalRel(emsq,       7.342528284100e-04, TOL));
assert(isequalRel(gam,        8.069194702478e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.996328061701e-01, TOL));
assert(isequalRel(se2,       -4.545493382307e-04, TOL));
assert(isequalRel(se3,       -1.408307282420e-05, TOL));
assert(isequalRel(sgh2,       3.341762775910e-04, TOL));
assert(isequalRel(sgh3,      -1.631250708160e-02, TOL));
assert(isequalRel(sgh4,      -1.775546834310e-04, TOL));
assert(isequalRel(sh2,       -7.925299564105e-04, TOL));
assert(isequalRel(sh3,       -7.614980505856e-04, TOL));
assert(isequalRel(si2,       -7.593552438778e-04, TOL));
assert(isequalRel(si3,        7.406357152159e-04, TOL));
assert(isequalRel(sl2,       -6.650365679906e-05, TOL));
assert(isequalRel(sl3,        1.569236751846e-02, TOL));
assert(isequalRel(sl4,        4.145768614330e-04, TOL));
assert(isequalRel(s1,        -3.844603186866e-05, TOL));
assert(isequalRel(s2,        -4.732890446927e-05, TOL));
assert(isequalRel(s3,         9.462305117515e-05, TOL));
assert(isequalRel(s4,         9.458830617460e-05, TOL));
assert(isequalRel(s5,        -2.695688550324e-02, TOL));
assert(isequalRel(s6,         6.783446012149e-01, TOL));
assert(isequalRel(s7,        -6.189899865592e-01, TOL));
assert(isequalRel(ss1,       -2.393640304675e-04, TOL));
assert(isequalRel(ss2,       -2.946685725612e-04, TOL));
assert(isequalRel(ss3,        5.891207441590e-04, TOL));
assert(isequalRel(ss4,        5.889044226567e-04, TOL));
assert(isequalRel(ss5,       -1.753069382440e-02, TOL));
assert(isequalRel(ss6,        9.494938260834e-01, TOL));
assert(isequalRel(ss7,        2.941768818959e-02, TOL));
assert(isequalRel(sz1,        1.630534276736e+01, TOL));
assert(isequalRel(sz2,        5.644314638249e-02, TOL));
assert(isequalRel(sz3,        2.986878196174e+00, TOL));
assert(isequalRel(sz11,       1.457191263623e+00, TOL));
assert(isequalRel(sz12,       1.288490383073e+00, TOL));
assert(isequalRel(sz13,       2.004645812038e-01, TOL));
assert(isequalRel(sz21,       9.813117642790e-01, TOL));
assert(isequalRel(sz22,      -1.344781952011e+00, TOL));
assert(isequalRel(sz23,      -3.108145795094e-01, TOL));
assert(isequalRel(sz31,       1.086186823499e+01, TOL));
assert(isequalRel(sz32,       2.837270911326e-01, TOL));
assert(isequalRel(sz33,      -2.988008293373e+00, TOL));
assert(isequalRel(xgh2,      -1.706031133674e-03, TOL));
assert(isequalRel(xgh3,      -1.810449604366e-03, TOL));
assert(isequalRel(xgh4,      -9.347216416174e-05, TOL));
assert(isequalRel(xh2,       -2.227234299372e-04, TOL));
assert(isequalRel(xh3,        5.491720843604e-06, TOL));
assert(isequalRel(xi2,       -6.826729645968e-06, TOL));
assert(isequalRel(xi3,        2.099107684283e-04, TOL));
assert(isequalRel(xl2,        1.640123445179e-03, TOL));
assert(isequalRel(xl3,        1.647042035558e-03, TOL));
assert(isequalRel(xl4,        2.182504888112e-04, TOL));
assert(isequalRel(nm,         5.069384722250e-03, TOL));
assert(isequalRel(z1,         1.347308349031e+01, TOL));
assert(isequalRel(z2,        -8.666616774718e+00, TOL));
assert(isequalRel(z3,         4.769908021423e+00, TOL));
assert(isequalRel(z11,        2.121080157488e+00, TOL));
assert(isequalRel(z12,        7.212008943076e-02, TOL));
assert(isequalRel(z13,       -9.649460768102e-02, TOL));
assert(isequalRel(z21,        3.902915047865e-01, TOL));
assert(isequalRel(z22,       -2.352932446195e+00, TOL));
assert(isequalRel(z23,        4.483080689261e-01, TOL));
assert(isequalRel(z31,        8.376216737664e+00, TOL));
assert(isequalRel(z32,       -9.018192642782e+00, TOL));
assert(isequalRel(z33,       -1.193938800509e+00, TOL));
assert(isequalRel(zmol,       1.585773955921e-01, TOL));
assert(isequalRel(zmos,       2.502914127169e+00, TOL));
# 9998

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 1.118729629788e+04,  7.318036000000e-01,  8.285461931653e-01,  0.000000000000e+00,  8.166674822762e-01,  4.021856443150e+00,  9.971131604593e-03);
assert(isequalRel(sinim,      7.288682597402e-01, TOL));
assert(isequalRel(cosim,      6.846539709542e-01, TOL));
assert(isequalRel(sinomm,     7.369494526341e-01, TOL));
assert(isequalRel(cosomm,     6.759478561711e-01, TOL));
assert(isequalRel(snodm,     -7.709069259013e-01, TOL));
assert(isequalRel(cnodm,     -6.369478091629e-01, TOL));
assert(isequalRel(day,        2.944879629788e+04, TOL));
assert(isequalRel(e3,        -7.499513315530e-05, TOL));
assert(isequalRel(ee2,        3.984687909508e-04, TOL));
assert(isequalRel(em,         7.318036000000e-01, TOL));
assert(isequalRel(emsq,       5.355365089730e-01, TOL));
assert(isequalRel(gam,        6.309444856012e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     6.815155838475e-01, TOL));
assert(isequalRel(se2,       -2.359225311260e-03, TOL));
assert(isequalRel(se3,       -7.047176327541e-05, TOL));
assert(isequalRel(sgh2,      -1.822566953373e-04, TOL));
assert(isequalRel(sgh3,      -2.213029457235e-03, TOL));
assert(isequalRel(sgh4,      -6.154293814758e-05, TOL));
assert(isequalRel(sh2,       -1.139407335123e-03, TOL));
assert(isequalRel(sh3,        2.509518062136e-03, TOL));
assert(isequalRel(si2,       -5.208303751558e-05, TOL));
assert(isequalRel(si3,        3.287353432187e-03, TOL));
assert(isequalRel(sl2,        2.781684009380e-03, TOL));
assert(isequalRel(sl3,        3.338363278200e-03, TOL));
assert(isequalRel(sl4,        2.590677065105e-04, TOL));
assert(isequalRel(s1,        -3.598896383932e-04, TOL));
assert(isequalRel(s2,        -3.529408803158e-05, TOL));
assert(isequalRel(s3,         4.810694202241e-05, TOL));
assert(isequalRel(s4,         3.278563067952e-05, TOL));
assert(isequalRel(s5,        -3.295141721071e-01, TOL));
assert(isequalRel(s6,        -5.535985875140e-01, TOL));
assert(isequalRel(s7,         1.041918482151e-01, TOL));
assert(isequalRel(ss1,       -2.240663865223e-03, TOL));
assert(isequalRel(ss2,       -2.197401071657e-04, TOL));
assert(isequalRel(ss3,        2.995126148595e-04, TOL));
assert(isequalRel(ss4,        2.041225145857e-04, TOL));
assert(isequalRel(ss5,       -2.842063666668e-01, TOL));
assert(isequalRel(ss6,        5.264567675405e-01, TOL));
assert(isequalRel(ss7,        1.572564371863e-02, TOL));
assert(isequalRel(sz1,        7.241600464427e+00, TOL));
assert(isequalRel(sz2,       -4.643684224593e+00, TOL));
assert(isequalRel(sz3,        1.668607687869e+00, TOL));
assert(isequalRel(sz11,       5.923151674967e+00, TOL));
assert(isequalRel(sz12,       1.185105399906e-01, TOL));
assert(isequalRel(sz13,      -1.556942593186e+00, TOL));
assert(isequalRel(sz21,      -5.548981285667e+00, TOL));
assert(isequalRel(sz22,      -2.592624873582e+00, TOL));
assert(isequalRel(sz23,       1.612144872051e-01, TOL));
assert(isequalRel(sz31,       3.273877043602e+00, TOL));
assert(isequalRel(sz32,      -4.464394721650e-01, TOL));
assert(isequalRel(sz33,      -2.146959216736e+00, TOL));
assert(isequalRel(xgh2,       1.510256022480e-04, TOL));
assert(isequalRel(xgh3,       3.555337411429e-04, TOL));
assert(isequalRel(xgh4,      -3.239876023751e-05, TOL));
assert(isequalRel(xh2,        1.128589566218e-04, TOL));
assert(isequalRel(xh3,       -4.733943399734e-04, TOL));
assert(isequalRel(xi2,       -6.414087511194e-05, TOL));
assert(isequalRel(xi3,       -5.695169719647e-04, TOL));
assert(isequalRel(xl2,       -7.034864700241e-04, TOL));
assert(isequalRel(xl3,       -5.240671428885e-04, TOL));
assert(isequalRel(xl4,        1.363840070226e-04, TOL));
assert(isequalRel(nm,         9.971131604593e-03, TOL));
assert(isequalRel(z1,         2.557388153538e+00, TOL));
assert(isequalRel(z2,         7.311693909959e+00, TOL));
assert(isequalRel(z3,         8.004285429241e+00, TOL));
assert(isequalRel(z11,       -1.949045345611e+00, TOL));
assert(isequalRel(z12,        9.086631598833e-01, TOL));
assert(isequalRel(z13,        6.119118527262e+00, TOL));
assert(isequalRel(z21,        6.841370517902e-01, TOL));
assert(isequalRel(z22,        1.598836560401e+00, TOL));
assert(isequalRel(z23,       -6.022288391897e+00, TOL));
assert(isequalRel(z31,       -1.633514023053e+00, TOL));
assert(isequalRel(z32,        2.303228565651e+00, TOL));
assert(isequalRel(z33,        3.788583001984e+00, TOL));
assert(isequalRel(zmol,       3.567468389971e+00, TOL));
assert(isequalRel(zmos,       3.896090412269e+00, TOL));
# 11801

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063002844893e+04,  1.156200000000e-03,  4.617827041512e-01,  0.000000000000e+00,  1.996377411601e-01,  6.145897708218e-01,  4.313874514604e-03);
assert(isequalRel(sinim,      1.983142799855e-01, TOL));
assert(isequalRel(cosim,      9.801384832532e-01, TOL));
assert(isequalRel(sinomm,     4.455447971855e-01, TOL));
assert(isequalRel(cosomm,     8.952596459692e-01, TOL));
assert(isequalRel(snodm,      5.766234094473e-01, TOL));
assert(isequalRel(cnodm,      8.170100633881e-01, TOL));
assert(isequalRel(day,        3.889152844893e+04, TOL));
assert(isequalRel(e3,        -2.023952527045e-06, TOL));
assert(isequalRel(ee2,        3.000360099525e-06, TOL));
assert(isequalRel(em,         1.156200000000e-03, TOL));
assert(isequalRel(emsq,       1.336798440000e-06, TOL));
assert(isequalRel(gam,        8.145459478719e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.999993316006e-01, TOL));
assert(isequalRel(se2,       -3.298847558934e-06, TOL));
assert(isequalRel(se3,        2.290506347297e-05, TOL));
assert(isequalRel(sgh2,      -1.939779689075e-02, TOL));
assert(isequalRel(sgh3,      -2.730323108731e-03, TOL));
assert(isequalRel(sgh4,      -2.087272183414e-04, TOL));
assert(isequalRel(sh2,       -2.473782067380e-04, TOL));
assert(isequalRel(sh3,       -1.070558033105e-03, TOL));
assert(isequalRel(si2,       -1.043419845310e-03, TOL));
assert(isequalRel(si3,        2.771277863689e-04, TOL));
assert(isequalRel(sl2,        1.883089760893e-02, TOL));
assert(isequalRel(sl3,        2.558661635920e-03, TOL));
assert(isequalRel(sl4,        4.870307806874e-04, TOL));
assert(isequalRel(s1,        -1.928451076707e-06, TOL));
assert(isequalRel(s2,        -5.559746452923e-05, TOL));
assert(isequalRel(s3,         1.111948547358e-04, TOL));
assert(isequalRel(s4,         1.111947804133e-04, TOL));
assert(isequalRel(s5,        -2.173422574442e-02, TOL));
assert(isequalRel(s6,        -7.779196827354e-01, TOL));
assert(isequalRel(s7,         5.247611804860e-01, TOL));
assert(isequalRel(ss1,       -1.200648805206e-05, TOL));
assert(isequalRel(ss2,       -3.461484201792e-04, TOL));
assert(isequalRel(ss3,        6.922963776275e-04, TOL));
assert(isequalRel(ss4,        6.922959148970e-04, TOL));
assert(isequalRel(ss5,       -5.358747472118e-03, TOL));
assert(isequalRel(ss6,        1.373777054802e-01, TOL));
assert(isequalRel(ss7,       -9.538619192246e-01, TOL));
assert(isequalRel(sz1,        1.078528759969e+01, TOL));
assert(isequalRel(sz2,       -1.360031499331e+01, TOL));
assert(isequalRel(sz3,        8.937335105200e+00, TOL));
assert(isequalRel(sz11,      -4.630982613971e-01, TOL));
assert(isequalRel(sz12,       1.507185623973e+00, TOL));
assert(isequalRel(sz13,      -8.634002275673e-01, TOL));
assert(isequalRel(sz21,       1.168263836916e+00, TOL));
assert(isequalRel(sz22,      -3.573296775556e-01, TOL));
assert(isequalRel(sz23,      -3.781220061153e-01, TOL));
assert(isequalRel(sz31,       5.061183248572e+00, TOL));
assert(isequalRel(sz32,      -1.400975830807e+01, TOL));
assert(isequalRel(sz33,       3.089249679430e+00, TOL));
assert(isequalRel(xgh2,       1.723156593166e-03, TOL));
assert(isequalRel(xgh3,       2.484248746878e-03, TOL));
assert(isequalRel(xgh4,      -1.098826820044e-04, TOL));
assert(isequalRel(xh2,       -1.510439919480e-04, TOL));
assert(isequalRel(xh3,        1.680607206591e-04, TOL));
assert(isequalRel(xi2,        1.739604100604e-04, TOL));
assert(isequalRel(xi3,        1.380206186465e-04, TOL));
assert(isequalRel(xl2,       -1.687937988178e-03, TOL));
assert(isequalRel(xl3,       -2.328138479321e-03, TOL));
assert(isequalRel(xl4,        2.563932429410e-04, TOL));
assert(isequalRel(nm,         4.313874514604e-03, TOL));
assert(isequalRel(z1,         4.216765164053e+00, TOL));
assert(isequalRel(z2,         7.590000419482e+00, TOL));
assert(isequalRel(z3,         1.468549811421e+01, TOL));
assert(isequalRel(z11,       -1.569394720994e-01, TOL));
assert(isequalRel(z12,       -1.564463519456e+00, TOL));
assert(isequalRel(z13,       -1.398188689264e+00, TOL));
assert(isequalRel(z21,       -1.680069232651e-01, TOL));
assert(isequalRel(z22,       -1.358371224542e+00, TOL));
assert(isequalRel(z23,        1.343399415874e+00, TOL));
assert(isequalRel(z31,       -1.774410090226e+00, TOL));
assert(isequalRel(z32,        7.748369962881e+00, TOL));
assert(isequalRel(z33,        9.396297462977e+00, TOL));
assert(isequalRel(zmol,       1.634038675524e+00, TOL));
assert(isequalRel(zmos,       2.966933705124e+00, TOL));
# 14128

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.060567415771e+04,  5.596327000000e-01,  4.278836976885e+00,  0.000000000000e+00,  1.083685404539e+00,  5.149138427074e+00,  2.131732105901e-02);
assert(isequalRel(sinim,      8.836888491856e-01, TOL));
assert(isequalRel(cosim,      4.680747993911e-01, TOL));
assert(isequalRel(sinomm,    -9.074792921580e-01, TOL));
assert(isequalRel(cosomm,    -4.200968153942e-01, TOL));
assert(isequalRel(snodm,     -9.061314198773e-01, TOL));
assert(isequalRel(cnodm,      4.229962764744e-01, TOL));
assert(isequalRel(day,        3.886717415771e+04, TOL));
assert(isequalRel(e3,        -1.668567580056e-04, TOL));
assert(isequalRel(ee2,       -8.275330366745e-05, TOL));
assert(isequalRel(em,         5.596327000000e-01, TOL));
assert(isequalRel(emsq,       3.131887589093e-01, TOL));
assert(isequalRel(gam,        8.140724108268e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     8.287407562626e-01, TOL));
assert(isequalRel(se2,        1.125966825154e-03, TOL));
assert(isequalRel(se3,        5.685080602400e-05, TOL));
assert(isequalRel(sgh2,      -8.864271738038e-05, TOL));
assert(isequalRel(sgh3,       1.625809438486e-03, TOL));
assert(isequalRel(sgh4,      -3.500523155064e-05, TOL));
assert(isequalRel(sh2,        2.744561082561e-04, TOL));
assert(isequalRel(sh3,       -9.759618675546e-04, TOL));
assert(isequalRel(si2,       -4.991454790905e-04, TOL));
assert(isequalRel(si3,       -4.573037379522e-04, TOL));
assert(isequalRel(sl2,        1.462141038683e-04, TOL));
assert(isequalRel(sl3,       -1.456991037415e-03, TOL));
assert(isequalRel(sl4,        1.117866087106e-04, TOL));
assert(isequalRel(s1,        -1.565426252795e-04, TOL));
assert(isequalRel(s2,        -1.357597034132e-05, TOL));
assert(isequalRel(s3,         2.250191985532e-05, TOL));
assert(isequalRel(s4,         1.864825807826e-05, TOL));
assert(isequalRel(s5,         8.624271127389e-02, TOL));
assert(isequalRel(s6,         2.643155610802e-01, TOL));
assert(isequalRel(s7,         5.329435280254e-01, TOL));
assert(isequalRel(ss1,       -9.746304600404e-04, TOL));
assert(isequalRel(ss2,       -8.452365095850e-05, TOL));
assert(isequalRel(ss3,        1.400963888348e-04, TOL));
assert(isequalRel(ss4,        1.161035872326e-04, TOL));
assert(isequalRel(ss5,        1.603399424520e-02, TOL));
assert(isequalRel(ss6,       -5.776378182905e-01, TOL));
assert(isequalRel(ss7,       -2.916531360083e-02, TOL));
assert(isequalRel(sz1,        2.070490436592e+00, TOL));
assert(isequalRel(sz2,       -5.218339497697e-01, TOL));
assert(isequalRel(sz3,        7.270449727238e+00, TOL));
assert(isequalRel(sz11,       7.572811749063e-03, TOL));
assert(isequalRel(sz12,       2.952697105663e+00, TOL));
assert(isequalRel(sz13,       2.712754928035e+00, TOL));
assert(isequalRel(sz21,       4.211910638255e-03, TOL));
assert(isequalRel(sz22,       1.623546221346e+00, TOL));
assert(isequalRel(sz23,      -5.769094474540e+00, TOL));
assert(isequalRel(sz31,      -2.992321735369e+00, TOL));
assert(isequalRel(sz32,      -3.817397872589e-01, TOL));
assert(isequalRel(sz33,       4.009225233322e+00, TOL));
assert(isequalRel(xgh2,       2.432700701456e-04, TOL));
assert(isequalRel(xgh3,      -1.126161998557e-04, TOL));
assert(isequalRel(xgh4,      -1.842820863294e-05, TOL));
assert(isequalRel(xh2,       -1.621327565099e-04, TOL));
assert(isequalRel(xh3,        5.347365712173e-05, TOL));
assert(isequalRel(xi2,       -1.237488399592e-05, TOL));
assert(isequalRel(xi3,        1.015094158511e-04, TOL));
assert(isequalRel(xl2,       -2.580143538619e-04, TOL));
assert(isequalRel(xl3,        5.639729900996e-05, TOL));
assert(isequalRel(xl4,        5.884911644441e-05, TOL));
assert(isequalRel(nm,         2.131732105901e-02, TOL));
assert(isequalRel(z1,         5.540026309401e+00, TOL));
assert(isequalRel(z2,         5.733163114988e+00, TOL));
assert(isequalRel(z3,         4.286859926875e+00, TOL));
assert(isequalRel(z11,        3.326689201301e+00, TOL));
assert(isequalRel(z12,        4.557642542225e-01, TOL));
assert(isequalRel(z13,       -4.118802452673e-01, TOL));
assert(isequalRel(z21,       -3.822206433384e+00, TOL));
assert(isequalRel(z22,       -5.971313741622e+00, TOL));
assert(isequalRel(z23,       -1.852783409566e+00, TOL));
assert(isequalRel(z31,        2.175359468061e+00, TOL));
assert(isequalRel(z32,        6.522595009269e+00, TOL));
assert(isequalRel(z33,       -8.441236220770e-01, TOL));
assert(isequalRel(zmol,       2.363784803869e+00, TOL));
assert(isequalRel(zmos,       2.547991747703e+00, TOL));
# 16925

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.045279166667e+04,  7.864447000000e-01,  3.426128445555e+00,  0.000000000000e+00,  2.155725972308e-01,  3.271188586538e+00,  1.077283640185e-03);
assert(isequalRel(sinim,      2.139068072733e-01, TOL));
assert(isequalRel(cosim,      9.768540719074e-01, TOL));
assert(isequalRel(sinomm,    -2.807119383680e-01, TOL));
assert(isequalRel(cosomm,    -9.597920648024e-01, TOL));
assert(isequalRel(snodm,     -1.292334745570e-01, TOL));
assert(isequalRel(cnodm,     -9.916141936529e-01, TOL));
assert(isequalRel(day,        3.871429166667e+04, TOL));
assert(isequalRel(e3,        -4.548826202443e-03, TOL));
assert(isequalRel(ee2,        2.057187923104e-03, TOL));
assert(isequalRel(em,         7.864447000000e-01, TOL));
assert(isequalRel(emsq,       6.184952661581e-01, TOL));
assert(isequalRel(gam,        8.110998125934e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     6.176606947523e-01, TOL));
assert(isequalRel(se2,        2.969569919355e-02, TOL));
assert(isequalRel(se3,        1.468368332662e-02, TOL));
assert(isequalRel(sgh2,      -1.634808994984e-02, TOL));
assert(isequalRel(sgh3,       4.324216378214e-02, TOL));
assert(isequalRel(sgh4,      -5.162579880111e-04, TOL));
assert(isequalRel(sh2,        1.425174198066e-02, TOL));
assert(isequalRel(sh3,        4.931955088329e-03, TOL));
assert(isequalRel(si2,        5.144176519066e-02, TOL));
assert(isequalRel(si3,       -8.646214930954e-04, TOL));
assert(isequalRel(sl2,        3.951910009817e-02, TOL));
assert(isequalRel(sl3,       -1.241558054094e-01, TOL));
assert(isequalRel(sl4,        2.467220444289e-03, TOL));
assert(isequalRel(s1,        -3.244378761083e-03, TOL));
assert(isequalRel(s2,        -3.604476295552e-04, TOL));
assert(isequalRel(s3,         4.452686665858e-04, TOL));
assert(isequalRel(s4,         2.750249539548e-04, TOL));
assert(isequalRel(s5,        -1.401774145800e-01, TOL));
assert(isequalRel(s6,        -3.170388038198e-01, TOL));
assert(isequalRel(s7,         7.010319289793e-01, TOL));
assert(isequalRel(ss1,       -2.019942082109e-02, TOL));
assert(isequalRel(ss2,       -2.244137904207e-03, TOL));
assert(isequalRel(ss3,        2.772231554066e-03, TOL));
assert(isequalRel(ss4,        1.712298467698e-03, TOL));
assert(isequalRel(ss5,       -1.156263617362e-01, TOL));
assert(isequalRel(ss6,       -7.350631351406e-01, TOL));
assert(isequalRel(ss7,       -3.634679295182e-01, TOL));
assert(isequalRel(sz1,        1.342983301258e+00, TOL));
assert(isequalRel(sz2,       -7.127669411348e+00, TOL));
assert(isequalRel(sz3,        2.373573855782e+01, TOL));
assert(isequalRel(sz11,       1.488445240897e+00, TOL));
assert(isequalRel(sz12,      -1.146136453874e+01, TOL));
assert(isequalRel(sz13,       1.681085250112e+00, TOL));
assert(isequalRel(sz21,      -1.539375336156e+00, TOL));
assert(isequalRel(sz22,       3.175326693145e+00, TOL));
assert(isequalRel(sz23,      -4.405223915392e-01, TOL));
assert(isequalRel(sz31,      -1.641109798937e+00, TOL));
assert(isequalRel(sz32,      -4.773726735800e+00, TOL));
assert(isequalRel(sz33,       1.098582545735e+01, TOL));
assert(isequalRel(xgh2,       6.919617584769e-03, TOL));
assert(isequalRel(xgh3,       2.084732624778e-03, TOL));
assert(isequalRel(xgh4,      -2.717796594982e-04, TOL));
assert(isequalRel(xh2,        7.186248636015e-04, TOL));
assert(isequalRel(xh3,       -2.561986795698e-03, TOL));
assert(isequalRel(xi2,       -5.475272881099e-04, TOL));
assert(isequalRel(xi3,       -9.211923499783e-03, TOL));
assert(isequalRel(xl2,       -2.030877598251e-02, TOL));
assert(isequalRel(xl3,       -4.767341552120e-03, TOL));
assert(isequalRel(xl4,        1.298847374429e-03, TOL));
assert(isequalRel(nm,         1.077283640185e-03, TOL));
assert(isequalRel(z1,         9.726328330151e+00, TOL));
assert(isequalRel(z2,         2.280508096183e+01, TOL));
assert(isequalRel(z3,         1.507965982400e+01, TOL));
assert(isequalRel(z11,       -4.806687489380e+00, TOL));
assert(isequalRel(z12,        7.595101801411e-01, TOL));
assert(isequalRel(z13,        7.971761783749e+00, TOL));
assert(isequalRel(z21,        7.614242560927e-01, TOL));
assert(isequalRel(z22,        9.968505889305e-01, TOL));
assert(isequalRel(z23,       -2.792471768775e+00, TOL));
assert(isequalRel(z31,        2.853856110337e+00, TOL));
assert(isequalRel(z32,        1.257998135308e+01, TOL));
assert(isequalRel(z33,        6.643935146438e+00, TOL));
assert(isequalRel(zmol,       5.201540682068e+00, TOL));
assert(isequalRel(zmos,       6.201295960309e+00, TOL));
# 20413

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063002341244e+04,  7.421690000000e-01,  4.416489349660e+00,  0.000000000000e+00,  1.085156717098e+00,  3.455919470557e+00,  8.782535528761e-03);
assert(isequalRel(sinim,      8.843765767810e-01, TOL));
assert(isequalRel(cosim,      4.667741107229e-01, TOL));
assert(isequalRel(sinomm,    -9.565401966673e-01, TOL));
assert(isequalRel(cosomm,    -2.916005009591e-01, TOL));
assert(isequalRel(snodm,     -3.091763410854e-01, TOL));
assert(isequalRel(cnodm,     -9.510047266513e-01, TOL));
assert(isequalRel(day,        3.889152341244e+04, TOL));
assert(isequalRel(e3,        -5.809658803806e-05, TOL));
assert(isequalRel(ee2,        1.029719050358e-04, TOL));
assert(isequalRel(em,         7.421690000000e-01, TOL));
assert(isequalRel(emsq,       5.508148245610e-01, TOL));
assert(isequalRel(gam,        8.145458499440e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     6.702127837031e-01, TOL));
assert(isequalRel(se2,       -5.827763896555e-04, TOL));
assert(isequalRel(se3,        7.782941825865e-04, TOL));
assert(isequalRel(sgh2,      -1.403967386252e-05, TOL));
assert(isequalRel(sgh3,      -1.232243049360e-03, TOL));
assert(isequalRel(sgh4,      -6.871312109088e-05, TOL));
assert(isequalRel(sh2,        1.040864137284e-03, TOL));
assert(isequalRel(sh3,        1.047903595216e-03, TOL));
assert(isequalRel(si2,        1.704326979978e-03, TOL));
assert(isequalRel(si3,        5.269146587838e-04, TOL));
assert(isequalRel(sl2,        6.958156453603e-04, TOL));
assert(isequalRel(sl3,       -1.138733166786e-03, TOL));
assert(isequalRel(sl4,        2.956953768062e-04, TOL));
assert(isequalRel(s1,        -4.075107416397e-04, TOL));
assert(isequalRel(s2,        -4.074643162103e-05, TOL));
assert(isequalRel(s3,         5.461755872540e-05, TOL));
assert(isequalRel(s4,         3.660538607241e-05, TOL));
assert(isequalRel(s5,        -1.448694740914e-01, TOL));
assert(isequalRel(s6,        -1.263425653782e-01, TOL));
assert(isequalRel(s7,         7.128227811161e-02, TOL));
assert(isequalRel(ss1,       -2.537151660045e-03, TOL));
assert(isequalRel(ss2,       -2.536862616486e-04, TOL));
assert(isequalRel(ss3,        3.400475512134e-04, TOL));
assert(isequalRel(ss4,        2.279042158902e-04, TOL));
assert(isequalRel(ss5,       -1.671806012792e-01, TOL));
assert(isequalRel(ss6,        1.148485521842e-01, TOL));
assert(isequalRel(ss7,       -1.533795150765e-01, TOL));
assert(isequalRel(sz1,        2.823148385069e-01, TOL));
assert(isequalRel(sz2,       -1.023115212677e+00, TOL));
assert(isequalRel(sz3,        1.956688264698e+00, TOL));
assert(isequalRel(sz11,       7.560455550249e-01, TOL));
assert(isequalRel(sz12,      -3.359123527034e+00, TOL));
assert(isequalRel(sz13,      -2.824707906370e-01, TOL));
assert(isequalRel(sz21,      -1.883155445920e+00, TOL));
assert(isequalRel(sz22,       2.051479119366e+00, TOL));
assert(isequalRel(sz23,       1.821980115480e-01, TOL));
assert(isequalRel(sz31,       1.221664044049e-01, TOL));
assert(isequalRel(sz32,      -3.080169844091e-02, TOL));
assert(isequalRel(sz33,      -2.581256708122e+00, TOL));
assert(isequalRel(xgh2,      -1.645505874222e-04, TOL));
assert(isequalRel(xgh3,       1.067426866480e-04, TOL));
assert(isequalRel(xgh4,      -3.617344251676e-05, TOL));
assert(isequalRel(xh2,       -7.385557332388e-05, TOL));
assert(isequalRel(xh3,       -1.379346924380e-04, TOL));
assert(isequalRel(xi2,       -1.440041796867e-04, TOL));
assert(isequalRel(xi3,       -2.339553088854e-04, TOL));
assert(isequalRel(xl2,       -1.733725252342e-04, TOL));
assert(isequalRel(xl3,        1.029442407285e-04, TOL));
assert(isequalRel(xl4,        1.556663348362e-04, TOL));
assert(isequalRel(nm,         8.782535528761e-03, TOL));
assert(isequalRel(z1,         1.395145995474e+00, TOL));
assert(isequalRel(z2,         1.587150078475e+00, TOL));
assert(isequalRel(z3,         4.527362363151e-01, TOL));
assert(isequalRel(z11,       -1.416027632726e+00, TOL));
assert(isequalRel(z12,        1.767077188820e+00, TOL));
assert(isequalRel(z13,        1.454841049240e+00, TOL));
assert(isequalRel(z21,        7.775545601669e-01, TOL));
assert(isequalRel(z22,       -9.062827146532e-01, TOL));
assert(isequalRel(z23,       -9.150438705484e-01, TOL));
assert(isequalRel(z31,       -2.067807705441e+00, TOL));
assert(isequalRel(z32,       -2.247628082609e+00, TOL));
assert(isequalRel(z33,       -6.097888439984e-01, TOL));
assert(isequalRel(zmol,       1.632890219145e+00, TOL));
assert(isequalRel(zmos,       2.966847067538e+00, TOL));
# 21897
# 22312
# *** error: t:= 494.202867 *** code =   1

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063055909107e+04,  7.541712000000e-01,  4.421379762224e+00,  0.000000000000e+00,  1.108345161540e+00,  6.186235757890e+00,  8.582332516240e-03);
assert(isequalRel(sinim,      8.949616166056e-01, TOL));
assert(isequalRel(cosim,      4.461431438481e-01, TOL));
assert(isequalRel(sinomm,    -9.579547993872e-01, TOL));
assert(isequalRel(cosomm,    -2.869191564378e-01, TOL));
assert(isequalRel(snodm,     -9.679774570435e-02, TOL));
assert(isequalRel(cnodm,      9.953040723450e-01, TOL));
assert(isequalRel(day,        3.889205909107e+04, TOL));
assert(isequalRel(e3,        -1.880237977527e-04, TOL));
assert(isequalRel(ee2,        6.551908742706e-04, TOL));
assert(isequalRel(em,         7.541712000000e-01, TOL));
assert(isequalRel(emsq,       5.687741989094e-01, TOL));
assert(isequalRel(gam,        8.145562655079e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     6.566778518349e-01, TOL));
assert(isequalRel(se2,       -1.668215845123e-03, TOL));
assert(isequalRel(se3,        3.610858069376e-03, TOL));
assert(isequalRel(sgh2,      -4.299448087716e-03, TOL));
assert(isequalRel(sgh3,      -1.722984622184e-03, TOL));
assert(isequalRel(sgh4,      -6.889598529018e-05, TOL));
assert(isequalRel(sh2,        3.935976325614e-03, TOL));
assert(isequalRel(sh3,        3.059743184660e-03, TOL));
assert(isequalRel(si2,        1.789568818084e-03, TOL));
assert(isequalRel(si3,        2.366876188168e-04, TOL));
assert(isequalRel(sl2,        9.202998763432e-03, TOL));
assert(isequalRel(sl3,        2.742276317175e-03, TOL));
assert(isequalRel(sl4,        3.044773891692e-04, TOL));
assert(isequalRel(s1,        -4.152029536535e-04, TOL));
assert(isequalRel(s2,        -4.255636236536e-05, TOL));
assert(isequalRel(s3,         5.589164123999e-05, TOL));
assert(isequalRel(s4,         3.670280290501e-05, TOL));
assert(isequalRel(s5,        -6.781121236965e-02, TOL));
assert(isequalRel(s6,        -7.890007386814e-01, TOL));
assert(isequalRel(s7,         2.264239645916e-01, TOL));
assert(isequalRel(ss1,       -2.585043179178e-03, TOL));
assert(isequalRel(ss2,       -2.649548450829e-04, TOL));
assert(isequalRel(ss3,        3.479799570045e-04, TOL));
assert(isequalRel(ss4,        2.285107306474e-04, TOL));
assert(isequalRel(ss5,       -9.300055233772e-02, TOL));
assert(isequalRel(ss6,        3.226669207231e-01, TOL));
assert(isequalRel(ss7,       -6.984134923665e-01, TOL));
assert(isequalRel(sz1,        1.011433491910e+01, TOL));
assert(isequalRel(sz2,       -1.322346097553e+01, TOL));
assert(isequalRel(sz3,        6.174055799605e+00, TOL));
assert(isequalRel(sz11,       1.436091100595e+00, TOL));
assert(isequalRel(sz12,      -3.377120387296e+00, TOL));
assert(isequalRel(sz13,       9.894345792869e-01, TOL));
assert(isequalRel(sz21,      -7.445807450018e+00, TOL));
assert(isequalRel(sz22,       7.427636064521e+00, TOL));
assert(isequalRel(sz23,      -1.671723221244e+00, TOL));
assert(isequalRel(sz31,       4.048778658683e+00, TOL));
assert(isequalRel(sz32,      -9.407540896517e+00, TOL));
assert(isequalRel(sz33,       2.787486533023e-01, TOL));
assert(isequalRel(xgh2,       2.558144451794e-04, TOL));
assert(isequalRel(xgh3,       7.760342525429e-04, TOL));
assert(isequalRel(xgh4,      -3.626970983073e-05, TOL));
assert(isequalRel(xh2,       -4.442804590880e-05, TOL));
assert(isequalRel(xh3,       -7.585547023917e-04, TOL));
assert(isequalRel(xi2,       -1.445258766608e-04, TOL));
assert(isequalRel(xi3,       -2.241607759555e-04, TOL));
assert(isequalRel(xl2,       -6.443953743437e-04, TOL));
assert(isequalRel(xl3,       -1.634546261908e-03, TOL));
assert(isequalRel(xl4,        1.602895511062e-04, TOL));
assert(isequalRel(nm,         8.582332516240e-03, TOL));
assert(isequalRel(z1,         1.813115954744e+00, TOL));
assert(isequalRel(z2,         5.764684665250e+00, TOL));
assert(isequalRel(z3,         1.643557313837e+01, TOL));
assert(isequalRel(z11,       -1.421821877921e-01, TOL));
assert(isequalRel(z12,        1.698052519386e+00, TOL));
assert(isequalRel(z13,        2.491510678518e+00, TOL));
assert(isequalRel(z21,        8.950346641696e-02, TOL));
assert(isequalRel(z22,       -5.219906429897e-01, TOL));
assert(isequalRel(z23,       -8.822850177431e+00, TOL));
assert(isequalRel(z31,       -2.661737982326e+00, TOL));
assert(isequalRel(z32,        3.484944267628e+00, TOL));
assert(isequalRel(z33,        7.910128348311e+00, TOL));
assert(isequalRel(zmol,       1.755039480870e+00, TOL));
assert(isequalRel(zmos,       2.976061799015e+00, TOL));
# 22674

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.062945752052e+04,  7.258491000000e-01,  5.167015834603e+00,  0.000000000000e+00,  1.230387309486e-01,  3.138517383448e+00,  9.853789469239e-03);
assert(isequalRel(sinim,      1.227285282698e-01, TOL));
assert(isequalRel(cosim,      9.924402794872e-01, TOL));
assert(isequalRel(sinomm,    -8.984249491476e-01, TOL));
assert(isequalRel(cosomm,     4.391271009049e-01, TOL));
assert(isequalRel(snodm,      3.075265294731e-03, TOL));
assert(isequalRel(cnodm,     -9.999952713605e-01, TOL));
assert(isequalRel(day,        3.889095752052e+04, TOL));
assert(isequalRel(e3,         5.883771878310e-04, TOL));
assert(isequalRel(ee2,        1.201802618946e-04, TOL));
assert(isequalRel(em,         7.258491000000e-01, TOL));
assert(isequalRel(emsq,       5.268569159708e-01, TOL));
assert(isequalRel(gam,        8.145348469226e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     6.878539699887e-01, TOL));
assert(isequalRel(se2,       -3.424600980580e-03, TOL));
assert(isequalRel(se3,       -1.945460736508e-03, TOL));
assert(isequalRel(sgh2,       2.807746435654e-03, TOL));
assert(isequalRel(sgh3,      -4.287929901990e-03, TOL));
assert(isequalRel(sgh4,      -6.285500316310e-05, TOL));
assert(isequalRel(sh2,       -1.277477731310e-04, TOL));
assert(isequalRel(sh3,        3.309216641173e-03, TOL));
assert(isequalRel(si2,        7.513453732828e-04, TOL));
assert(isequalRel(si3,       -1.615208443659e-03, TOL));
assert(isequalRel(sl2,       -6.591258953724e-03, TOL));
assert(isequalRel(sl3,        8.653034599493e-03, TOL));
assert(isequalRel(sl4,        2.613596417420e-04, TOL));
assert(isequalRel(s1,        -3.645715464322e-04, TOL));
assert(isequalRel(s2,        -3.538528327605e-05, TOL));
assert(isequalRel(s3,         4.867981516121e-05, TOL));
assert(isequalRel(s4,         3.348460411695e-05, TOL));
assert(isequalRel(s5,         1.335551822618e-01, TOL));
assert(isequalRel(s6,        -1.648239736078e-01, TOL));
assert(isequalRel(s7,        -8.069433744748e-01, TOL));
assert(isequalRel(ss1,       -2.269813307285e-03, TOL));
assert(isequalRel(ss2,       -2.203078864713e-04, TOL));
assert(isequalRel(ss3,        3.030793086581e-04, TOL));
assert(isequalRel(ss4,        2.084743056819e-04, TOL));
assert(isequalRel(ss5,        1.012064733473e-01, TOL));
assert(isequalRel(ss6,        7.543794393988e-01, TOL));
assert(isequalRel(ss7,        4.285508262429e-01, TOL));
assert(isequalRel(sz1,        1.743998961512e+01, TOL));
assert(isequalRel(sz2,        1.087381877520e+01, TOL));
assert(isequalRel(sz3,        3.164791090678e+00, TOL));
assert(isequalRel(sz11,      -3.199300228592e+00, TOL));
assert(isequalRel(sz12,      -1.705216697680e+00, TOL));
assert(isequalRel(sz13,       4.664978268716e-01, TOL));
assert(isequalRel(sz21,      -7.168375325603e+00, TOL));
assert(isequalRel(sz22,      -2.899300955068e-01, TOL));
assert(isequalRel(sz23,       3.420608511894e-01, TOL));
assert(isequalRel(sz31,       8.465783464086e+00, TOL));
assert(isequalRel(sz32,       6.734034744640e+00, TOL));
assert(isequalRel(sz33,      -1.818289405144e+00, TOL));
assert(isequalRel(xgh2,      -7.580873897080e-04, TOL));
assert(isequalRel(xgh3,       8.944532635768e-05, TOL));
assert(isequalRel(xgh4,      -3.308948578837e-05, TOL));
assert(isequalRel(xh2,        4.592174078680e-04, TOL));
assert(isequalRel(xh3,       -3.581021323765e-04, TOL));
assert(isequalRel(xi2,       -3.094906804917e-04, TOL));
assert(isequalRel(xi3,        8.206020674696e-05, TOL));
assert(isequalRel(xl2,        1.595875573261e-03, TOL));
assert(isequalRel(xl3,       -2.025915791658e-05, TOL));
assert(isequalRel(xl4,        1.375905769766e-04, TOL));
assert(isequalRel(nm,         9.853789469239e-03, TOL));
assert(isequalRel(z1,         9.381951731311e+00, TOL));
assert(isequalRel(z2,        -1.639155333660e+01, TOL));
assert(isequalRel(z3,         9.590037545210e+00, TOL));
assert(isequalRel(z11,       -8.992776337465e-01, TOL));
assert(isequalRel(z12,        4.373155332364e+00, TOL));
assert(isequalRel(z13,       -2.058802147183e+00, TOL));
assert(isequalRel(z21,       -1.165590178778e+00, TOL));
assert(isequalRel(z22,        6.488819155206e+00, TOL));
assert(isequalRel(z23,       -6.225633496546e+00, TOL));
assert(isequalRel(z31,        2.282389782041e+00, TOL));
assert(isequalRel(z32,       -1.131993956178e+01, TOL));
assert(isequalRel(z33,        3.618008474818e+00, TOL));
assert(isequalRel(zmol,       1.503851507578e+00, TOL));
assert(isequalRel(zmos,       2.957112607744e+00, TOL));
# 23177

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 1.637649999999e+04,  9.728298000000e-01,  5.312084111370e-01,  0.000000000000e+00,  5.017647066558e-01,  4.139920985731e-02,  3.189177226396e-04);
assert(isequalRel(sinim,      4.809734670776e-01, TOL));
assert(isequalRel(cosim,      8.767351504117e-01, TOL));
assert(isequalRel(sinomm,     5.065755975198e-01, TOL));
assert(isequalRel(cosomm,     8.621955485836e-01, TOL));
assert(isequalRel(snodm,      4.138738522378e-02, TOL));
assert(isequalRel(cnodm,      9.991431750977e-01, TOL));
assert(isequalRel(day,        3.463799999999e+04, TOL));
assert(isequalRel(e3,         6.618130467595e-03, TOL));
assert(isequalRel(ee2,       -7.503198877723e-03, TOL));
assert(isequalRel(em,         9.728298000000e-01, TOL));
assert(isequalRel(emsq,       9.463978197680e-01, TOL));
assert(isequalRel(gam,        7.318417018398e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     2.315214465918e-01, TOL));
assert(isequalRel(se2,        4.629809809051e-02, TOL));
assert(isequalRel(se3,        4.271626851497e-02, TOL));
assert(isequalRel(sgh2,      -4.391480163694e-02, TOL));
assert(isequalRel(sgh3,       4.776472532865e-02, TOL));
assert(isequalRel(sgh4,      -6.536713592881e-04, TOL));
assert(isequalRel(sh2,        5.087055669958e-02, TOL));
assert(isequalRel(sh3,        2.194123446194e-02, TOL));
assert(isequalRel(si2,        8.750068533754e-02, TOL));
assert(isequalRel(si3,        3.511647715856e-02, TOL));
assert(isequalRel(sl2,        3.692252174204e-01, TOL));
assert(isequalRel(sl3,       -4.025541103842e-01, TOL));
assert(isequalRel(sl4,        9.259903790801e-03, TOL));
assert(isequalRel(s1,        -5.081511320759e-03, TOL));
assert(isequalRel(s2,        -3.248271505978e-03, TOL));
assert(isequalRel(s3,         1.504089035974e-03, TOL));
assert(isequalRel(s4,         3.482288694116e-04, TOL));
assert(isequalRel(s5,        -2.328528826856e-03, TOL));
assert(isequalRel(s6,         7.382841839859e-01, TOL));
assert(isequalRel(s7,        -6.511970602682e-01, TOL));
assert(isequalRel(ss1,       -3.163736207572e-02, TOL));
assert(isequalRel(ss2,       -2.022365695321e-02, TOL));
assert(isequalRel(ss3,        9.364420626367e-03, TOL));
assert(isequalRel(ss4,        2.168064209911e-03, TOL));
assert(isequalRel(ss5,       -2.895833784881e-03, TOL));
assert(isequalRel(ss6,       -7.316997223047e-01, TOL));
assert(isequalRel(ss7,       -6.750921333570e-01, TOL));
assert(isequalRel(sz1,        3.995477449554e+00, TOL));
assert(isequalRel(sz2,       -1.971425847643e+01, TOL));
assert(isequalRel(sz3,        2.548928504566e+01, TOL));
assert(isequalRel(sz11,       8.310226113488e-01, TOL));
assert(isequalRel(sz12,      -2.163324999528e+00, TOL));
assert(isequalRel(sz13,      -3.718033631310e-02, TOL));
assert(isequalRel(sz21,      -5.208379182207e-01, TOL));
assert(isequalRel(sz22,       1.257699258281e+00, TOL));
assert(isequalRel(sz23,       2.162664475876e-02, TOL));
assert(isequalRel(sz31,      -1.002513894286e+00, TOL));
assert(isequalRel(sz32,      -1.012765245517e+01, TOL));
assert(isequalRel(sz33,       1.001300979507e+01, TOL));
assert(isequalRel(xgh2,      -6.878292929739e-03, TOL));
assert(isequalRel(xgh3,      -7.775516402908e-03, TOL));
assert(isequalRel(xgh4,      -3.441197687525e-04, TOL));
assert(isequalRel(xh2,       -1.179576494215e-02, TOL));
assert(isequalRel(xh3,        1.169037463880e-02, TOL));
assert(isequalRel(xi2,       -1.956589871380e-02, TOL));
assert(isequalRel(xi3,        2.039566495961e-02, TOL));
assert(isequalRel(xl2,        5.825328423320e-02, TOL));
assert(isequalRel(xl3,        6.572632496892e-02, TOL));
assert(isequalRel(xl4,        4.874798177836e-03, TOL));
assert(isequalRel(nm,         3.189177226396e-04, TOL));
assert(isequalRel(z1,         2.567833618728e+01, TOL));
assert(isequalRel(z2,        -1.936497203288e+01, TOL));
assert(isequalRel(z3,         3.829122677668e+00, TOL));
assert(isequalRel(z11,        1.717602413072e+00, TOL));
assert(isequalRel(z12,        3.011740040478e+00, TOL));
assert(isequalRel(z13,       -1.421861902345e+00, TOL));
assert(isequalRel(z21,       -1.018792332212e+00, TOL));
assert(isequalRel(z22,       -1.815698737072e+00, TOL));
assert(isequalRel(z23,        7.806838841821e-01, TOL));
assert(isequalRel(z31,        1.012719038286e+01, TOL));
assert(isequalRel(z32,       -9.876109555996e+00, TOL));
assert(isequalRel(z33,       -1.037186103277e+00, TOL));
assert(isequalRel(zmol,       5.607868196210e+00, TOL));
assert(isequalRel(zmos,       5.196058843771e+00, TOL));
# 23333

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.062576535463e+04,  5.782022000000e-01,  4.789944431026e+00,  0.000000000000e+00,  1.209984410530e-01,  4.972443038932e-03,  1.952919673236e-02);
assert(isequalRel(sinim,      1.207034083544e-01, TOL));
assert(isequalRel(cosim,      9.926886154337e-01, TOL));
assert(isequalRel(sinomm,    -9.969940831688e-01, TOL));
assert(isequalRel(cosomm,     7.747772664665e-02, TOL));
assert(isequalRel(snodm,      4.972422548191e-03, TOL));
assert(isequalRel(cnodm,      9.999876374306e-01, TOL));
assert(isequalRel(day,        3.888726535463e+04, TOL));
assert(isequalRel(e3,         1.917688589693e-04, TOL));
assert(isequalRel(ee2,        2.600403830731e-04, TOL));
assert(isequalRel(em,         5.782022000000e-01, TOL));
assert(isequalRel(emsq,       3.343177840848e-01, TOL));
assert(isequalRel(gam,        8.144630576305e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     8.158935077050e-01, TOL));
assert(isequalRel(se2,       -2.021959812118e-03, TOL));
assert(isequalRel(se3,        4.664465684109e-04, TOL));
assert(isequalRel(sgh2,      -7.734435306744e-04, TOL));
assert(isequalRel(sgh3,      -3.415977655410e-03, TOL));
assert(isequalRel(sgh4,      -3.761802411036e-05, TOL));
assert(isequalRel(sh2,       -2.320545150812e-04, TOL));
assert(isequalRel(sh3,       -6.756286295110e-04, TOL));
assert(isequalRel(si2,       -1.848221304876e-04, TOL));
assert(isequalRel(si3,        1.185722011180e-04, TOL));
assert(isequalRel(sl2,        1.207731977398e-03, TOL));
assert(isequalRel(sl3,        5.449750974362e-03, TOL));
assert(isequalRel(sl4,        1.229961546518e-04, TOL));
assert(isequalRel(s1,        -1.738090138239e-04, TOL));
assert(isequalRel(s2,        -1.505235132354e-05, TOL));
assert(isequalRel(s3,         2.456223144115e-05, TOL));
assert(isequalRel(s4,         2.004016516758e-05, TOL));
assert(isequalRel(s5,         1.141559521691e-02, TOL));
assert(isequalRel(s6,        -7.480635709048e-01, TOL));
assert(isequalRel(s7,        -5.516654595475e-01, TOL));
assert(isequalRel(ss1,       -1.082130562202e-03, TOL));
assert(isequalRel(ss2,       -9.371556193695e-05, TOL));
assert(isequalRel(ss3,        1.529238371106e-04, TOL));
assert(isequalRel(ss4,        1.247695658719e-04, TOL));
assert(isequalRel(ss5,        6.794274893840e-03, TOL));
assert(isequalRel(ss6,        9.342494717103e-01, TOL));
assert(isequalRel(ss7,       -2.155223152841e-01, TOL));
assert(isequalRel(sz1,        2.003045339565e+01, TOL));
assert(isequalRel(sz2,       -3.948802228017e+00, TOL));
assert(isequalRel(sz3,        2.211939691926e+00, TOL));
assert(isequalRel(sz11,       4.180135541233e-01, TOL));
assert(isequalRel(sz12,       9.860802553364e-01, TOL));
assert(isequalRel(sz13,      -2.146039037850e-01, TOL));
assert(isequalRel(sz21,       3.703990857776e+00, TOL));
assert(isequalRel(sz22,      -1.238078875509e+00, TOL));
assert(isequalRel(sz23,       9.931402744621e-02, TOL));
assert(isequalRel(sz31,       1.086424461544e+01, TOL));
assert(isequalRel(sz32,      -3.099487945117e+00, TOL));
assert(isequalRel(sz33,      -2.824901577941e+00, TOL));
assert(isequalRel(xgh2,      -3.210545596328e-04, TOL));
assert(isequalRel(xgh3,       4.292321013506e-04, TOL));
assert(isequalRel(xgh4,      -1.980369121860e-05, TOL));
assert(isequalRel(xh2,       -7.343991154683e-05, TOL));
assert(isequalRel(xh3,        1.243873320172e-04, TOL));
assert(isequalRel(xi2,        4.375268409065e-05, TOL));
assert(isequalRel(xi3,        1.339081864290e-05, TOL));
assert(isequalRel(xl2,        5.069978526244e-04, TOL));
assert(isequalRel(xl3,       -6.661160092554e-04, TOL));
assert(isequalRel(xl4,        6.475028727329e-05, TOL));
assert(isequalRel(nm,         1.952919673236e-02, TOL));
assert(isequalRel(z1,         3.735227503813e+00, TOL));
assert(isequalRel(z2,        -1.032067981769e+01, TOL));
assert(isequalRel(z3,         1.729498918205e+01, TOL));
assert(isequalRel(z11,        3.506359240961e-01, TOL));
assert(isequalRel(z12,       -1.453350481603e+00, TOL));
assert(isequalRel(z13,       -9.417227746221e-02, TOL));
assert(isequalRel(z21,        3.278561983564e-01, TOL));
assert(isequalRel(z22,       -2.439483040499e+00, TOL));
assert(isequalRel(z23,        4.459680168698e+00, TOL));
assert(isequalRel(z31,       -1.664599028406e+00, TOL));
assert(isequalRel(z32,       -8.010277284346e+00, TOL));
assert(isequalRel(z33,        9.044696472935e+00, TOL));
assert(isequalRel(zmol,       6.619375088630e-01, TOL));
assert(isequalRel(zmos,       2.893600055028e+00, TOL));
# 23599

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063104061740e+04,  2.664000000000e-03,  5.429679160382e+00,  0.000000000000e+00,  6.725800805485e-02,  1.396474586435e+00,  4.397108759492e-03);
assert(isequalRel(sinim,      6.720731102433e-02, TOL));
assert(isequalRel(cosim,      9.977390326858e-01, TOL));
assert(isequalRel(sinomm,    -7.535897804281e-01, TOL));
assert(isequalRel(cosomm,     6.573449952911e-01, TOL));
assert(isequalRel(snodm,      9.848444029137e-01, TOL));
assert(isequalRel(cnodm,      1.734401973290e-01, TOL));
assert(isequalRel(day,        3.889254061740e+04, TOL));
assert(isequalRel(e3,        -7.726902954388e-06, TOL));
assert(isequalRel(ee2,       -5.176143424006e-07, TOL));
assert(isequalRel(em,         2.664000000000e-03, TOL));
assert(isequalRel(emsq,       7.096896000000e-06, TOL));
assert(isequalRel(gam,        8.145656281517e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.999964515457e-01, TOL));
assert(isequalRel(se2,        3.935674677679e-05, TOL));
assert(isequalRel(se3,        3.101303936462e-05, TOL));
assert(isequalRel(sgh2,      -1.095943198289e-02, TOL));
assert(isequalRel(sgh3,       1.543789357065e-02, TOL));
assert(isequalRel(sgh4,      -2.047755658748e-04, TOL));
assert(isequalRel(sh2,        1.170723269672e-03, TOL));
assert(isequalRel(sh3,       -1.086189670839e-03, TOL));
assert(isequalRel(si2,       -1.002689875952e-03, TOL));
assert(isequalRel(si3,       -1.074034874057e-03, TOL));
assert(isequalRel(sl2,        1.012379841762e-02, TOL));
assert(isequalRel(sl3,       -1.636988036209e-02, TOL));
assert(isequalRel(sl4,        4.778128024756e-04, TOL));
assert(isequalRel(s1,        -4.359221435156e-06, TOL));
assert(isequalRel(s2,        -5.454519985382e-05, TOL));
assert(isequalRel(s3,         1.090900126053e-04, TOL));
assert(isequalRel(s4,         1.090896255044e-04, TOL));
assert(isequalRel(s5,        -1.083047439793e-01, TOL));
assert(isequalRel(s6,         5.937004463986e-02, TOL));
assert(isequalRel(s7,         8.862709854645e-01, TOL));
assert(isequalRel(ss1,       -2.714040335773e-05, TOL));
assert(isequalRel(ss2,       -3.395970466932e-04, TOL));
assert(isequalRel(ss3,        6.791916832972e-04, TOL));
assert(isequalRel(ss4,        6.791892732165e-04, TOL));
assert(isequalRel(ss5,       -7.564404853169e-02, TOL));
assert(isequalRel(ss6,       -7.250582509412e-01, TOL));
assert(isequalRel(ss7,       -5.713444814331e-01, TOL));
assert(isequalRel(sz1,        3.767328239899e+00, TOL));
assert(isequalRel(sz2,       -7.452828609794e+00, TOL));
assert(isequalRel(sz3,        1.581833001499e+01, TOL));
assert(isequalRel(sz11,      -1.872126641261e+00, TOL));
assert(isequalRel(sz12,       1.476293574569e+00, TOL));
assert(isequalRel(sz13,      -2.907894586864e-01, TOL));
assert(isequalRel(sz21,       8.194386720961e-01, TOL));
assert(isequalRel(sz22,       1.723694715652e+00, TOL));
assert(isequalRel(sz23,      -7.797944210889e-01, TOL));
assert(isequalRel(sz31,      -1.428938019349e+00, TOL));
assert(isequalRel(sz32,      -8.068024934334e+00, TOL));
assert(isequalRel(sz33,       9.936004110508e+00, TOL));
assert(isequalRel(xgh2,       2.915576106025e-03, TOL));
assert(isequalRel(xgh3,      -4.189146928255e-04, TOL));
assert(isequalRel(xgh4,      -1.078023679235e-04, TOL));
assert(isequalRel(xh2,       -3.065019513911e-04, TOL));
assert(isequalRel(xh3,       -3.781667774154e-05, TOL));
assert(isequalRel(xi2,       -2.998211222471e-05, TOL));
assert(isequalRel(xi3,        2.707830507804e-04, TOL));
assert(isequalRel(xl2,       -2.963865666279e-03, TOL));
assert(isequalRel(xl3,        7.064676449674e-04, TOL));
assert(isequalRel(xl4,        2.515405161303e-04, TOL));
assert(isequalRel(nm,         4.397108759492e-03, TOL));
assert(isequalRel(z1,         1.114414424666e+01, TOL));
assert(isequalRel(z2,         1.358449593824e+01, TOL));
assert(isequalRel(z3,         7.906140931350e+00, TOL));
assert(isequalRel(z11,       -5.626930686788e-03, TOL));
assert(isequalRel(z12,        2.748373120372e-01, TOL));
assert(isequalRel(z13,       -2.487816486377e+00, TOL));
assert(isequalRel(z21,        2.349040036708e-01, TOL));
assert(isequalRel(z22,       -2.809614340149e+00, TOL));
assert(isequalRel(z23,       -1.117504942767e-01, TOL));
assert(isequalRel(z31,        5.153323530243e+00, TOL));
assert(isequalRel(z32,        1.336321438699e+01, TOL));
assert(isequalRel(z33,        3.233275263102e+00, TOL));
assert(isequalRel(zmol,       1.864840548802e+00, TOL));
assert(isequalRel(zmos,       2.984345003862e+00, TOL));
# 24208

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 1.976268057285e+04,  1.765000000000e-04,  2.710391608592e-01,  0.000000000000e+00,  6.981317007977e-06,  4.255350081140e+00,  4.374997775854e-03);
assert(isequalRel(sinim,      6.981317007921e-06, TOL));
assert(isequalRel(cosim,      9.999999999756e-01, TOL));
assert(isequalRel(sinomm,     2.677328054857e-01, TOL));
assert(isequalRel(cosomm,     9.634931991803e-01, TOL));
assert(isequalRel(snodm,     -8.973631423355e-01, TOL));
assert(isequalRel(cnodm,     -4.412928628221e-01, TOL));
assert(isequalRel(day,        3.802418057285e+04, TOL));
assert(isequalRel(e3,        -1.443253711966e-07, TOL));
assert(isequalRel(ee2,       -4.967861523155e-07, TOL));
assert(isequalRel(em,         1.765000000000e-04, TOL));
assert(isequalRel(emsq,       3.115225000000e-08, TOL));
assert(isequalRel(gam,        7.976815133207e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.999999844239e-01, TOL));
assert(isequalRel(se2,       -2.393510838524e-06, TOL));
assert(isequalRel(se3,        2.297499314735e-06, TOL));
assert(isequalRel(sgh2,      -1.264715658450e-02, TOL));
assert(isequalRel(sgh3,      -1.273189516222e-02, TOL));
assert(isequalRel(sgh4,      -2.058112167495e-04, TOL));
assert(isequalRel(sh2,       -1.099705176855e-03, TOL));
assert(isequalRel(sh3,        1.167960133285e-03, TOL));
assert(isequalRel(si2,        1.176752281702e-03, TOL));
assert(isequalRel(si3,        9.654718969481e-04, TOL));
assert(isequalRel(sl2,        1.215221622343e-02, TOL));
assert(isequalRel(sl3,        1.153344263874e-02, TOL));
assert(isequalRel(sl4,        4.802261863070e-04, TOL));
assert(isequalRel(s1,        -2.902754621049e-07, TOL));
assert(isequalRel(s2,        -5.482067443771e-05, TOL));
assert(isequalRel(s3,         1.096413471676e-04, TOL));
assert(isequalRel(s4,         1.096413454598e-04, TOL));
assert(isequalRel(s5,        -6.378753298339e-02, TOL));
assert(isequalRel(s6,         8.557150313586e-01, TOL));
assert(isequalRel(s7,         2.486007087027e-01, TOL));
assert(isequalRel(ss1,       -1.807247749069e-06, TOL));
assert(isequalRel(ss2,       -3.413121445456e-04, TOL));
assert(isequalRel(ss3,        6.826242784585e-04, TOL));
assert(isequalRel(ss4,        6.826242678259e-04, TOL));
assert(isequalRel(ss5,       -2.876970046754e-02, TOL));
assert(isequalRel(ss6,        6.621977644616e-01, TOL));
assert(isequalRel(ss7,       -6.356348530297e-01, TOL));
assert(isequalRel(sz1,        1.333992996164e+01, TOL));
assert(isequalRel(sz2,       -8.901101679884e+00, TOL));
assert(isequalRel(sz3,        4.892059732956e+00, TOL));
assert(isequalRel(sz11,       1.689817110256e+00, TOL));
assert(isequalRel(sz12,      -1.723865236716e+00, TOL));
assert(isequalRel(sz13,       2.754638380722e-01, TOL));
assert(isequalRel(sz21,      -1.338739623226e+00, TOL));
assert(isequalRel(sz22,      -1.610996260211e+00, TOL));
assert(isequalRel(sz23,       3.722456902921e-01, TOL));
assert(isequalRel(sz31,       8.253714037282e+00, TOL));
assert(isequalRel(sz32,      -9.263629481548e+00, TOL));
assert(isequalRel(sz33,      -1.071983687153e+00, TOL));
assert(isequalRel(xgh2,       6.708089970693e-04, TOL));
assert(isequalRel(xgh3,      -2.691818508104e-03, TOL));
assert(isequalRel(xgh4,      -1.083475775834e-04, TOL));
assert(isequalRel(xh2,       -2.688548161140e-04, TOL));
assert(isequalRel(xh3,       -1.120931668890e-04, TOL));
assert(isequalRel(xi2,       -7.859155231505e-05, TOL));
assert(isequalRel(xi3,        2.677016040710e-04, TOL));
assert(isequalRel(xl2,       -4.478395208697e-04, TOL));
assert(isequalRel(xl3,        2.528608623316e-03, TOL));
assert(isequalRel(xl4,        2.528110216744e-04, TOL));
assert(isequalRel(nm,         4.374997775854e-03, TOL));
assert(isequalRel(z1,         1.453742738580e+01, TOL));
assert(isequalRel(z2,         2.042293041990e+00, TOL));
assert(isequalRel(z3,         3.006154336733e+00, TOL));
assert(isequalRel(z11,        2.231085072369e+00, TOL));
assert(isequalRel(z12,        7.168057773930e-01, TOL));
assert(isequalRel(z13,       -2.105266627735e-01, TOL));
assert(isequalRel(z21,       -1.762284682913e-01, TOL));
assert(isequalRel(z22,       -2.452129774685e+00, TOL));
assert(isequalRel(z23,       -1.198590634013e+00, TOL));
assert(isequalRel(z31,        9.539627269283e+00, TOL));
assert(isequalRel(z32,        3.059106007209e+00, TOL));
assert(isequalRel(z33,       -2.735935826075e+00, TOL));
assert(isequalRel(zmol,       4.917119876491e+00, TOL));
assert(isequalRel(zmos,       6.132061041587e-01, TOL));
# 25954

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.056074503247e+04,  3.319000000000e-04,  1.504114277393e+00,  0.000000000000e+00,  2.862339973271e-04,  4.651962191022e+00,  4.375109379983e-03);
assert(isequalRel(sinim,      2.862339934185e-04, TOL));
assert(isequalRel(cosim,      9.999999590350e-01, TOL));
assert(isequalRel(sinomm,     9.977775758269e-01, TOL));
assert(isequalRel(cosomm,     6.663264347934e-02, TOL));
assert(isequalRel(snodm,     -9.981748570252e-01, TOL));
assert(isequalRel(cnodm,     -6.039002237745e-02, TOL));
assert(isequalRel(day,        3.882224503247e+04, TOL));
assert(isequalRel(e3,        -4.297357109584e-07, TOL));
assert(isequalRel(ee2,       -8.575863014313e-07, TOL));
assert(isequalRel(em,         3.319000000000e-04, TOL));
assert(isequalRel(emsq,       1.101576100000e-07, TOL));
assert(isequalRel(gam,        8.131988232929e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.999999449212e-01, TOL));
assert(isequalRel(se2,        4.977710503291e-06, TOL));
assert(isequalRel(se3,       -3.758122880832e-06, TOL));
assert(isequalRel(sgh2,       1.170238813200e-02, TOL));
assert(isequalRel(sgh3,       1.596617407202e-02, TOL));
assert(isequalRel(sgh4,      -2.058059586065e-04, TOL));
assert(isequalRel(sh2,       -1.469489949578e-03, TOL));
assert(isequalRel(sh3,        7.031457064751e-04, TOL));
assert(isequalRel(si2,        6.596584265507e-04, TOL));
assert(isequalRel(si3,        1.342180142943e-03, TOL));
assert(isequalRel(sl2,       -1.219566699304e-02, TOL));
assert(isequalRel(sl3,       -1.716537238492e-02, TOL));
assert(isequalRel(sl4,        4.802139525359e-04, TOL));
assert(isequalRel(s1,        -5.458354928034e-07, TOL));
assert(isequalRel(s2,        -5.481927818934e-05, TOL));
assert(isequalRel(s3,         1.096385503399e-04, TOL));
assert(isequalRel(s4,         1.096385443012e-04, TOL));
assert(isequalRel(s5,         3.134894679716e-02, TOL));
assert(isequalRel(s6,         7.855721300082e-01, TOL));
assert(isequalRel(s7,         3.936494755510e-01, TOL));
assert(isequalRel(ss1,       -3.398358092612e-06, TOL));
assert(isequalRel(ss2,       -3.413034515383e-04, TOL));
assert(isequalRel(ss3,        6.826068654794e-04, TOL));
assert(isequalRel(ss4,        6.826068278822e-04, TOL));
assert(isequalRel(ss5,        2.000630099778e-02, TOL));
assert(isequalRel(ss6,       -7.323699221269e-01, TOL));
assert(isequalRel(ss7,        5.529321481752e-01, TOL));
assert(isequalRel(sz1,        3.956575789077e+00, TOL));
assert(isequalRel(sz2,        8.933155824965e+00, TOL));
assert(isequalRel(sz3,        1.652997143817e+01, TOL));
assert(isequalRel(sz11,       2.076153554075e+00, TOL));
assert(isequalRel(sz12,      -9.663811244475e-01, TOL));
assert(isequalRel(sz13,       1.098972257350e-01, TOL));
assert(isequalRel(sz21,      -5.818957556802e-01, TOL));
assert(isequalRel(sz22,      -2.152761630383e+00, TOL));
assert(isequalRel(sz23,       4.481930162117e-01, TOL));
assert(isequalRel(sz31,      -1.129325285006e+00, TOL));
assert(isequalRel(sz32,       8.571836417392e+00, TOL));
assert(isequalRel(sz33,       1.056567498445e+01, TOL));
assert(isequalRel(xgh2,       1.468610866371e-03, TOL));
assert(isequalRel(xgh3,      -2.762771903365e-03, TOL));
assert(isequalRel(xgh4,      -1.083448094784e-04, TOL));
assert(isequalRel(xh2,        2.443977229280e-04, TOL));
assert(isequalRel(xh3,        1.980068154638e-04, TOL));
assert(isequalRel(xi2,        1.700595365594e-04, TOL));
assert(isequalRel(xi3,       -2.181240526799e-04, TOL));
assert(isequalRel(xl2,       -1.672610170679e-03, TOL));
assert(isequalRel(xl3,        2.984308463316e-03, TOL));
assert(isequalRel(xl4,        2.528045813088e-04, TOL));
assert(isequalRel(nm,         4.375109379983e-03, TOL));
assert(isequalRel(z1,         1.692870278037e+01, TOL));
assert(isequalRel(z2,         7.627837861288e+00, TOL));
assert(isequalRel(z3,         3.318943922456e+00, TOL));
assert(isequalRel(z11,        2.623614504262e-01, TOL));
assert(isequalRel(z12,       -1.551092445727e+00, TOL));
assert(isequalRel(z13,        2.251844529048e+00, TOL));
assert(isequalRel(z21,       -9.937247788382e-01, TOL));
assert(isequalRel(z22,        2.229122044291e+00, TOL));
assert(isequalRel(z23,        8.122714145074e-01, TOL));
assert(isequalRel(z31,        1.111024835979e+01, TOL));
assert(isequalRel(z32,        6.697511699614e+00, TOL));
assert(isequalRel(z33,       -1.489207064283e+00, TOL));
assert(isequalRel(zmol,       4.685095846573e+00, TOL));
assert(isequalRel(zmos,       1.775121968701e+00, TOL));
# 26900

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.062885818871e+04,  5.602877000000e-01,  2.159817024075e+00,  0.000000000000e+00,  1.195051373450e+00,  4.121251198722e+00,  8.973959238486e-03);
assert(isequalRel(sinim,      9.302345077967e-01, TOL));
assert(isequalRel(cosim,      3.669656121548e-01, TOL));
assert(isequalRel(sinomm,     8.314851264260e-01, TOL));
assert(isequalRel(cosomm,    -5.555470137912e-01, TOL));
assert(isequalRel(snodm,     -8.303071240211e-01, TOL));
assert(isequalRel(cnodm,     -5.573060916586e-01, TOL));
assert(isequalRel(day,        3.889035818871e+04, TOL));
assert(isequalRel(e3,        -2.267021997425e-04, TOL));
assert(isequalRel(ee2,       -2.551224465045e-04, TOL));
assert(isequalRel(em,         5.602877000000e-01, TOL));
assert(isequalRel(emsq,       3.139223067713e-01, TOL));
assert(isequalRel(gam,        8.145231937067e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     8.282980702795e-01, TOL));
assert(isequalRel(se2,        2.254910627255e-03, TOL));
assert(isequalRel(se3,       -2.280386619192e-04, TOL));
assert(isequalRel(sgh2,      -3.389917058225e-03, TOL));
assert(isequalRel(sgh3,       1.654422300963e-03, TOL));
assert(isequalRel(sgh4,      -8.310926481500e-05, TOL));
assert(isequalRel(sh2,       -9.721139826925e-04, TOL));
assert(isequalRel(sh3,       -2.919237403379e-03, TOL));
assert(isequalRel(si2,        6.537866741737e-04, TOL));
assert(isequalRel(si3,        3.149325116495e-03, TOL));
assert(isequalRel(sl2,        9.242202107515e-03, TOL));
assert(isequalRel(sl3,       -3.312631236734e-03, TOL));
assert(isequalRel(sl4,        2.656187161612e-04, TOL));
assert(isequalRel(s1,        -3.720978016674e-04, TOL));
assert(isequalRel(s2,        -3.226647047178e-05, TOL));
assert(isequalRel(s3,         5.345251045300e-05, TOL));
assert(isequalRel(s4,         4.427461125982e-05, TOL));
assert(isequalRel(s5,         4.525325835392e-01, TOL));
assert(isequalRel(s6,         3.428163850489e-01, TOL));
assert(isequalRel(s7,         3.046271688877e-01, TOL));
assert(isequalRel(ss1,       -2.316671583676e-03, TOL));
assert(isequalRel(ss2,       -2.008902361490e-04, TOL));
assert(isequalRel(ss3,        3.327939898804e-04, TOL));
assert(isequalRel(ss4,        2.756526196186e-04, TOL));
assert(isequalRel(ss5,        4.714471153965e-01, TOL));
assert(isequalRel(ss6,       -4.866703254669e-01, TOL));
assert(isequalRel(ss7,        4.921687293228e-02, TOL));
assert(isequalRel(sz1,        4.938361689104e+00, TOL));
assert(isequalRel(sz2,       -1.388577075992e+01, TOL));
assert(isequalRel(sz3,        9.915361480964e+00, TOL));
assert(isequalRel(sz11,       3.805314774695e+00, TOL));
assert(isequalRel(sz12,      -1.627223618994e+00, TOL));
assert(isequalRel(sz13,      -4.033107780993e+00, TOL));
assert(isequalRel(sz21,       3.078769405047e+00, TOL));
assert(isequalRel(sz22,      -2.419515257007e+00, TOL));
assert(isequalRel(sz23,      -4.186982926525e+00, TOL));
assert(isequalRel(sz31,       1.829903197356e+00, TOL));
assert(isequalRel(sz32,      -6.148893239098e+00, TOL));
assert(isequalRel(sz33,       4.830822077162e+00, TOL));
assert(isequalRel(xgh2,       5.870668970928e-04, TOL));
assert(isequalRel(xgh3,       3.411079917117e-04, TOL));
assert(isequalRel(xgh4,      -4.375217084695e-05, TOL));
assert(isequalRel(xh2,       -2.939157970135e-04, TOL));
assert(isequalRel(xh3,        4.419605173894e-04, TOL));
assert(isequalRel(xi2,        3.177266725877e-04, TOL));
assert(isequalRel(xi3,       -4.193605290405e-04, TOL));
assert(isequalRel(xl2,       -1.435489158349e-03, TOL));
assert(isequalRel(xl3,       -9.317921317489e-04, TOL));
assert(isequalRel(xl4,        1.398327307491e-04, TOL));
assert(isequalRel(nm,         8.973959238486e-03, TOL));
assert(isequalRel(z1,         3.661706391172e+00, TOL));
assert(isequalRel(z2,         1.342770569786e+01, TOL));
assert(isequalRel(z3,         1.237778093895e+01, TOL));
assert(isequalRel(z11,       -3.293349160083e+00, TOL));
assert(isequalRel(z12,       -4.923480441805e+00, TOL));
assert(isequalRel(z13,        3.205045658268e+00, TOL));
assert(isequalRel(z21,       -3.721535433952e+00, TOL));
assert(isequalRel(z22,       -4.554508018945e+00, TOL));
assert(isequalRel(z23,        3.127067944841e+00, TOL));
assert(isequalRel(z31,        1.881696181512e+00, TOL));
assert(isequalRel(z32,        6.629836834113e+00, TOL));
assert(isequalRel(z33,        5.733881237525e+00, TOL));
assert(isequalRel(zmol,       1.367187593900e+00, TOL));
assert(isequalRel(zmos,       2.946802915738e+00, TOL));
# 26975
# 28057

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.062957071136e+04,  4.850600000000e-03,  4.647183479530e+00,  0.000000000000e+00,  9.552152089580e-01,  5.669000452744e+00,  8.751201528747e-03);
assert(isequalRel(sinim,      8.164380281199e-01, TOL));
assert(isequalRel(cosim,      5.774330664585e-01, TOL));
assert(isequalRel(sinomm,    -9.978748744491e-01, TOL));
assert(isequalRel(cosomm,    -6.515930434859e-02, TOL));
assert(isequalRel(snodm,     -5.762925414229e-01, TOL));
assert(isequalRel(cnodm,      8.172434806716e-01, TOL));
assert(isequalRel(day,        3.889107071136e+04, TOL));
assert(isequalRel(e3,        -3.876849228949e-06, TOL));
assert(isequalRel(ee2,        5.421891510864e-06, TOL));
assert(isequalRel(em,         4.850600000000e-03, TOL));
assert(isequalRel(emsq,       2.352832036000e-05, TOL));
assert(isequalRel(gam,        8.145370477691e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.999882357706e-01, TOL));
assert(isequalRel(se2,       -2.399586065802e-06, TOL));
assert(isequalRel(se3,        3.979795711446e-05, TOL));
assert(isequalRel(sgh2,      -7.340466124056e-03, TOL));
assert(isequalRel(sgh3,      -9.267102539452e-04, TOL));
assert(isequalRel(sgh4,      -1.028902184234e-04, TOL));
assert(isequalRel(sh2,        1.019818515817e-03, TOL));
assert(isequalRel(sh3,       -1.260734846663e-04, TOL));
assert(isequalRel(si2,       -3.379233009896e-04, TOL));
assert(isequalRel(si3,       -1.160185387548e-03, TOL));
assert(isequalRel(sl2,        6.096109975713e-03, TOL));
assert(isequalRel(sl3,        1.773703432654e-03, TOL));
assert(isequalRel(sl4,        2.400824215399e-04, TOL));
assert(isequalRel(s1,        -3.988100801283e-06, TOL));
assert(isequalRel(s2,        -2.740688187581e-05, TOL));
assert(isequalRel(s3,         5.481311890993e-05, TOL));
assert(isequalRel(s4,         5.481247407583e-05, TOL));
assert(isequalRel(s5,         1.233438061238e-01, TOL));
assert(isequalRel(s6,        -6.797585844770e-01, TOL));
assert(isequalRel(s7,         4.860520611341e-01, TOL));
assert(isequalRel(ss1,       -2.482981559624e-05, TOL));
assert(isequalRel(ss2,       -1.706345593936e-04, TOL));
assert(isequalRel(ss3,        3.412651040191e-04, TOL));
assert(isequalRel(ss4,        3.412610892981e-04, TOL));
assert(isequalRel(ss5,        1.105337187989e-01, TOL));
assert(isequalRel(ss6,        4.832065821233e-02, TOL));
assert(isequalRel(ss7,       -8.014146734236e-01, TOL));
assert(isequalRel(sz1,        8.767976650646e+00, TOL));
assert(isequalRel(sz2,       -8.931633946627e+00, TOL));
assert(isequalRel(sz3,        6.169258803781e+00, TOL));
assert(isequalRel(sz11,      -1.152824021952e+00, TOL));
assert(isequalRel(sz12,       9.901959550000e-01, TOL));
assert(isequalRel(sz13,       2.246796171257e+00, TOL));
assert(isequalRel(sz21,      -1.154475187594e+00, TOL));
assert(isequalRel(sz22,       2.988311744821e+00, TOL));
assert(isequalRel(sz23,      -1.523900599171e+00, TOL));
assert(isequalRel(sz31,       3.250295769937e+00, TOL));
assert(isequalRel(sz32,      -1.075491222740e+01, TOL));
assert(isequalRel(sz33,       1.892522670385e+00, TOL));
assert(isequalRel(xgh2,       6.595724207569e-04, TOL));
assert(isequalRel(xgh3,       1.091630835372e-03, TOL));
assert(isequalRel(xgh4,      -5.416568688173e-05, TOL));
assert(isequalRel(xh2,       -1.288582105817e-04, TOL));
assert(isequalRel(xh3,       -9.703376083569e-05, TOL));
assert(isequalRel(xi2,       -8.270003713552e-05, TOL));
assert(isequalRel(xi3,        1.575914794162e-04, TOL));
assert(isequalRel(xl2,       -4.514061623044e-04, TOL));
assert(isequalRel(xl3,       -1.081448579815e-03, TOL));
assert(isequalRel(xl4,        1.263893640252e-04, TOL));
assert(isequalRel(nm,         8.751201528747e-03, TOL));
assert(isequalRel(z1,         3.157998007190e+00, TOL));
assert(isequalRel(z2,         4.117683606420e+00, TOL));
assert(isequalRel(z3,         1.302286796280e+01, TOL));
assert(isequalRel(z11,        2.120494801971e+00, TOL));
assert(isequalRel(z12,        1.508745823590e+00, TOL));
assert(isequalRel(z13,       -7.545400183037e-01, TOL));
assert(isequalRel(z21,       -3.322838238711e-01, TOL));
assert(isequalRel(z22,       -2.350836756359e+00, TOL));
assert(isequalRel(z23,       -2.102528269689e+00, TOL));
assert(isequalRel(z31,       -1.937886829300e+00, TOL));
assert(isequalRel(z32,        6.016626980242e+00, TOL));
assert(isequalRel(z33,        8.019981829044e+00, TOL));
assert(isequalRel(zmol,       1.529662090192e+00, TOL));
assert(isequalRel(zmos,       2.959059713970e+00, TOL));
# 28129
# 28350
# *** error: t:= 1560.000000 *** code =   1

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063181079184e+04,  6.249053000000e-01,  2.971510317983e+00,  0.000000000000e+00,  4.977679026688e-01,  2.006838915138e+00,  1.655279727416e-02);
assert(isequalRel(sinim,      4.774654962260e-01, TOL));
assert(isequalRel(cosim,      8.786504992963e-01, TOL));
assert(isequalRel(sinomm,     1.692634972133e-01, TOL));
assert(isequalRel(cosomm,    -9.855708338375e-01, TOL));
assert(isequalRel(snodm,      9.064301919275e-01, TOL));
assert(isequalRel(cnodm,     -4.223556642953e-01, TOL));
assert(isequalRel(day,        3.889331079184e+04, TOL));
assert(isequalRel(e3,         2.080207273239e-04, TOL));
assert(isequalRel(ee2,        2.279612848318e-04, TOL));
assert(isequalRel(em,         6.249053000000e-01, TOL));
assert(isequalRel(emsq,       3.905066339681e-01, TOL));
assert(isequalRel(gam,        8.145806031771e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     7.807005610552e-01, TOL));
assert(isequalRel(se2,       -2.010666927152e-03, TOL));
assert(isequalRel(se3,        1.234888459603e-04, TOL));
assert(isequalRel(sgh2,       4.404694052449e-04, TOL));
assert(isequalRel(sgh3,      -3.174852765982e-03, TOL));
assert(isequalRel(sgh4,      -4.246782106577e-05, TOL));
assert(isequalRel(sh2,        4.897361699131e-04, TOL));
assert(isequalRel(sh3,       -1.594883558919e-04, TOL));
assert(isequalRel(si2,       -1.422358125944e-03, TOL));
assert(isequalRel(si3,       -1.642085155919e-03, TOL));
assert(isequalRel(sl2,       -1.791873501287e-03, TOL));
assert(isequalRel(sl3,        5.840111590196e-03, TOL));
assert(isequalRel(sl4,        1.481689063817e-04, TOL));
assert(isequalRel(s1,        -2.120658619569e-04, TOL));
assert(isequalRel(s2,        -1.855950189595e-05, TOL));
assert(isequalRel(s3,         2.897882708615e-05, TOL));
assert(isequalRel(s4,         2.262378656488e-05, TOL));
assert(isequalRel(s5,         2.722596005818e-01, TOL));
assert(isequalRel(s6,        -5.374775617541e-01, TOL));
assert(isequalRel(s7,        -4.904625511250e-01, TOL));
assert(isequalRel(ss1,       -1.320316739475e-03, TOL));
assert(isequalRel(ss2,       -1.155509934670e-04, TOL));
assert(isequalRel(ss3,        1.804214508603e-04, TOL));
assert(isequalRel(ss4,        1.408551279130e-04, TOL));
assert(isequalRel(ss5,        2.346453190940e-01, TOL));
assert(isequalRel(ss6,        7.614335511458e-01, TOL));
assert(isequalRel(ss7,       -4.676485659395e-02, TOL));
assert(isequalRel(sz1,        1.776222957970e+01, TOL));
assert(isequalRel(sz2,        4.965799500954e+00, TOL));
assert(isequalRel(sz3,        1.577591992681e+00, TOL));
assert(isequalRel(sz11,      -5.936254038933e+00, TOL));
assert(isequalRel(sz12,       6.154677183070e+00, TOL));
assert(isequalRel(sz13,       1.169202637163e+00, TOL));
assert(isequalRel(sz21,      -7.594596902903e-01, TOL));
assert(isequalRel(sz22,       2.119134397807e+00, TOL));
assert(isequalRel(sz23,      -1.449580783613e+00, TOL));
assert(isequalRel(sz31,       9.294909311397e+00, TOL));
assert(isequalRel(sz32,       1.563554738018e+00, TOL));
assert(isequalRel(sz33,      -1.975013243152e+00, TOL));
assert(isequalRel(xgh2,      -3.876052640328e-04, TOL));
assert(isequalRel(xgh3,       2.628367881541e-04, TOL));
assert(isequalRel(xgh4,      -2.235682588341e-05, TOL));
assert(isequalRel(xh2,       -7.296812344377e-05, TOL));
assert(isequalRel(xh3,       -4.081833544751e-05, TOL));
assert(isequalRel(xi2,       -6.948628061380e-05, TOL));
assert(isequalRel(xi3,        3.512666727653e-04, TOL));
assert(isequalRel(xl2,        8.272799129225e-04, TOL));
assert(isequalRel(xl3,       -3.372511878045e-04, TOL));
assert(isequalRel(xl4,        7.800226991119e-05, TOL));
assert(isequalRel(nm,         1.655279727416e-02, TOL));
assert(isequalRel(z1,         5.938562976121e+00, TOL));
assert(isequalRel(z2,        -1.427386813247e+01, TOL));
assert(isequalRel(z3,         1.175748702715e+01, TOL));
assert(isequalRel(z11,        2.138574136804e+00, TOL));
assert(isequalRel(z12,        1.871986678397e+00, TOL));
assert(isequalRel(z13,       -7.324682871238e+00, TOL));
assert(isequalRel(z21,       -5.405862432734e-01, TOL));
assert(isequalRel(z22,       -1.965788841016e+00, TOL));
assert(isequalRel(z23,       -1.640247637107e+00, TOL));
assert(isequalRel(z31,        3.189234780521e-01, TOL));
assert(isequalRel(z32,       -8.566321621740e+00, TOL));
assert(isequalRel(z33,        6.127782826163e+00, TOL));
assert(isequalRel(zmol,       2.040461217495e+00, TOL));
assert(isequalRel(zmos,       2.997593526865e+00, TOL));
# 28623

[sinim, cosim, sinomm, cosomm, snodm, cnodm, day, e3, ee2, em, emsq, gam, ...
 peo, pgho, pho, pinco, plo, rtemsq, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, ...
 si3, sl2, sl3, sl4, s1, s2, s3, s4, s5, s6, s7, ss1, ss2, ss3, ss4, ss5, ss6, ss7, ...
 sz1, sz2, sz3, sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33, xgh2, xgh3, ...
 xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, nm, z1, z2, z3, z11, z12, z13, z21, z22, ...
 z23, z31, z32, z33, zmol, zmos]...
 = dscom( 2.063046683397e+04,  3.350000000000e-05,  2.407123197766e-01,  0.000000000000e+00,  3.316125578789e-05,  5.008105351538e+00,  4.374949216286e-03);
assert(isequalRel(sinim,      3.316125578181e-05, TOL));
assert(isequalRel(cosim,      9.999999994502e-01, TOL));
assert(isequalRel(sinomm,     2.383944693127e-01, TOL));
assert(isequalRel(cosomm,     9.711684081564e-01, TOL));
assert(isequalRel(snodm,     -9.565936191876e-01, TOL));
assert(isequalRel(cnodm,      2.914252009170e-01, TOL));
assert(isequalRel(day,        3.889196683397e+04, TOL));
assert(isequalRel(e3,         9.730286584479e-08, TOL));
assert(isequalRel(ee2,        4.116645807083e-09, TOL));
assert(isequalRel(em,         3.350000000000e-05, TOL));
assert(isequalRel(emsq,       1.122250000000e-09, TOL));
assert(isequalRel(gam,        8.145544716903e+01, TOL));
assert(isequalRel(peo,        0.000000000000e+00, TOL));
assert(isequalRel(pgho,       0.000000000000e+00, TOL));
assert(isequalRel(pho,        0.000000000000e+00, TOL));
assert(isequalRel(pinco,      0.000000000000e+00, TOL));
assert(isequalRel(plo,        0.000000000000e+00, TOL));
assert(isequalRel(rtemsq,     9.999999994389e-01, TOL));
assert(isequalRel(se2,       -4.897269431303e-07, TOL));
assert(isequalRel(se3,       -3.982514162897e-07, TOL));
assert(isequalRel(sgh2,       1.218979806720e-02, TOL));
assert(isequalRel(sgh3,      -1.372729148759e-02, TOL));
assert(isequalRel(sgh4,      -2.058135042329e-04, TOL));
assert(isequalRel(sh2,       -1.607052704128e-03, TOL));
assert(isequalRel(sh3,        1.922166128879e-04, TOL));
assert(isequalRel(si2,        1.068903225853e-04, TOL));
assert(isequalRel(si3,        1.503069663730e-03, TOL));
assert(isequalRel(sl2,       -1.268456207451e-02, TOL));
assert(isequalRel(sl3,        1.252883219957e-02, TOL));
assert(isequalRel(sl4,        4.802315103772e-04, TOL));
assert(isequalRel(s1,        -5.509538844302e-08, TOL));
assert(isequalRel(s2,        -5.482128209438e-05, TOL));
assert(isequalRel(s3,         1.096425641272e-04, TOL));
assert(isequalRel(s4,         1.096425640657e-04, TOL));
assert(isequalRel(s5,         1.006889932162e-01, TOL));
assert(isequalRel(s6,        -3.735925930843e-02, TOL));
assert(isequalRel(s7,        -8.830400201772e-01, TOL));
assert(isequalRel(ss1,       -3.430225070548e-07, TOL));
assert(isequalRel(ss2,       -3.413159278008e-04, TOL));
assert(isequalRel(ss3,        6.826318552185e-04, TOL));
assert(isequalRel(ss4,        6.826318548355e-04, TOL));
assert(isequalRel(ss5,        6.952479533275e-02, TOL));
assert(isequalRel(ss6,        7.138408312257e-01, TOL));
assert(isequalRel(ss7,        5.805033315585e-01, TOL));
assert(isequalRel(sz1,        1.397388821705e+01, TOL));
assert(isequalRel(sz2,        9.290924513366e+00, TOL));
assert(isequalRel(sz3,        4.797029487281e+00, TOL));
assert(isequalRel(sz11,       2.148442577894e+00, TOL));
assert(isequalRel(sz12,      -1.565856057085e-01, TOL));
assert(isequalRel(sz13,      -5.343190451679e-02, TOL));
assert(isequalRel(sz21,       1.782467849547e-01, TOL));
assert(isequalRel(sz22,      -2.354201156804e+00, TOL));
assert(isequalRel(sz23,       4.598284476190e-01, TOL));
assert(isequalRel(sz31,       8.887642026753e+00, TOL));
assert(isequalRel(sz32,       8.928530056762e+00, TOL));
assert(isequalRel(sz33,      -1.167039270606e+00, TOL));
assert(isequalRel(xgh2,      -2.791926643954e-03, TOL));
assert(isequalRel(xgh3,      -6.071229788246e-05, TOL));
assert(isequalRel(xgh4,      -1.083487818097e-04, TOL));
assert(isequalRel(xh2,        2.358741028641e-04, TOL));
assert(isequalRel(xh3,        2.037703492136e-04, TOL));
assert(isequalRel(xi2,        1.978957741048e-04, TOL));
assert(isequalRel(xi3,       -1.979448507755e-04, TOL));
assert(isequalRel(xl2,        2.660801647839e-03, TOL));
assert(isequalRel(xl3,        3.319557433091e-04, TOL));
assert(isequalRel(xl4,        2.528138244862e-04, TOL));
assert(isequalRel(nm,         4.374949216286e-03, TOL));
assert(isequalRel(z1,         9.646010296956e+00, TOL));
assert(isequalRel(z2,        -1.213398131018e+01, TOL));
assert(isequalRel(z3,         8.132201558755e+00, TOL));
assert(isequalRel(z11,        3.027985928786e-01, TOL));
assert(isequalRel(z12,       -1.804917420247e+00, TOL));
assert(isequalRel(z13,        2.108163619135e+00, TOL));
assert(isequalRel(z21,       -5.607883259758e-01, TOL));
assert(isequalRel(z22,        2.151300497297e+00, TOL));
assert(isequalRel(z23,        1.297708424089e+00, TOL));
assert(isequalRel(z31,        3.714486889036e+00, TOL));
assert(isequalRel(z32,       -1.273194706702e+01, TOL));
assert(isequalRel(z33,        3.437622249834e+00, TOL));
assert(isequalRel(zmol,       1.734002358913e+00, TOL));
assert(isequalRel(zmos,       2.974474794500e+00, TOL));
# 28626
# 28872
# 29141
# *** error: t:= 440.000000 *** code =   6
# 29238
# 88888

