...Cleaning up files to start...
     ...Cleaning Grope Files...
     ...Cleaning Log Files...
     ...Cleaning Exodus Output Files...
     ...Cleaning Temporary Files...
 
 
     ...Doing a serial test...
 
     ...Creating tmp_ files to record failures and passes...
 
     ...Running tests on sahp5120...
 
Running tests in . :
     
     ...Parsing ./acoustics/coupled_acoustics1_test and creating the_script...
     
     ...Parsing ./acoustics/coupled_acoustics2_test and creating the_script...
     
     ...Parsing ./acoustics/coupled_acoustics3_test and creating the_script...
     
     ...Parsing ./acoustics/coupled_acoustics4_test and creating the_script...
     
     ...Parsing ./acoustics/coupled_acoustics4a_test and creating the_script...
     
     ...Parsing ./acoustics/infinite_tube_test and creating the_script...
     
     ...Parsing ./acoustics/waveguide_directfrf_test and creating the_script...
     
     ...Parsing ./acoustics/waveguide_eigen_test and creating the_script...
     
     ...Parsing ./acoustics/waveguide_transient_test and creating the_script...
     
     ...Parsing ./aniso/anisoGump_test and creating the_script...
     
     ...Parsing ./aniso/isoGump_test and creating the_script...
     
     ...Parsing ./aniso/ortho_test and creating the_script...
     
     ...Parsing ./aniso/quartz_test and creating the_script...
     
     ...Parsing ./aniso/sr_test and creating the_script...
     
     ...Parsing ./beam/beam100_circle_test and creating the_script...
     
     ...Parsing ./beam/beam100_eigk_test and creating the_script...
     
     ...Parsing ./beam/beam100_torsion_test and creating the_script...
     
     ...Parsing ./beam/beam100_xy_test and creating the_script...
     
     ...Parsing ./beam/beam100_xz_test and creating the_script...
     
     ...Parsing ./beam/bstiffener_test and creating the_script...
     
     ...Parsing ./beam/cube4_test and creating the_script...
     
     ...Parsing ./beam/dash_test and creating the_script...
     
     ...Parsing ./beam/eforce2_test and creating the_script...
     
     ...Parsing ./beam/eforce_test and creating the_script...
     
     ...Parsing ./beam/gap2d_test and creating the_script...
     
     ...Parsing ./beam/gap2g_test and creating the_script...
     
     ...Parsing ./beam/gap_test and creating the_script...
     
     ...Parsing ./beam/gasdmp_test and creating the_script...
     
     ...Parsing ./beam/hys1_test and creating the_script...
     
     ...Parsing ./beam/nlbeam_test and creating the_script...
     
     ...Parsing ./beam/nldash_test and creating the_script...
     
     ...Parsing ./beam/nlrspring_test and creating the_script...
     
     ...Parsing ./beam/ring1_test and creating the_script...
     
     ...Parsing ./beam/rspring_test and creating the_script...
     
     ...Parsing ./beam/shys1_test and creating the_script...
     
     ...Parsing ./beam/small2g_test and creating the_script...
     
     ...Parsing ./beam/tblchk_test and creating the_script...
     
     ...Parsing ./directfrf/directFRF1_test and creating the_script...
     
     ...Parsing ./directfrf/directFRF2_imag_test and creating the_script...
     
     ...Parsing ./directfrf/directFRF2_test and creating the_script...
     
     ...Parsing ./directfrf/directFRF3_test and creating the_script...
     
     ...Parsing ./directfrf/directFRF4_test and creating the_script...
     
     ...Parsing ./hex/dead1_test and creating the_script...
     
     ...Parsing ./hex/dead2_test and creating the_script...
     
     ...Parsing ./hex/hex20_sideset_test and creating the_script...
     
     ...Parsing ./hex/hex20_small_rot2_test and creating the_script...
     
     ...Parsing ./hex/hex8_small_eigen_test and creating the_script...
     
     ...Parsing ./hex/hex8_small_statics_test and creating the_script...
     
     ...Parsing ./hex/hex_sub_eigen_test and creating the_script...
     
     ...Parsing ./hex/hexplateMpc_test and creating the_script...
     
     ...Parsing ./hex/hexplate_1_test and creating the_script...
     
     ...Parsing ./hex/hexplate_free_test and creating the_script...
     
     ...Parsing ./hex/hexplate_list_test and creating the_script...
     
     ...Parsing ./hex/hexplate_multi_eigen_test and creating the_script...
     
     ...Parsing ./hex/hexplate_multi_test and creating the_script...
     
     ...Parsing ./hex/hexplate_test and creating the_script...
     
     ...Parsing ./hex/hexplatemulti_test and creating the_script...
     
     ...Parsing ./hex/hexshell_ex1_test and creating the_script...
     
     ...Parsing ./hex/mult-loads-th_test and creating the_script...
     
     ...Parsing ./hex/mult-loads-time_test and creating the_script...
     
     ...Parsing ./hex/nltrans_test and creating the_script...
     
     ...Parsing ./hex/output_coord2_test and creating the_script...
     
     ...Parsing ./hex/output_coord3_test and creating the_script...
     
     ...Parsing ./hex/output_coord4_test and creating the_script...
     
     ...Parsing ./hex/output_coord_test and creating the_script...
     
     ...Parsing ./hex/pure_bend_static_test and creating the_script...
     
     ...Parsing ./modal-tests/eigsens_test and creating the_script...
     
     ...Parsing ./modal-tests/fixed_rbe3_test and creating the_script...
     
     ...Parsing ./modal-tests/hexrms_bis_test and creating the_script...
     
     ...Parsing ./modal-tests/hexrms_test and creating the_script...
     
     ...Parsing ./modal-tests/modalFRF2_parallel_test and creating the_script...
     
     ...Parsing ./modal-tests/modalFRF2_test and creating the_script...
     
     ...Parsing ./modal-tests/modalFRF_parallel_test and creating the_script...
     
     ...Parsing ./modal-tests/modalFRF_test and creating the_script...
     
     ...Parsing ./modal-tests/modalaccelFRF_parallel_test and creating the_script...
     
     ...Parsing ./modal-tests/modalaccelFRF_test and creating the_script...
     
     ...Parsing ./modal-tests/modalshock_test and creating the_script...
     
     ...Parsing ./modal-tests/modaltrans2_test and creating the_script...
     
     ...Parsing ./modal-tests/modaltrans_test and creating the_script...
     
     ...Parsing ./modal-tests/transhock1_test and creating the_script...
     
     ...Parsing ./modal-tests/transhock_test and creating the_script...
     
     ...Parsing ./modal-tests/vmodalFRF_rbars_test and creating the_script...
     
     ...Parsing ./modal-tests/vmodalshock_rbars_test and creating the_script...
     
     ...Parsing ./modal-tests/vmodaltrans_rbars_test and creating the_script...
     
     ...Parsing ./modal-tests/vran0_test and creating the_script...
     
     ...Parsing ./modal-tests/vran_rbars_test and creating the_script...
     
     ...Parsing ./mpc/BoxOnBarA_test and creating the_script...
     
     ...Parsing ./mpc/BoxOnBarB_test and creating the_script...
     
     ...Parsing ./mpc/BoxOnBarC_test and creating the_script...
     
     ...Parsing ./mpc/BoxOnBarF-redundant_test and creating the_script...
     
     ...Parsing ./mpc/BoxOnBarF_test and creating the_script...
     
     ...Parsing ./mpc/BoxOnBarRbe3_test and creating the_script...
     
     ...Parsing ./mpc/BoxOnBarS_test and creating the_script...
     
     ...Parsing ./mpc/gcoord_test and creating the_script...
     
     ...Parsing ./mpc/mult_rbe3_test and creating the_script...
     
     ...Parsing ./mpc/redundant_test and creating the_script...
     
     ...Parsing ./obeam/Obeam100_torsion_test and creating the_script...
     
     ...Parsing ./obeam/Obeam100_xz_test and creating the_script...
     
     ...Parsing ./quadt/cjdamp2_test and creating the_script...
     
     ...Parsing ./quadt/cjdamp_test and creating the_script...
     
     ...Parsing ./quadt/quad8beam_nlstatics_test and creating the_script...
     
     ...Parsing ./quadt/quadbeam_eig_test and creating the_script...
     
     ...Parsing ./quadt/quadbeam_nlstatics_test and creating the_script...
     
     ...Parsing ./quadt/quadbeam_stress_test and creating the_script...
     
     ...Parsing ./quadt/quadbeam_test and creating the_script...
     
     ...Parsing ./quadt/sphereq_test and creating the_script...
     
     ...Parsing ./quadt/stiffener_test and creating the_script...
     
     ...Parsing ./sfe/beam10a_test and creating the_script...
     
     ...Parsing ./sfe/beam10b_test and creating the_script...
     
     ...Parsing ./sfe/hex8a_test and creating the_script...
     
     ...Parsing ./sfe/hex8b_test and creating the_script...
     
     ...Parsing ./sfe/tri8a_test and creating the_script...
     
     ...Parsing ./sfe/tri8b_test and creating the_script...
     
     ...Parsing ./sidesets/quad4/quad4_test and creating the_script...
     
     ...Parsing ./sidesets/hex20_test and creating the_script...
     
     ...Parsing ./sidesets/hex8_test and creating the_script...
     
     ...Parsing ./sidesets/sidebc_test and creating the_script...
     
     ...Parsing ./sidesets/tet10_test and creating the_script...
     
     ...Parsing ./sidesets/tet4_test and creating the_script...
     
     ...Parsing ./sidesets/wedge6_test and creating the_script...
     
     ...Parsing ./sidesets/quad8/quad8_test and creating the_script...
     
     ...Parsing ./sidesets/tria3/tria3_test and creating the_script...
     
     ...Parsing ./sidesets/tria3/triashell_test and creating the_script...
     
     ...Parsing ./sidesets/tria6/tria6_test and creating the_script...
     
     ...Parsing ./tet10/a_eigrst_test and creating the_script...
     
     ...Parsing ./tet10/b_eigrst_test and creating the_script...
     
     ...Parsing ./tet10/tet10_beam_small_eigen_test and creating the_script...
     
     ...Parsing ./tet10/tet10_beam_small_statics_test and creating the_script...
     
     ...Parsing ./tet10/tet10_sidesets_test and creating the_script...
     
     ...Parsing ./tet4/tet4_small_eigen_test and creating the_script...
     
     ...Parsing ./tet4/tet4_small_statics_test and creating the_script...
     
     ...Parsing ./tied_surfaces/barely_tied_test and creating the_script...
     
     ...Parsing ./tied_surfaces/hex_tied_surface_develop_test and creating the_script...
     
     ...Parsing ./tied_surfaces/hex_tied_surface_test and creating the_script...
     
     ...Parsing ./tied_surfaces/tied_corner_test and creating the_script...
     
     ...Parsing ./tied_surfaces/two_plates_test and creating the_script...
     
     ...Parsing ./traction/beam_hex20_test and creating the_script...
     
     ...Parsing ./traction/beam_hex8_test and creating the_script...
     
     ...Parsing ./traction/beam_quad4_2_test and creating the_script...
     
     ...Parsing ./traction/beam_quad4_test and creating the_script...
     
     ...Parsing ./traction/beam_quad8_2_test and creating the_script...
     
     ...Parsing ./traction/beam_quad8_test and creating the_script...
     
     ...Parsing ./traction/beam_tet10_test and creating the_script...
     
     ...Parsing ./traction/beam_tet4_test and creating the_script...
     
     ...Parsing ./traction/beam_tria3_2_test and creating the_script...
     
     ...Parsing ./traction/beam_tria3_test and creating the_script...
     
     ...Parsing ./traction/beam_tria6_2_test and creating the_script...
     
     ...Parsing ./traction/beam_tria6_test and creating the_script...
     
     ...Parsing ./traction/beam_wedge15_test and creating the_script...
     
     ...Parsing ./traction/beam_wedge6_test and creating the_script...
     
     ...Parsing ./traction/half_pipe_wedge15_test and creating the_script...
     
     ...Parsing ./transient/blkdmp_test and creating the_script...
     
     ...Parsing ./transient/gen_alpha1_test and creating the_script...
     
     ...Parsing ./transient/gen_alpha2_modaldamping_test and creating the_script...
     
     ...Parsing ./transient/gen_alpha2_test and creating the_script...
     
     ...Parsing ./transient/gen_alpha3_test and creating the_script...
     
     ...Parsing ./transient/vepatch_test and creating the_script...
     
     ...Parsing ./tria3/sphere600_test and creating the_script...
     
     ...Parsing ./tria3/tri-beam_nlstatics_test and creating the_script...
     
     ...Parsing ./tria3/tri-beam_test and creating the_script...
     
     ...Parsing ./tria6/tria6_beam_eig_test and creating the_script...
     
     ...Parsing ./tria6/tria6_beam_nlstatics_test and creating the_script...
     
     ...Parsing ./tria6/tria6_beam_statics_test and creating the_script...
     
     ...Parsing ./triashell/sphere600-triashell_test and creating the_script...
     
     ...Parsing ./triashell/tri-beam-triashell_test and creating the_script...
     
     ...Parsing ./truss/truss32_eigen_test and creating the_script...
     
     ...Parsing ./truss/truss32_statics_test and creating the_script...
     
     ...Parsing ./truss/truss_nlstatics_test and creating the_script...
     
     ...Parsing ./wedge/pure_bend_static_test and creating the_script...
     
     ...Parsing ./wedge/wedge6_small_eigen_test and creating the_script...
     
     ...Parsing ./wedge/wedge6_small_statics_test and creating the_script...
     
     ...Parsing ./wedge/wtest6_test and creating the_script...
 
     ...Executing the_script...
 
     ...Executing coupled_acoustics1_test...
==13778== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==13778== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==13778== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==13778== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==13778== Estimated CPU clock rate is 2812 MHz
==13778== For more details, rerun with: -v
==13778== 
==13778== 
==13778== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==13778== malloc/free: in use at exit: 1139577 bytes in 84 blocks.
==13778== malloc/free: 7992 allocs, 7908 frees, 101203096 bytes allocated.
==13778== For counts of detected errors, rerun with: -v
==13778== searching for pointers to 84 not-freed blocks.
==13778== checked 7981620 bytes.
==13778== 
==13778== LEAK SUMMARY:
==13778==    definitely lost: 0 bytes in 0 blocks.
==13778==    possibly lost:   0 bytes in 0 blocks.
==13778==    still reachable: 1139577 bytes in 84 blocks.
==13778==         suppressed: 0 bytes in 0 blocks.
==13778== Reachable blocks (those to which a pointer was found) are not shown.
==13778== To see them, rerun with: --show-reachable=yes
==13778== 
 
     ...Executing coupled_acoustics2_test...
==14023== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14023== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14023== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14023== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14023== Estimated CPU clock rate is 2831 MHz
==14023== For more details, rerun with: -v
==14023== 
==14023== 
==14023== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14023== malloc/free: in use at exit: 56017 bytes in 35 blocks.
==14023== malloc/free: 9922 allocs, 9887 frees, 1563707847 bytes allocated.
==14023== For counts of detected errors, rerun with: -v
==14023== searching for pointers to 35 not-freed blocks.
==14023== checked 7067656 bytes.
==14023== 
==14023== LEAK SUMMARY:
==14023==    definitely lost: 0 bytes in 0 blocks.
==14023==    possibly lost:   0 bytes in 0 blocks.
==14023==    still reachable: 56017 bytes in 35 blocks.
==14023==         suppressed: 0 bytes in 0 blocks.
==14023== Reachable blocks (those to which a pointer was found) are not shown.
==14023== To see them, rerun with: --show-reachable=yes
==14023== 
 
     ...Executing coupled_acoustics3_test...
==14081== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14081== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14081== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14081== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14081== Estimated CPU clock rate is 2826 MHz
==14081== For more details, rerun with: -v
==14081== 
==14081== 
==14081== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14081== malloc/free: in use at exit: 74797 bytes in 40 blocks.
==14081== malloc/free: 2150 allocs, 2110 frees, 5705798 bytes allocated.
==14081== For counts of detected errors, rerun with: -v
==14081== searching for pointers to 40 not-freed blocks.
==14081== checked 7081764 bytes.
==14081== 
==14081== LEAK SUMMARY:
==14081==    definitely lost: 0 bytes in 0 blocks.
==14081==    possibly lost:   0 bytes in 0 blocks.
==14081==    still reachable: 74797 bytes in 40 blocks.
==14081==         suppressed: 0 bytes in 0 blocks.
==14081== Reachable blocks (those to which a pointer was found) are not shown.
==14081== To see them, rerun with: --show-reachable=yes
==14081== 
 
     ...Executing coupled_acoustics4_test...
==14102== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14102== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14102== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14102== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14102== Estimated CPU clock rate is 2828 MHz
==14102== For more details, rerun with: -v
==14102== 
==14102== 
==14102== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14102== malloc/free: in use at exit: 1139577 bytes in 84 blocks.
==14102== malloc/free: 14520 allocs, 14436 frees, 169502133 bytes allocated.
==14102== For counts of detected errors, rerun with: -v
==14102== searching for pointers to 84 not-freed blocks.
==14102== checked 7982132 bytes.
==14102== 
==14102== LEAK SUMMARY:
==14102==    definitely lost: 0 bytes in 0 blocks.
==14102==    possibly lost:   0 bytes in 0 blocks.
==14102==    still reachable: 1139577 bytes in 84 blocks.
==14102==         suppressed: 0 bytes in 0 blocks.
==14102== Reachable blocks (those to which a pointer was found) are not shown.
==14102== To see them, rerun with: --show-reachable=yes
==14102== 
 
     ...Executing coupled_acoustics4a_test...
==14328== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14328== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14328== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14328== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14328== Estimated CPU clock rate is 2809 MHz
==14328== For more details, rerun with: -v
==14328== 
==14328== 
==14328== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14328== malloc/free: in use at exit: 1139577 bytes in 84 blocks.
==14328== malloc/free: 14520 allocs, 14436 frees, 169502133 bytes allocated.
==14328== For counts of detected errors, rerun with: -v
==14328== searching for pointers to 84 not-freed blocks.
==14328== checked 7986484 bytes.
==14328== 
==14328== LEAK SUMMARY:
==14328==    definitely lost: 0 bytes in 0 blocks.
==14328==    possibly lost:   0 bytes in 0 blocks.
==14328==    still reachable: 1139577 bytes in 84 blocks.
==14328==         suppressed: 0 bytes in 0 blocks.
==14328== Reachable blocks (those to which a pointer was found) are not shown.
==14328== To see them, rerun with: --show-reachable=yes
==14328== 
 
     ...Executing infinite_tube_test...
==14543== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14543== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14543== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14543== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14543== Estimated CPU clock rate is 2804 MHz
==14543== For more details, rerun with: -v
==14543== 
==14543== 
==14543== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14543== malloc/free: in use at exit: 23933 bytes in 22 blocks.
==14543== malloc/free: 4495 allocs, 4473 frees, 123532000 bytes allocated.
==14543== For counts of detected errors, rerun with: -v
==14543== searching for pointers to 22 not-freed blocks.
==14543== checked 7041592 bytes.
==14543== 
==14543== LEAK SUMMARY:
==14543==    definitely lost: 0 bytes in 0 blocks.
==14543==    possibly lost:   0 bytes in 0 blocks.
==14543==    still reachable: 23933 bytes in 22 blocks.
==14543==         suppressed: 0 bytes in 0 blocks.
==14543== Reachable blocks (those to which a pointer was found) are not shown.
==14543== To see them, rerun with: --show-reachable=yes
==14543== 
 
     ...Executing waveguide_directfrf_test...
==14553== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14553== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14553== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14553== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14553== Estimated CPU clock rate is 2812 MHz
==14553== For more details, rerun with: -v
==14553== 
==14553== 
==14553== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14553== malloc/free: in use at exit: 41729 bytes in 20 blocks.
==14553== malloc/free: 3053 allocs, 3033 frees, 145063706 bytes allocated.
==14553== For counts of detected errors, rerun with: -v
==14553== searching for pointers to 20 not-freed blocks.
==14553== checked 7060668 bytes.
==14553== 
==14553== LEAK SUMMARY:
==14553==    definitely lost: 0 bytes in 0 blocks.
==14553==    possibly lost:   0 bytes in 0 blocks.
==14553==    still reachable: 41729 bytes in 20 blocks.
==14553==         suppressed: 0 bytes in 0 blocks.
==14553== Reachable blocks (those to which a pointer was found) are not shown.
==14553== To see them, rerun with: --show-reachable=yes
==14553== 
 
     ...Executing waveguide_eigen_test...
==14569== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14569== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14569== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14569== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14569== Estimated CPU clock rate is 2811 MHz
==14569== For more details, rerun with: -v
==14569== 
==14569== 
==14569== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14569== malloc/free: in use at exit: 18654 bytes in 16 blocks.
==14569== malloc/free: 1482 allocs, 1466 frees, 1312747 bytes allocated.
==14569== For counts of detected errors, rerun with: -v
==14569== searching for pointers to 16 not-freed blocks.
==14569== checked 7039644 bytes.
==14569== 
==14569== LEAK SUMMARY:
==14569==    definitely lost: 0 bytes in 0 blocks.
==14569==    possibly lost:   0 bytes in 0 blocks.
==14569==    still reachable: 18654 bytes in 16 blocks.
==14569==         suppressed: 0 bytes in 0 blocks.
==14569== Reachable blocks (those to which a pointer was found) are not shown.
==14569== To see them, rerun with: --show-reachable=yes
==14569== 
 
     ...Executing waveguide_transient_test...
==14582== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14582== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14582== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14582== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14582== Estimated CPU clock rate is 2816 MHz
==14582== For more details, rerun with: -v
==14582== 
==14582== 
==14582== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14582== malloc/free: in use at exit: 41729 bytes in 20 blocks.
==14582== malloc/free: 2936 allocs, 2916 frees, 23763387 bytes allocated.
==14582== For counts of detected errors, rerun with: -v
==14582== searching for pointers to 20 not-freed blocks.
==14582== checked 7064380 bytes.
==14582== 
==14582== LEAK SUMMARY:
==14582==    definitely lost: 0 bytes in 0 blocks.
==14582==    possibly lost:   0 bytes in 0 blocks.
==14582==    still reachable: 41729 bytes in 20 blocks.
==14582==         suppressed: 0 bytes in 0 blocks.
==14582== Reachable blocks (those to which a pointer was found) are not shown.
==14582== To see them, rerun with: --show-reachable=yes
==14582== 
 
     ...Executing anisoGump_test...
==14593== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14593== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14593== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14593== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14593== Estimated CPU clock rate is 2791 MHz
==14593== For more details, rerun with: -v
==14593== 
==14593== 
==14593== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14593== malloc/free: in use at exit: 39339 bytes in 16 blocks.
==14593== malloc/free: 1753 allocs, 1737 frees, 8646766 bytes allocated.
==14593== For counts of detected errors, rerun with: -v
==14593== searching for pointers to 16 not-freed blocks.
==14593== checked 7055196 bytes.
==14593== 
==14593== LEAK SUMMARY:
==14593==    definitely lost: 0 bytes in 0 blocks.
==14593==    possibly lost:   0 bytes in 0 blocks.
==14593==    still reachable: 39339 bytes in 16 blocks.
==14593==         suppressed: 0 bytes in 0 blocks.
==14593== Reachable blocks (those to which a pointer was found) are not shown.
==14593== To see them, rerun with: --show-reachable=yes
==14593== 
 
     ...Executing isoGump_test...
==14612== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14612== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14612== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14612== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14612== Estimated CPU clock rate is 2818 MHz
==14612== For more details, rerun with: -v
==14612== 
==14612== 
==14612== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14612== malloc/free: in use at exit: 39339 bytes in 16 blocks.
==14612== malloc/free: 1748 allocs, 1732 frees, 8645640 bytes allocated.
==14612== For counts of detected errors, rerun with: -v
==14612== searching for pointers to 16 not-freed blocks.
==14612== checked 7057628 bytes.
==14612== 
==14612== LEAK SUMMARY:
==14612==    definitely lost: 0 bytes in 0 blocks.
==14612==    possibly lost:   0 bytes in 0 blocks.
==14612==    still reachable: 39339 bytes in 16 blocks.
==14612==         suppressed: 0 bytes in 0 blocks.
==14612== Reachable blocks (those to which a pointer was found) are not shown.
==14612== To see them, rerun with: --show-reachable=yes
==14612== 
 
     ...Executing ortho_test...
==14627== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14627== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14627== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14627== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14627== Estimated CPU clock rate is 2797 MHz
==14627== For more details, rerun with: -v
==14627== 
==14627== 
==14627== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14627== malloc/free: in use at exit: 15563 bytes in 18 blocks.
==14627== malloc/free: 917 allocs, 899 frees, 1071488 bytes allocated.
==14627== For counts of detected errors, rerun with: -v
==14627== searching for pointers to 18 not-freed blocks.
==14627== checked 7035772 bytes.
==14627== 
==14627== LEAK SUMMARY:
==14627==    definitely lost: 0 bytes in 0 blocks.
==14627==    possibly lost:   0 bytes in 0 blocks.
==14627==    still reachable: 15563 bytes in 18 blocks.
==14627==         suppressed: 0 bytes in 0 blocks.
==14627== Reachable blocks (those to which a pointer was found) are not shown.
==14627== To see them, rerun with: --show-reachable=yes
==14627== 
 
     ...Executing quartz_test...
==14638== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14638== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14638== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14638== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14638== Estimated CPU clock rate is 2812 MHz
==14638== For more details, rerun with: -v
==14638== 
==14638== 
==14638== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14638== malloc/free: in use at exit: 39339 bytes in 16 blocks.
==14638== malloc/free: 1740 allocs, 1724 frees, 8545933 bytes allocated.
==14638== For counts of detected errors, rerun with: -v
==14638== searching for pointers to 16 not-freed blocks.
==14638== checked 7060956 bytes.
==14638== 
==14638== LEAK SUMMARY:
==14638==    definitely lost: 0 bytes in 0 blocks.
==14638==    possibly lost:   0 bytes in 0 blocks.
==14638==    still reachable: 39339 bytes in 16 blocks.
==14638==         suppressed: 0 bytes in 0 blocks.
==14638== Reachable blocks (those to which a pointer was found) are not shown.
==14638== To see them, rerun with: --show-reachable=yes
==14638== 
 
     ...Executing sr_test...
==14668== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14668== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14668== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14668== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14668== Estimated CPU clock rate is 2809 MHz
==14668== For more details, rerun with: -v
==14668== 
==14668== 
==14668== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14668== malloc/free: in use at exit: 15563 bytes in 18 blocks.
==14668== malloc/free: 854 allocs, 836 frees, 1014422 bytes allocated.
==14668== For counts of detected errors, rerun with: -v
==14668== searching for pointers to 18 not-freed blocks.
==14668== checked 7032828 bytes.
==14668== 
==14668== LEAK SUMMARY:
==14668==    definitely lost: 0 bytes in 0 blocks.
==14668==    possibly lost:   0 bytes in 0 blocks.
==14668==    still reachable: 15563 bytes in 18 blocks.
==14668==         suppressed: 0 bytes in 0 blocks.
==14668== Reachable blocks (those to which a pointer was found) are not shown.
==14668== To see them, rerun with: --show-reachable=yes
==14668== 
 
     ...Executing beam100_circle_test...
==14681== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==14681== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==14681== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==14681== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==14681== Estimated CPU clock rate is 2807 MHz
==14681== For more details, rerun with: -v
==14681== 
==14681== 
==14681== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==14681== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==14681== malloc/free: 32687 allocs, 32675 frees, 208413786 bytes allocated.
==14681== For counts of detected errors, rerun with: -v
==14681== searching for pointers to 12 not-freed blocks.
==14681== checked 7032368 bytes.
==14681== 
==14681== LEAK SUMMARY:
==14681==    definitely lost: 0 bytes in 0 blocks.
==14681==    possibly lost:   0 bytes in 0 blocks.
==14681==    still reachable: 13439 bytes in 12 blocks.
==14681==         suppressed: 0 bytes in 0 blocks.
==14681== Reachable blocks (those to which a pointer was found) are not shown.
==14681== To see them, rerun with: --show-reachable=yes
==14681== 
 
     ...Executing beam100_eigk_test...
==15101== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15101== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15101== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15101== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15101== Estimated CPU clock rate is 2815 MHz
==15101== For more details, rerun with: -v
==15101== 
==15101== 
==15101== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15101== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==15101== malloc/free: 1521 allocs, 1509 frees, 373605 bytes allocated.
==15101== For counts of detected errors, rerun with: -v
==15101== searching for pointers to 12 not-freed blocks.
==15101== checked 7036976 bytes.
==15101== 
==15101== LEAK SUMMARY:
==15101==    definitely lost: 0 bytes in 0 blocks.
==15101==    possibly lost:   0 bytes in 0 blocks.
==15101==    still reachable: 13439 bytes in 12 blocks.
==15101==         suppressed: 0 bytes in 0 blocks.
==15101== Reachable blocks (those to which a pointer was found) are not shown.
==15101== To see them, rerun with: --show-reachable=yes
==15101== 
 
     ...Executing beam100_torsion_test...
==15112== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15112== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15112== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15112== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15112== Estimated CPU clock rate is 2803 MHz
==15112== For more details, rerun with: -v
==15112== 
==15112== 
==15112== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15112== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==15112== malloc/free: 1682 allocs, 1670 frees, 856833 bytes allocated.
==15112== For counts of detected errors, rerun with: -v
==15112== searching for pointers to 12 not-freed blocks.
==15112== checked 7030208 bytes.
==15112== 
==15112== LEAK SUMMARY:
==15112==    definitely lost: 0 bytes in 0 blocks.
==15112==    possibly lost:   0 bytes in 0 blocks.
==15112==    still reachable: 13439 bytes in 12 blocks.
==15112==         suppressed: 0 bytes in 0 blocks.
==15112== Reachable blocks (those to which a pointer was found) are not shown.
==15112== To see them, rerun with: --show-reachable=yes
==15112== 
 
     ...Executing beam100_xy_test...
==15122== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15122== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15122== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15122== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15122== Estimated CPU clock rate is 2794 MHz
==15122== For more details, rerun with: -v
==15122== 
==15122== 
==15122== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15122== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==15122== malloc/free: 1564 allocs, 1552 frees, 955790 bytes allocated.
==15122== For counts of detected errors, rerun with: -v
==15122== searching for pointers to 12 not-freed blocks.
==15122== checked 7031472 bytes.
==15122== 
==15122== LEAK SUMMARY:
==15122==    definitely lost: 0 bytes in 0 blocks.
==15122==    possibly lost:   0 bytes in 0 blocks.
==15122==    still reachable: 13439 bytes in 12 blocks.
==15122==         suppressed: 0 bytes in 0 blocks.
==15122== Reachable blocks (those to which a pointer was found) are not shown.
==15122== To see them, rerun with: --show-reachable=yes
==15122== 
 
     ...Executing beam100_xz_test...
==15133== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15133== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15133== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15133== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15133== Estimated CPU clock rate is 2826 MHz
==15133== For more details, rerun with: -v
==15133== 
==15133== 
==15133== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15133== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==15133== malloc/free: 1569 allocs, 1557 frees, 974041 bytes allocated.
==15133== For counts of detected errors, rerun with: -v
==15133== searching for pointers to 12 not-freed blocks.
==15133== checked 7032880 bytes.
==15133== 
==15133== LEAK SUMMARY:
==15133==    definitely lost: 0 bytes in 0 blocks.
==15133==    possibly lost:   0 bytes in 0 blocks.
==15133==    still reachable: 13439 bytes in 12 blocks.
==15133==         suppressed: 0 bytes in 0 blocks.
==15133== Reachable blocks (those to which a pointer was found) are not shown.
==15133== To see them, rerun with: --show-reachable=yes
==15133== 
 
     ...Executing bstiffener_test...
==15147== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15147== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15147== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15147== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15147== Estimated CPU clock rate is 2800 MHz
==15147== For more details, rerun with: -v
==15147== 
==15147== 
==15147== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15147== malloc/free: in use at exit: 22665 bytes in 16 blocks.
==15147== malloc/free: 1468 allocs, 1452 frees, 1847084 bytes allocated.
==15147== For counts of detected errors, rerun with: -v
==15147== searching for pointers to 16 not-freed blocks.
==15147== checked 7046488 bytes.
==15147== 
==15147== LEAK SUMMARY:
==15147==    definitely lost: 0 bytes in 0 blocks.
==15147==    possibly lost:   0 bytes in 0 blocks.
==15147==    still reachable: 22665 bytes in 16 blocks.
==15147==         suppressed: 0 bytes in 0 blocks.
==15147== Reachable blocks (those to which a pointer was found) are not shown.
==15147== To see them, rerun with: --show-reachable=yes
==15147== 
 
     ...Executing cube4_test...
==15159== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15159== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15159== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15159== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15159== Estimated CPU clock rate is 2818 MHz
==15159== For more details, rerun with: -v
==15159== 
	--- Newton Method Parameters ---
	max_newton_iterations = 100
	num_newton_load_steps = 1
	            tolerance = 1e-06
	       update_tangent = 10000
==15159== 
==15159== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15159== malloc/free: in use at exit: 12969 bytes in 14 blocks.
==15159== malloc/free: 1171 allocs, 1157 frees, 101969 bytes allocated.
==15159== For counts of detected errors, rerun with: -v
==15159== searching for pointers to 14 not-freed blocks.
==15159== checked 7035740 bytes.
==15159== 
==15159== LEAK SUMMARY:
==15159==    definitely lost: 0 bytes in 0 blocks.
==15159==    possibly lost:   0 bytes in 0 blocks.
==15159==    still reachable: 12969 bytes in 14 blocks.
==15159==         suppressed: 0 bytes in 0 blocks.
==15159== Reachable blocks (those to which a pointer was found) are not shown.
==15159== To see them, rerun with: --show-reachable=yes
==15159== 
 
     ...Executing dash_test...
==15168== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15168== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15168== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15168== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15168== Estimated CPU clock rate is 2823 MHz
==15168== For more details, rerun with: -v
==15168== 
==15168== 
==15168== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15168== malloc/free: in use at exit: 17179 bytes in 22 blocks.
==15168== malloc/free: 1486 allocs, 1464 frees, 247670 bytes allocated.
==15168== For counts of detected errors, rerun with: -v
==15168== searching for pointers to 22 not-freed blocks.
==15168== checked 7033524 bytes.
==15168== 
==15168== LEAK SUMMARY:
==15168==    definitely lost: 0 bytes in 0 blocks.
==15168==    possibly lost:   0 bytes in 0 blocks.
==15168==    still reachable: 17179 bytes in 22 blocks.
==15168==         suppressed: 0 bytes in 0 blocks.
==15168== Reachable blocks (those to which a pointer was found) are not shown.
==15168== To see them, rerun with: --show-reachable=yes
==15168== 
 
     ...Executing eforce2_test...
==15177== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15177== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15177== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15177== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15177== Estimated CPU clock rate is 2806 MHz
==15177== For more details, rerun with: -v
==15177== 
==15177== 
==15177== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15177== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==15177== malloc/free: 1855 allocs, 1843 frees, 491992 bytes allocated.
==15177== For counts of detected errors, rerun with: -v
==15177== searching for pointers to 12 not-freed blocks.
==15177== checked 7030320 bytes.
==15177== 
==15177== LEAK SUMMARY:
==15177==    definitely lost: 0 bytes in 0 blocks.
==15177==    possibly lost:   0 bytes in 0 blocks.
==15177==    still reachable: 13439 bytes in 12 blocks.
==15177==         suppressed: 0 bytes in 0 blocks.
==15177== Reachable blocks (those to which a pointer was found) are not shown.
==15177== To see them, rerun with: --show-reachable=yes
==15177== 
 
     ...Executing eforce_test...
==15186== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15186== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15186== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15186== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15186== Estimated CPU clock rate is 2803 MHz
==15186== For more details, rerun with: -v
==15186== 
	--- Newton Method Parameters ---
	max_newton_iterations = 100
	num_newton_load_steps = 1
	            tolerance = 1e-06
	       update_tangent = 101
==15186== 
==15186== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15186== malloc/free: in use at exit: 12969 bytes in 14 blocks.
==15186== malloc/free: 1657 allocs, 1643 frees, 116561 bytes allocated.
==15186== For counts of detected errors, rerun with: -v
==15186== searching for pointers to 14 not-freed blocks.
==15186== checked 7031004 bytes.
==15186== 
==15186== LEAK SUMMARY:
==15186==    definitely lost: 0 bytes in 0 blocks.
==15186==    possibly lost:   0 bytes in 0 blocks.
==15186==    still reachable: 12969 bytes in 14 blocks.
==15186==         suppressed: 0 bytes in 0 blocks.
==15186== Reachable blocks (those to which a pointer was found) are not shown.
==15186== To see them, rerun with: --show-reachable=yes
==15186== 
 
     ...Executing gap2d_test...
==15196== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15196== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15196== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15196== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15196== Estimated CPU clock rate is 2826 MHz
==15196== For more details, rerun with: -v
==15196== 
==15196== 
==15196== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15196== malloc/free: in use at exit: 16916 bytes in 20 blocks.
==15196== malloc/free: 27955 allocs, 27935 frees, 2391743 bytes allocated.
==15196== For counts of detected errors, rerun with: -v
==15196== searching for pointers to 20 not-freed blocks.
==15196== checked 7037332 bytes.
==15196== 
==15196== LEAK SUMMARY:
==15196==    definitely lost: 0 bytes in 0 blocks.
==15196==    possibly lost:   0 bytes in 0 blocks.
==15196==    still reachable: 16916 bytes in 20 blocks.
==15196==         suppressed: 0 bytes in 0 blocks.
==15196== Reachable blocks (those to which a pointer was found) are not shown.
==15196== To see them, rerun with: --show-reachable=yes
==15196== 
 
     ...Executing gap2g_test...
==15211== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15211== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15211== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15211== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15211== Estimated CPU clock rate is 2811 MHz
==15211== For more details, rerun with: -v
==15211== 
	--- Newton Method Parameters ---
	max_newton_iterations = 1000
	num_newton_load_steps = 1
	            tolerance = 1e-06
	       update_tangent = 101
==15211== 
==15211== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15211== malloc/free: in use at exit: 12969 bytes in 14 blocks.
==15211== malloc/free: 5070 allocs, 5056 frees, 895891 bytes allocated.
==15211== For counts of detected errors, rerun with: -v
==15211== searching for pointers to 14 not-freed blocks.
==15211== checked 7034204 bytes.
==15211== 
==15211== LEAK SUMMARY:
==15211==    definitely lost: 0 bytes in 0 blocks.
==15211==    possibly lost:   0 bytes in 0 blocks.
==15211==    still reachable: 12969 bytes in 14 blocks.
==15211==         suppressed: 0 bytes in 0 blocks.
==15211== Reachable blocks (those to which a pointer was found) are not shown.
==15211== To see them, rerun with: --show-reachable=yes
==15211== 
 
     ...Executing gap_test...
==15220== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15220== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15220== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15220== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15220== Estimated CPU clock rate is 2800 MHz
==15220== For more details, rerun with: -v
==15220== 
	--- Newton Method Parameters ---
	max_newton_iterations = 1000
	num_newton_load_steps = 1
	            tolerance = 1e-06
	       update_tangent = 101
==15220== 
==15220== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15220== malloc/free: in use at exit: 12969 bytes in 14 blocks.
==15220== malloc/free: 1434 allocs, 1420 frees, 103426 bytes allocated.
==15220== For counts of detected errors, rerun with: -v
==15220== searching for pointers to 14 not-freed blocks.
==15220== checked 7035356 bytes.
==15220== 
==15220== LEAK SUMMARY:
==15220==    definitely lost: 0 bytes in 0 blocks.
==15220==    possibly lost:   0 bytes in 0 blocks.
==15220==    still reachable: 12969 bytes in 14 blocks.
==15220==         suppressed: 0 bytes in 0 blocks.
==15220== Reachable blocks (those to which a pointer was found) are not shown.
==15220== To see them, rerun with: --show-reachable=yes
==15220== 
 
     ...Executing gasdmp_test...
==15229== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15229== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15229== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15229== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15229== Estimated CPU clock rate is 2826 MHz
==15229== For more details, rerun with: -v
==15229== 
==15229== 
==15229== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15229== malloc/free: in use at exit: 17284 bytes in 20 blocks.
==15229== malloc/free: 3555 allocs, 3535 frees, 1006251 bytes allocated.
==15229== For counts of detected errors, rerun with: -v
==15229== searching for pointers to 20 not-freed blocks.
==15229== checked 7040816 bytes.
==15229== 
==15229== LEAK SUMMARY:
==15229==    definitely lost: 0 bytes in 0 blocks.
==15229==    possibly lost:   0 bytes in 0 blocks.
==15229==    still reachable: 17284 bytes in 20 blocks.
==15229==         suppressed: 0 bytes in 0 blocks.
==15229== Reachable blocks (those to which a pointer was found) are not shown.
==15229== To see them, rerun with: --show-reachable=yes
==15229== 
 
     ...Executing hys1_test...
==15238== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15238== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15238== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15238== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15238== Estimated CPU clock rate is 2827 MHz
==15238== For more details, rerun with: -v
==15238== 
==15238== 
==15238== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15238== malloc/free: in use at exit: 16916 bytes in 20 blocks.
==15238== malloc/free: 33966 allocs, 33946 frees, 2624648 bytes allocated.
==15238== For counts of detected errors, rerun with: -v
==15238== searching for pointers to 20 not-freed blocks.
==15238== checked 7037468 bytes.
==15238== 
==15238== LEAK SUMMARY:
==15238==    definitely lost: 0 bytes in 0 blocks.
==15238==    possibly lost:   0 bytes in 0 blocks.
==15238==    still reachable: 16916 bytes in 20 blocks.
==15238==         suppressed: 0 bytes in 0 blocks.
==15238== Reachable blocks (those to which a pointer was found) are not shown.
==15238== To see them, rerun with: --show-reachable=yes
==15238== 
 
     ...Executing nlbeam_test...
==15248== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15248== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15248== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15248== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15248== Estimated CPU clock rate is 2817 MHz
==15248== For more details, rerun with: -v
==15248== 
==15248== 
==15248== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15248== malloc/free: in use at exit: 16964 bytes in 20 blocks.
==15248== malloc/free: 6342 allocs, 6322 frees, 1460468 bytes allocated.
==15248== For counts of detected errors, rerun with: -v
==15248== searching for pointers to 20 not-freed blocks.
==15248== checked 7034736 bytes.
==15248== 
==15248== LEAK SUMMARY:
==15248==    definitely lost: 0 bytes in 0 blocks.
==15248==    possibly lost:   0 bytes in 0 blocks.
==15248==    still reachable: 16964 bytes in 20 blocks.
==15248==         suppressed: 0 bytes in 0 blocks.
==15248== Reachable blocks (those to which a pointer was found) are not shown.
==15248== To see them, rerun with: --show-reachable=yes
==15248== 
 
     ...Executing nldash_test...
==15259== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15259== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15259== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15259== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15259== Estimated CPU clock rate is 2805 MHz
==15259== For more details, rerun with: -v
==15259== 
==15259== Use of uninitialised value of size 8
==15259==    at 0x8129564: SumVector(double const *, int, int, double *) (writedisp.C:706)
==15259==    by 0x81296C1: PutSum(double const *, int, short, echo_flag) (writedisp.C:785)
==15259==    by 0x812890B: WriteNodal(int, double const *, int, double, echo_flag, short, int, HistBlock const *, bool) (writedisp.C:401)
==15259==    by 0x8128B0C: WriteNodal(int, double const *, int, double, echo_flag) (writedisp.C:441)
==15259== 
==15259== Syscall param write(buf) contains uninitialised or unaddressable byte(s)
==15259==    at 0x420DAE34: __libc_write (in /lib/i686/libc-2.2.5.so)
==15259==    by 0x8274B12: ncio_spx_rel (in /var/scratch3/gmreese/rel1.2/Salinas/salinas)
==15259==    by 0x827CD18: putNCvx_double_double (in /var/scratch3/gmreese/rel1.2/Salinas/salinas)
==15259==    by 0x827D39E: putNCv_double (in /var/scratch3/gmreese/rel1.2/Salinas/salinas)
==15259==    Address 0x4129FB78 is 8 bytes inside a block of size 4096 alloc'd
==15259==    at 0x40166BC0: malloc (vg_clientfuncs.c:103)
==15259==    by 0x8274E83: ncio_spx_init2 (in /var/scratch3/gmreese/rel1.2/Salinas/salinas)
==15259==    by 0x82751A2: ncio_create (in /var/scratch3/gmreese/rel1.2/Salinas/salinas)
==15259==    by 0x8273008: nc__create (in /var/scratch3/gmreese/rel1.2/Salinas/salinas)
==15259== 
==15259== ERROR SUMMARY: 330 errors from 2 contexts (suppressed: 0 from 0)
==15259== malloc/free: in use at exit: 17179 bytes in 22 blocks.
==15259== malloc/free: 2748 allocs, 2726 frees, 562244 bytes allocated.
==15259== For counts of detected errors, rerun with: -v
==15259== searching for pointers to 22 not-freed blocks.
==15259== checked 7037620 bytes.
==15259== 
==15259== LEAK SUMMARY:
==15259==    definitely lost: 0 bytes in 0 blocks.
==15259==    possibly lost:   0 bytes in 0 blocks.
==15259==    still reachable: 17179 bytes in 22 blocks.
==15259==         suppressed: 0 bytes in 0 blocks.
==15259== Reachable blocks (those to which a pointer was found) are not shown.
==15259== To see them, rerun with: --show-reachable=yes
==15259== 
 
     ...Executing nlrspring_test...
==15268== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15268== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15268== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15268== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15268== Estimated CPU clock rate is 2809 MHz
==15268== For more details, rerun with: -v
==15268== 
	--- Newton Method Parameters ---
	max_newton_iterations = 100
	num_newton_load_steps = 1
	            tolerance = 1e-06
	       update_tangent = 101
==15268== 
==15268== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15268== malloc/free: in use at exit: 12969 bytes in 14 blocks.
==15268== malloc/free: 1119 allocs, 1105 frees, 99679 bytes allocated.
==15268== For counts of detected errors, rerun with: -v
==15268== searching for pointers to 14 not-freed blocks.
==15268== checked 7033308 bytes.
==15268== 
==15268== LEAK SUMMARY:
==15268==    definitely lost: 0 bytes in 0 blocks.
==15268==    possibly lost:   0 bytes in 0 blocks.
==15268==    still reachable: 12969 bytes in 14 blocks.
==15268==         suppressed: 0 bytes in 0 blocks.
==15268== Reachable blocks (those to which a pointer was found) are not shown.
==15268== To see them, rerun with: --show-reachable=yes
==15268== 
 
     ...Executing ring1_test...
==15279== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15279== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15279== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15279== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15279== Estimated CPU clock rate is 2815 MHz
==15279== For more details, rerun with: -v
==15279== 
==15279== 
==15279== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15279== malloc/free: in use at exit: 15715 bytes in 18 blocks.
==15279== malloc/free: 1136 allocs, 1118 frees, 716042 bytes allocated.
==15279== For counts of detected errors, rerun with: -v
==15279== searching for pointers to 18 not-freed blocks.
==15279== checked 7037460 bytes.
==15279== 
==15279== LEAK SUMMARY:
==15279==    definitely lost: 0 bytes in 0 blocks.
==15279==    possibly lost:   0 bytes in 0 blocks.
==15279==    still reachable: 15715 bytes in 18 blocks.
==15279==         suppressed: 0 bytes in 0 blocks.
==15279== Reachable blocks (those to which a pointer was found) are not shown.
==15279== To see them, rerun with: --show-reachable=yes
==15279== 
 
     ...Executing rspring_test...
==15288== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15288== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15288== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15288== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15288== Estimated CPU clock rate is 2803 MHz
==15288== For more details, rerun with: -v
==15288== 
==15288== 
==15288== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15288== malloc/free: in use at exit: 12969 bytes in 14 blocks.
==15288== malloc/free: 1032 allocs, 1018 frees, 83021 bytes allocated.
==15288== For counts of detected errors, rerun with: -v
==15288== searching for pointers to 14 not-freed blocks.
==15288== checked 7037784 bytes.
==15288== 
==15288== LEAK SUMMARY:
==15288==    definitely lost: 0 bytes in 0 blocks.
==15288==    possibly lost:   0 bytes in 0 blocks.
==15288==    still reachable: 12969 bytes in 14 blocks.
==15288==         suppressed: 0 bytes in 0 blocks.
==15288== Reachable blocks (those to which a pointer was found) are not shown.
==15288== To see them, rerun with: --show-reachable=yes
==15288== 
 
     ...Executing shys1_test...
==15299== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15299== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15299== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15299== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15299== Estimated CPU clock rate is 2804 MHz
==15299== For more details, rerun with: -v
==15299== 
==15299== 
==15299== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15299== malloc/free: in use at exit: 16964 bytes in 20 blocks.
==15299== malloc/free: 23222 allocs, 23202 frees, 3245597 bytes allocated.
==15299== For counts of detected errors, rerun with: -v
==15299== searching for pointers to 20 not-freed blocks.
==15299== checked 7033284 bytes.
==15299== 
==15299== LEAK SUMMARY:
==15299==    definitely lost: 0 bytes in 0 blocks.
==15299==    possibly lost:   0 bytes in 0 blocks.
==15299==    still reachable: 16964 bytes in 20 blocks.
==15299==         suppressed: 0 bytes in 0 blocks.
==15299== Reachable blocks (those to which a pointer was found) are not shown.
==15299== To see them, rerun with: --show-reachable=yes
==15299== 
 
     ...Executing small2g_test...
==15310== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15310== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15310== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15310== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15310== Estimated CPU clock rate is 2795 MHz
==15310== For more details, rerun with: -v
==15310== 
==15310== 
==15310== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15310== malloc/free: in use at exit: 16916 bytes in 20 blocks.
==15310== malloc/free: 17608 allocs, 17588 frees, 1609280 bytes allocated.
==15310== For counts of detected errors, rerun with: -v
==15310== searching for pointers to 20 not-freed blocks.
==15310== checked 7037332 bytes.
==15310== 
==15310== LEAK SUMMARY:
==15310==    definitely lost: 0 bytes in 0 blocks.
==15310==    possibly lost:   0 bytes in 0 blocks.
==15310==    still reachable: 16916 bytes in 20 blocks.
==15310==         suppressed: 0 bytes in 0 blocks.
==15310== Reachable blocks (those to which a pointer was found) are not shown.
==15310== To see them, rerun with: --show-reachable=yes
==15310== 
 
     ...Executing tblchk_test...
==15334== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15334== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15334== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15334== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15334== Estimated CPU clock rate is 2821 MHz
==15334== For more details, rerun with: -v
==15334== 
==15334== 
==15334== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15334== malloc/free: in use at exit: 16916 bytes in 20 blocks.
==15334== malloc/free: 1441 allocs, 1421 frees, 122556 bytes allocated.
==15334== For counts of detected errors, rerun with: -v
==15334== searching for pointers to 20 not-freed blocks.
==15334== checked 7041564 bytes.
==15334== 
==15334== LEAK SUMMARY:
==15334==    definitely lost: 0 bytes in 0 blocks.
==15334==    possibly lost:   0 bytes in 0 blocks.
==15334==    still reachable: 16916 bytes in 20 blocks.
==15334==         suppressed: 0 bytes in 0 blocks.
==15334== Reachable blocks (those to which a pointer was found) are not shown.
==15334== To see them, rerun with: --show-reachable=yes
==15334== 
 
     ...Executing directFRF1_test...
==15346== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15346== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15346== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15346== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15346== Estimated CPU clock rate is 2797 MHz
==15346== For more details, rerun with: -v
==15346== 
==15346== 
==15346== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15346== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==15346== malloc/free: 1860 allocs, 1840 frees, 184822866 bytes allocated.
==15346== For counts of detected errors, rerun with: -v
==15346== searching for pointers to 20 not-freed blocks.
==15346== checked 7063516 bytes.
==15346== 
==15346== LEAK SUMMARY:
==15346==    definitely lost: 0 bytes in 0 blocks.
==15346==    possibly lost:   0 bytes in 0 blocks.
==15346==    still reachable: 41393 bytes in 20 blocks.
==15346==         suppressed: 0 bytes in 0 blocks.
==15346== Reachable blocks (those to which a pointer was found) are not shown.
==15346== To see them, rerun with: --show-reachable=yes
==15346== 
 
     ...Executing directFRF2_imag_test...
==15371== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15371== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15371== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15371== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15371== Estimated CPU clock rate is 2831 MHz
==15371== For more details, rerun with: -v
==15371== 
==15371== 
==15371== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15371== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==15371== malloc/free: 3598 allocs, 3578 frees, 217455047 bytes allocated.
==15371== For counts of detected errors, rerun with: -v
==15371== searching for pointers to 20 not-freed blocks.
==15371== checked 7058540 bytes.
==15371== 
==15371== LEAK SUMMARY:
==15371==    definitely lost: 0 bytes in 0 blocks.
==15371==    possibly lost:   0 bytes in 0 blocks.
==15371==    still reachable: 41393 bytes in 20 blocks.
==15371==         suppressed: 0 bytes in 0 blocks.
==15371== Reachable blocks (those to which a pointer was found) are not shown.
==15371== To see them, rerun with: --show-reachable=yes
==15371== 
 
     ...Executing directFRF2_test...
==15388== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15388== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15388== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15388== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15388== Estimated CPU clock rate is 2813 MHz
==15388== For more details, rerun with: -v
==15388== 
==15388== 
==15388== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15388== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==15388== malloc/free: 3598 allocs, 3578 frees, 217455046 bytes allocated.
==15388== For counts of detected errors, rerun with: -v
==15388== searching for pointers to 20 not-freed blocks.
==15388== checked 7060700 bytes.
==15388== 
==15388== LEAK SUMMARY:
==15388==    definitely lost: 0 bytes in 0 blocks.
==15388==    possibly lost:   0 bytes in 0 blocks.
==15388==    still reachable: 41393 bytes in 20 blocks.
==15388==         suppressed: 0 bytes in 0 blocks.
==15388== Reachable blocks (those to which a pointer was found) are not shown.
==15388== To see them, rerun with: --show-reachable=yes
==15388== 
 
     ...Executing directFRF3_test...
==15431== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15431== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15431== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15431== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15431== Estimated CPU clock rate is 2828 MHz
==15431== For more details, rerun with: -v
==15431== 
==15431== 
==15431== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15431== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==15431== malloc/free: 3598 allocs, 3578 frees, 217455050 bytes allocated.
==15431== For counts of detected errors, rerun with: -v
==15431== searching for pointers to 20 not-freed blocks.
==15431== checked 7058012 bytes.
==15431== 
==15431== LEAK SUMMARY:
==15431==    definitely lost: 0 bytes in 0 blocks.
==15431==    possibly lost:   0 bytes in 0 blocks.
==15431==    still reachable: 41393 bytes in 20 blocks.
==15431==         suppressed: 0 bytes in 0 blocks.
==15431== Reachable blocks (those to which a pointer was found) are not shown.
==15431== To see them, rerun with: --show-reachable=yes
==15431== 
 
     ...Executing directFRF4_test...
==15449== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15449== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15449== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15449== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15449== Estimated CPU clock rate is 2821 MHz
==15449== For more details, rerun with: -v
==15449== 
==15449== 
==15449== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15449== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==15449== malloc/free: 7653 allocs, 7633 frees, 1652347759 bytes allocated.
==15449== For counts of detected errors, rerun with: -v
==15449== searching for pointers to 20 not-freed blocks.
==15449== checked 7060316 bytes.
==15449== 
==15449== LEAK SUMMARY:
==15449==    definitely lost: 0 bytes in 0 blocks.
==15449==    possibly lost:   0 bytes in 0 blocks.
==15449==    still reachable: 41393 bytes in 20 blocks.
==15449==         suppressed: 0 bytes in 0 blocks.
==15449== Reachable blocks (those to which a pointer was found) are not shown.
==15449== To see them, rerun with: --show-reachable=yes
==15449== 
 
     ...Executing dead1_test...
==15530== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15530== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15530== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15530== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15530== Estimated CPU clock rate is 2792 MHz
==15530== For more details, rerun with: -v
==15530== 
==15530== 
==15530== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15530== malloc/free: in use at exit: 17943 bytes in 20 blocks.
==15530== malloc/free: 1232 allocs, 1212 frees, 741825 bytes allocated.
==15530== For counts of detected errors, rerun with: -v
==15530== searching for pointers to 20 not-freed blocks.
==15530== checked 7039044 bytes.
==15530== 
==15530== LEAK SUMMARY:
==15530==    definitely lost: 0 bytes in 0 blocks.
==15530==    possibly lost:   0 bytes in 0 blocks.
==15530==    still reachable: 17943 bytes in 20 blocks.
==15530==         suppressed: 0 bytes in 0 blocks.
==15530== Reachable blocks (those to which a pointer was found) are not shown.
==15530== To see them, rerun with: --show-reachable=yes
==15530== 
 
     ...Executing dead2_test...
==15541== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15541== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15541== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15541== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15541== Estimated CPU clock rate is 2809 MHz
==15541== For more details, rerun with: -v
==15541== 
==15541== 
==15541== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15541== malloc/free: in use at exit: 17943 bytes in 20 blocks.
==15541== malloc/free: 1354 allocs, 1334 frees, 983872 bytes allocated.
==15541== For counts of detected errors, rerun with: -v
==15541== searching for pointers to 20 not-freed blocks.
==15541== checked 7040452 bytes.
==15541== 
==15541== LEAK SUMMARY:
==15541==    definitely lost: 0 bytes in 0 blocks.
==15541==    possibly lost:   0 bytes in 0 blocks.
==15541==    still reachable: 17943 bytes in 20 blocks.
==15541==         suppressed: 0 bytes in 0 blocks.
==15541== Reachable blocks (those to which a pointer was found) are not shown.
==15541== To see them, rerun with: --show-reachable=yes
==15541== 
 
     ...Executing hex20_sideset_test...
==15552== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15552== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15552== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15552== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15552== Estimated CPU clock rate is 2797 MHz
==15552== For more details, rerun with: -v
==15552== 
==15552== 
==15552== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15552== malloc/free: in use at exit: 21279 bytes in 12 blocks.
==15552== malloc/free: 2248 allocs, 2236 frees, 39732787 bytes allocated.
==15552== For counts of detected errors, rerun with: -v
==15552== searching for pointers to 12 not-freed blocks.
==15552== checked 7037008 bytes.
==15552== 
==15552== LEAK SUMMARY:
==15552==    definitely lost: 0 bytes in 0 blocks.
==15552==    possibly lost:   0 bytes in 0 blocks.
==15552==    still reachable: 21279 bytes in 12 blocks.
==15552==         suppressed: 0 bytes in 0 blocks.
==15552== Reachable blocks (those to which a pointer was found) are not shown.
==15552== To see them, rerun with: --show-reachable=yes
==15552== 
 
     ...Executing hex20_small_rot2_test...
==15745== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15745== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15745== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15745== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15745== Estimated CPU clock rate is 2799 MHz
==15745== For more details, rerun with: -v
==15745== 
==15745== 
==15745== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15745== malloc/free: in use at exit: 18167 bytes in 16 blocks.
==15745== malloc/free: 1123 allocs, 1107 frees, 2372244 bytes allocated.
==15745== For counts of detected errors, rerun with: -v
==15745== searching for pointers to 16 not-freed blocks.
==15745== checked 7034040 bytes.
==15745== 
==15745== LEAK SUMMARY:
==15745==    definitely lost: 0 bytes in 0 blocks.
==15745==    possibly lost:   0 bytes in 0 blocks.
==15745==    still reachable: 18167 bytes in 16 blocks.
==15745==         suppressed: 0 bytes in 0 blocks.
==15745== Reachable blocks (those to which a pointer was found) are not shown.
==15745== To see them, rerun with: --show-reachable=yes
==15745== 
 
     ...Executing hex8_small_eigen_test...
==15761== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15761== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15761== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15761== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15761== Estimated CPU clock rate is 2825 MHz
==15761== For more details, rerun with: -v
==15761== 
==15761== 
==15761== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15761== malloc/free: in use at exit: 15251 bytes in 16 blocks.
==15761== malloc/free: 1033 allocs, 1017 frees, 880664 bytes allocated.
==15761== For counts of detected errors, rerun with: -v
==15761== searching for pointers to 16 not-freed blocks.
==15761== checked 7033172 bytes.
==15761== 
==15761== LEAK SUMMARY:
==15761==    definitely lost: 0 bytes in 0 blocks.
==15761==    possibly lost:   0 bytes in 0 blocks.
==15761==    still reachable: 15251 bytes in 16 blocks.
==15761==         suppressed: 0 bytes in 0 blocks.
==15761== Reachable blocks (those to which a pointer was found) are not shown.
==15761== To see them, rerun with: --show-reachable=yes
==15761== 
 
     ...Executing hex8_small_statics_test...
==15774== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15774== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15774== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15774== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15774== Estimated CPU clock rate is 2807 MHz
==15774== For more details, rerun with: -v
==15774== 
==15774== 
==15774== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15774== malloc/free: in use at exit: 12900 bytes in 12 blocks.
==15774== malloc/free: 1103 allocs, 1091 frees, 295588 bytes allocated.
==15774== For counts of detected errors, rerun with: -v
==15774== searching for pointers to 12 not-freed blocks.
==15774== checked 7032488 bytes.
==15774== 
==15774== LEAK SUMMARY:
==15774==    definitely lost: 0 bytes in 0 blocks.
==15774==    possibly lost:   0 bytes in 0 blocks.
==15774==    still reachable: 12900 bytes in 12 blocks.
==15774==         suppressed: 0 bytes in 0 blocks.
==15774== Reachable blocks (those to which a pointer was found) are not shown.
==15774== To see them, rerun with: --show-reachable=yes
==15774== 
 
     ...Executing hex_sub_eigen_test...
==15788== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15788== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15788== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15788== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15788== Estimated CPU clock rate is 2792 MHz
==15788== For more details, rerun with: -v
==15788== 
==15788== 
==15788== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15788== malloc/free: in use at exit: 16745 bytes in 16 blocks.
==15788== malloc/free: 938 allocs, 922 frees, 702770 bytes allocated.
==15788== For counts of detected errors, rerun with: -v
==15788== searching for pointers to 16 not-freed blocks.
==15788== checked 7038104 bytes.
==15788== 
==15788== LEAK SUMMARY:
==15788==    definitely lost: 0 bytes in 0 blocks.
==15788==    possibly lost:   0 bytes in 0 blocks.
==15788==    still reachable: 16745 bytes in 16 blocks.
==15788==         suppressed: 0 bytes in 0 blocks.
==15788== Reachable blocks (those to which a pointer was found) are not shown.
==15788== To see them, rerun with: --show-reachable=yes
==15788== 
 
     ...Executing hexplateMpc_test...
==15797== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15797== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15797== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15797== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15797== Estimated CPU clock rate is 2805 MHz
==15797== For more details, rerun with: -v
==15797== 
==15797== 
==15797== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15797== malloc/free: in use at exit: 16745 bytes in 16 blocks.
==15797== malloc/free: 1392 allocs, 1376 frees, 1488418 bytes allocated.
==15797== For counts of detected errors, rerun with: -v
==15797== searching for pointers to 16 not-freed blocks.
==15797== checked 7039256 bytes.
==15797== 
==15797== LEAK SUMMARY:
==15797==    definitely lost: 0 bytes in 0 blocks.
==15797==    possibly lost:   0 bytes in 0 blocks.
==15797==    still reachable: 16745 bytes in 16 blocks.
==15797==         suppressed: 0 bytes in 0 blocks.
==15797== Reachable blocks (those to which a pointer was found) are not shown.
==15797== To see them, rerun with: --show-reachable=yes
==15797== 
 
     ...Executing hexplate_1_test...
==15808== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15808== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15808== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15808== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15808== Estimated CPU clock rate is 2824 MHz
==15808== For more details, rerun with: -v
==15808== 
==15808== 
==15808== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15808== malloc/free: in use at exit: 16745 bytes in 16 blocks.
==15808== malloc/free: 1535 allocs, 1519 frees, 1645443 bytes allocated.
==15808== For counts of detected errors, rerun with: -v
==15808== searching for pointers to 16 not-freed blocks.
==15808== checked 7032472 bytes.
==15808== 
==15808== LEAK SUMMARY:
==15808==    definitely lost: 0 bytes in 0 blocks.
==15808==    possibly lost:   0 bytes in 0 blocks.
==15808==    still reachable: 16745 bytes in 16 blocks.
==15808==         suppressed: 0 bytes in 0 blocks.
==15808== Reachable blocks (those to which a pointer was found) are not shown.
==15808== To see them, rerun with: --show-reachable=yes
==15808== 
 
     ...Executing hexplate_free_test...
==15833== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15833== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15833== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15833== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15833== Estimated CPU clock rate is 2807 MHz
==15833== For more details, rerun with: -v
==15833== 
==15833== 
==15833== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15833== malloc/free: in use at exit: 16745 bytes in 16 blocks.
==15833== malloc/free: 1016 allocs, 1000 frees, 1290789 bytes allocated.
==15833== For counts of detected errors, rerun with: -v
==15833== searching for pointers to 16 not-freed blocks.
==15833== checked 7035672 bytes.
==15833== 
==15833== LEAK SUMMARY:
==15833==    definitely lost: 0 bytes in 0 blocks.
==15833==    possibly lost:   0 bytes in 0 blocks.
==15833==    still reachable: 16745 bytes in 16 blocks.
==15833==         suppressed: 0 bytes in 0 blocks.
==15833== Reachable blocks (those to which a pointer was found) are not shown.
==15833== To see them, rerun with: --show-reachable=yes
==15833== 
 
     ...Executing hexplate_list_test...
==15843== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15843== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15843== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15843== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15843== Estimated CPU clock rate is 2801 MHz
==15843== For more details, rerun with: -v
==15843== 
==15843== 
==15843== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15843== malloc/free: in use at exit: 16745 bytes in 16 blocks.
==15843== malloc/free: 1099 allocs, 1083 frees, 1331702 bytes allocated.
==15843== For counts of detected errors, rerun with: -v
==15843== searching for pointers to 16 not-freed blocks.
==15843== checked 7036952 bytes.
==15843== 
==15843== LEAK SUMMARY:
==15843==    definitely lost: 0 bytes in 0 blocks.
==15843==    possibly lost:   0 bytes in 0 blocks.
==15843==    still reachable: 16745 bytes in 16 blocks.
==15843==         suppressed: 0 bytes in 0 blocks.
==15843== Reachable blocks (those to which a pointer was found) are not shown.
==15843== To see them, rerun with: --show-reachable=yes
==15843== 
 
     ...Executing hexplate_multi_eigen_test...
==15854== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15854== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15854== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15854== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15854== Estimated CPU clock rate is 2791 MHz
==15854== For more details, rerun with: -v
==15854== 
==15854== 
==15854== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15854== malloc/free: in use at exit: 15505 bytes in 16 blocks.
==15854== malloc/free: 1190 allocs, 1174 frees, 1023154 bytes allocated.
==15854== For counts of detected errors, rerun with: -v
==15854== searching for pointers to 16 not-freed blocks.
==15854== checked 7037136 bytes.
==15854== 
==15854== LEAK SUMMARY:
==15854==    definitely lost: 0 bytes in 0 blocks.
==15854==    possibly lost:   0 bytes in 0 blocks.
==15854==    still reachable: 15505 bytes in 16 blocks.
==15854==         suppressed: 0 bytes in 0 blocks.
==15854== Reachable blocks (those to which a pointer was found) are not shown.
==15854== To see them, rerun with: --show-reachable=yes
==15854== 
 
     ...Executing hexplate_multi_test...
==15865== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15865== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15865== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15865== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15865== Estimated CPU clock rate is 2791 MHz
==15865== For more details, rerun with: -v
==15865== 
==15865== 
==15865== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15865== malloc/free: in use at exit: 13082 bytes in 12 blocks.
==15865== malloc/free: 928 allocs, 916 frees, 315485 bytes allocated.
==15865== For counts of detected errors, rerun with: -v
==15865== searching for pointers to 12 not-freed blocks.
==15865== checked 7036108 bytes.
==15865== 
==15865== LEAK SUMMARY:
==15865==    definitely lost: 0 bytes in 0 blocks.
==15865==    possibly lost:   0 bytes in 0 blocks.
==15865==    still reachable: 13082 bytes in 12 blocks.
==15865==         suppressed: 0 bytes in 0 blocks.
==15865== Reachable blocks (those to which a pointer was found) are not shown.
==15865== To see them, rerun with: --show-reachable=yes
==15865== 
 
     ...Executing hexplate_test...
==15876== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15876== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15876== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15876== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15876== Estimated CPU clock rate is 2830 MHz
==15876== For more details, rerun with: -v
==15876== 
==15876== 
==15876== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15876== malloc/free: in use at exit: 16745 bytes in 16 blocks.
==15876== malloc/free: 1535 allocs, 1519 frees, 1645443 bytes allocated.
==15876== For counts of detected errors, rerun with: -v
==15876== searching for pointers to 16 not-freed blocks.
==15876== checked 7032984 bytes.
==15876== 
==15876== LEAK SUMMARY:
==15876==    definitely lost: 0 bytes in 0 blocks.
==15876==    possibly lost:   0 bytes in 0 blocks.
==15876==    still reachable: 16745 bytes in 16 blocks.
==15876==         suppressed: 0 bytes in 0 blocks.
==15876== Reachable blocks (those to which a pointer was found) are not shown.
==15876== To see them, rerun with: --show-reachable=yes
==15876== 
 
     ...Executing hexplatemulti_test...
==15890== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15890== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15890== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15890== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15890== Estimated CPU clock rate is 2814 MHz
==15890== For more details, rerun with: -v
==15890== 
==15890== 
==15890== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15890== malloc/free: in use at exit: 16745 bytes in 16 blocks.
==15890== malloc/free: 1082 allocs, 1066 frees, 1285961 bytes allocated.
==15890== For counts of detected errors, rerun with: -v
==15890== searching for pointers to 16 not-freed blocks.
==15890== checked 7034776 bytes.
==15890== 
==15890== LEAK SUMMARY:
==15890==    definitely lost: 0 bytes in 0 blocks.
==15890==    possibly lost:   0 bytes in 0 blocks.
==15890==    still reachable: 16745 bytes in 16 blocks.
==15890==         suppressed: 0 bytes in 0 blocks.
==15890== Reachable blocks (those to which a pointer was found) are not shown.
==15890== To see them, rerun with: --show-reachable=yes
==15890== 
 
     ...Executing hexshell_ex1_test...
==15903== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15903== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15903== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15903== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15903== Estimated CPU clock rate is 2792 MHz
==15903== For more details, rerun with: -v
==15903== 
==15903== 
==15903== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15903== malloc/free: in use at exit: 15107 bytes in 18 blocks.
==15903== malloc/free: 897 allocs, 879 frees, 681394 bytes allocated.
==15903== For counts of detected errors, rerun with: -v
==15903== searching for pointers to 18 not-freed blocks.
==15903== checked 7034804 bytes.
==15903== 
==15903== LEAK SUMMARY:
==15903==    definitely lost: 0 bytes in 0 blocks.
==15903==    possibly lost:   0 bytes in 0 blocks.
==15903==    still reachable: 15107 bytes in 18 blocks.
==15903==         suppressed: 0 bytes in 0 blocks.
==15903== Reachable blocks (those to which a pointer was found) are not shown.
==15903== To see them, rerun with: --show-reachable=yes
==15903== 
 
     ...Executing mult-loads-th_test...
==15920== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15920== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15920== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15920== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15920== Estimated CPU clock rate is 2800 MHz
==15920== For more details, rerun with: -v
==15920== 
==15920== 
==15920== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15920== malloc/free: in use at exit: 17768 bytes in 16 blocks.
==15920== malloc/free: 2270 allocs, 2254 frees, 1173966 bytes allocated.
==15920== For counts of detected errors, rerun with: -v
==15920== searching for pointers to 16 not-freed blocks.
==15920== checked 7039640 bytes.
==15920== 
==15920== LEAK SUMMARY:
==15920==    definitely lost: 0 bytes in 0 blocks.
==15920==    possibly lost:   0 bytes in 0 blocks.
==15920==    still reachable: 17768 bytes in 16 blocks.
==15920==         suppressed: 0 bytes in 0 blocks.
==15920== Reachable blocks (those to which a pointer was found) are not shown.
==15920== To see them, rerun with: --show-reachable=yes
==15920== 
 
     ...Executing mult-loads-time_test...
==15932== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15932== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15932== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15932== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15932== Estimated CPU clock rate is 2823 MHz
==15932== For more details, rerun with: -v
==15932== 
==15932== 
==15932== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15932== malloc/free: in use at exit: 17768 bytes in 16 blocks.
==15932== malloc/free: 1203 allocs, 1187 frees, 1075738 bytes allocated.
==15932== For counts of detected errors, rerun with: -v
==15932== searching for pointers to 16 not-freed blocks.
==15932== checked 7041176 bytes.
==15932== 
==15932== LEAK SUMMARY:
==15932==    definitely lost: 0 bytes in 0 blocks.
==15932==    possibly lost:   0 bytes in 0 blocks.
==15932==    still reachable: 17768 bytes in 16 blocks.
==15932==         suppressed: 0 bytes in 0 blocks.
==15932== Reachable blocks (those to which a pointer was found) are not shown.
==15932== To see them, rerun with: --show-reachable=yes
==15932== 
 
     ...Executing nltrans_test...
==15946== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15946== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15946== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15946== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15946== Estimated CPU clock rate is 2817 MHz
==15946== For more details, rerun with: -v
==15946== 
==15946== 
==15946== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15946== malloc/free: in use at exit: 22367 bytes in 20 blocks.
==15946== malloc/free: 2656 allocs, 2636 frees, 7337769 bytes allocated.
==15946== For counts of detected errors, rerun with: -v
==15946== searching for pointers to 20 not-freed blocks.
==15946== checked 7039372 bytes.
==15946== 
==15946== LEAK SUMMARY:
==15946==    definitely lost: 0 bytes in 0 blocks.
==15946==    possibly lost:   0 bytes in 0 blocks.
==15946==    still reachable: 22367 bytes in 20 blocks.
==15946==         suppressed: 0 bytes in 0 blocks.
==15946== Reachable blocks (those to which a pointer was found) are not shown.
==15946== To see them, rerun with: --show-reachable=yes
==15946== 
 
     ...Executing output_coord2_test...
==15957== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15957== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15957== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15957== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15957== Estimated CPU clock rate is 2810 MHz
==15957== For more details, rerun with: -v
==15957== 
==15957== 
==15957== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15957== malloc/free: in use at exit: 13333 bytes in 14 blocks.
==15957== malloc/free: 2551 allocs, 2537 frees, 1758378 bytes allocated.
==15957== For counts of detected errors, rerun with: -v
==15957== searching for pointers to 14 not-freed blocks.
==15957== checked 7031752 bytes.
==15957== 
==15957== LEAK SUMMARY:
==15957==    definitely lost: 0 bytes in 0 blocks.
==15957==    possibly lost:   0 bytes in 0 blocks.
==15957==    still reachable: 13333 bytes in 14 blocks.
==15957==         suppressed: 0 bytes in 0 blocks.
==15957== Reachable blocks (those to which a pointer was found) are not shown.
==15957== To see them, rerun with: --show-reachable=yes
==15957== 
 
     ...Executing output_coord4_test...
==15968== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15968== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15968== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15968== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15968== Estimated CPU clock rate is 2831 MHz
==15968== For more details, rerun with: -v
==15968== 
==15968== 
==15968== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15968== malloc/free: in use at exit: 13333 bytes in 14 blocks.
==15968== malloc/free: 2440 allocs, 2426 frees, 1755573 bytes allocated.
==15968== For counts of detected errors, rerun with: -v
==15968== searching for pointers to 14 not-freed blocks.
==15968== checked 7033160 bytes.
==15968== 
==15968== LEAK SUMMARY:
==15968==    definitely lost: 0 bytes in 0 blocks.
==15968==    possibly lost:   0 bytes in 0 blocks.
==15968==    still reachable: 13333 bytes in 14 blocks.
==15968==         suppressed: 0 bytes in 0 blocks.
==15968== Reachable blocks (those to which a pointer was found) are not shown.
==15968== To see them, rerun with: --show-reachable=yes
==15968== 
 
     ...Executing output_coord_test...
==15981== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15981== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15981== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15981== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15981== Estimated CPU clock rate is 2793 MHz
==15981== For more details, rerun with: -v
==15981== 
==15981== 
==15981== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15981== malloc/free: in use at exit: 17928 bytes in 18 blocks.
==15981== malloc/free: 3822 allocs, 3804 frees, 1641835 bytes allocated.
==15981== For counts of detected errors, rerun with: -v
==15981== searching for pointers to 18 not-freed blocks.
==15981== checked 7039416 bytes.
==15981== 
==15981== LEAK SUMMARY:
==15981==    definitely lost: 0 bytes in 0 blocks.
==15981==    possibly lost:   0 bytes in 0 blocks.
==15981==    still reachable: 17928 bytes in 18 blocks.
==15981==         suppressed: 0 bytes in 0 blocks.
==15981== Reachable blocks (those to which a pointer was found) are not shown.
==15981== To see them, rerun with: --show-reachable=yes
==15981== 
 
     ...Executing hex_pure_bend_static_test...
==15996== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==15996== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==15996== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==15996== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==15996== Estimated CPU clock rate is 2827 MHz
==15996== For more details, rerun with: -v
==15996== 
==15996== 
==15996== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==15996== malloc/free: in use at exit: 49626 bytes in 494 blocks.
==15996== malloc/free: 4290 allocs, 3796 frees, 648837 bytes allocated.
==15996== For counts of detected errors, rerun with: -v
==15996== searching for pointers to 494 not-freed blocks.
==15996== checked 7064556 bytes.
==15996== 
==15996== LEAK SUMMARY:
==15996==    definitely lost: 0 bytes in 0 blocks.
==15996==    possibly lost:   0 bytes in 0 blocks.
==15996==    still reachable: 49626 bytes in 494 blocks.
==15996==         suppressed: 0 bytes in 0 blocks.
==15996== Reachable blocks (those to which a pointer was found) are not shown.
==15996== To see them, rerun with: --show-reachable=yes
==15996== 
 
     ...Executing eigsens_test...
==16005== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16005== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16005== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16005== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16005== Estimated CPU clock rate is 2815 MHz
==16005== For more details, rerun with: -v
==16005== 
Recommended shift value is -1. Using -100000
==16005== 
==16005== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16005== malloc/free: in use at exit: 104130 bytes in 18 blocks.
==16005== malloc/free: 1975 allocs, 1957 frees, 16645645 bytes allocated.
==16005== For counts of detected errors, rerun with: -v
==16005== searching for pointers to 18 not-freed blocks.
==16005== checked 7123088 bytes.
==16005== 
==16005== LEAK SUMMARY:
==16005==    definitely lost: 0 bytes in 0 blocks.
==16005==    possibly lost:   0 bytes in 0 blocks.
==16005==    still reachable: 104130 bytes in 18 blocks.
==16005==         suppressed: 0 bytes in 0 blocks.
==16005== Reachable blocks (those to which a pointer was found) are not shown.
==16005== To see them, rerun with: --show-reachable=yes
==16005== 
 
     ...Executing fixed_rbe3_test...
==16018== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16018== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16018== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16018== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16018== Estimated CPU clock rate is 2825 MHz
==16018== For more details, rerun with: -v
==16018== 
Recommended shift value is -1. Using -100000
==16018== 
==16018== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16018== malloc/free: in use at exit: 104130 bytes in 18 blocks.
==16018== malloc/free: 1906 allocs, 1888 frees, 16170606 bytes allocated.
==16018== For counts of detected errors, rerun with: -v
==16018== searching for pointers to 18 not-freed blocks.
==16018== checked 7124768 bytes.
==16018== 
==16018== LEAK SUMMARY:
==16018==    definitely lost: 0 bytes in 0 blocks.
==16018==    possibly lost:   0 bytes in 0 blocks.
==16018==    still reachable: 104130 bytes in 18 blocks.
==16018==         suppressed: 0 bytes in 0 blocks.
==16018== Reachable blocks (those to which a pointer was found) are not shown.
==16018== To see them, rerun with: --show-reachable=yes
==16018== 
 
     ...Executing hexrms_bis_test...
==16037== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16037== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16037== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16037== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16037== Estimated CPU clock rate is 2820 MHz
==16037== For more details, rerun with: -v
==16037== 
Recommended shift value is -1. Using -100000
Implicitly restarting eigen. Step=1
==16037== 
==16037== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16037== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16037== malloc/free: 3141 allocs, 3125 frees, 3579061 bytes allocated.
==16037== For counts of detected errors, rerun with: -v
==16037== searching for pointers to 16 not-freed blocks.
==16037== checked 7048204 bytes.
==16037== 
==16037== LEAK SUMMARY:
==16037==    definitely lost: 0 bytes in 0 blocks.
==16037==    possibly lost:   0 bytes in 0 blocks.
==16037==    still reachable: 27726 bytes in 16 blocks.
==16037==         suppressed: 0 bytes in 0 blocks.
==16037== Reachable blocks (those to which a pointer was found) are not shown.
==16037== To see them, rerun with: --show-reachable=yes
==16037== 
 
     ...Executing hexrms_test...
==16050== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16050== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16050== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16050== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16050== Estimated CPU clock rate is 2813 MHz
==16050== For more details, rerun with: -v
==16050== 
Recommended shift value is -1. Using -100000
==16050== 
==16050== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16050== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16050== malloc/free: 2386 allocs, 2370 frees, 4317035 bytes allocated.
==16050== For counts of detected errors, rerun with: -v
==16050== searching for pointers to 16 not-freed blocks.
==16050== checked 7049852 bytes.
==16050== 
==16050== LEAK SUMMARY:
==16050==    definitely lost: 0 bytes in 0 blocks.
==16050==    possibly lost:   0 bytes in 0 blocks.
==16050==    still reachable: 27726 bytes in 16 blocks.
==16050==         suppressed: 0 bytes in 0 blocks.
==16050== Reachable blocks (those to which a pointer was found) are not shown.
==16050== To see them, rerun with: --show-reachable=yes
==16050== 
 
     ...Executing modalFRF2_test...
==16063== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16063== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16063== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16063== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16063== Estimated CPU clock rate is 2832 MHz
==16063== For more details, rerun with: -v
==16063== 
Solution step 'junk', checkout is skipped in multicase.
==16063== 
==16063== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16063== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==16063== malloc/free: 1284 allocs, 1264 frees, 4397889 bytes allocated.
==16063== For counts of detected errors, rerun with: -v
==16063== searching for pointers to 20 not-freed blocks.
==16063== checked 7065196 bytes.
==16063== 
==16063== LEAK SUMMARY:
==16063==    definitely lost: 0 bytes in 0 blocks.
==16063==    possibly lost:   0 bytes in 0 blocks.
==16063==    still reachable: 41393 bytes in 20 blocks.
==16063==         suppressed: 0 bytes in 0 blocks.
==16063== Reachable blocks (those to which a pointer was found) are not shown.
==16063== To see them, rerun with: --show-reachable=yes
==16063== 
 
     ...Executing modalFRF_test...
==16081== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16081== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16081== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16081== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16081== Estimated CPU clock rate is 2813 MHz
==16081== For more details, rerun with: -v
==16081== 
Generating Eigen Solution for modal based solution
==16081== 
==16081== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16081== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16081== malloc/free: 1205 allocs, 1189 frees, 4317061 bytes allocated.
==16081== For counts of detected errors, rerun with: -v
==16081== searching for pointers to 16 not-freed blocks.
==16081== checked 7045644 bytes.
==16081== 
==16081== LEAK SUMMARY:
==16081==    definitely lost: 0 bytes in 0 blocks.
==16081==    possibly lost:   0 bytes in 0 blocks.
==16081==    still reachable: 27726 bytes in 16 blocks.
==16081==         suppressed: 0 bytes in 0 blocks.
==16081== Reachable blocks (those to which a pointer was found) are not shown.
==16081== To see them, rerun with: --show-reachable=yes
==16081== 
 
     ...Executing modalaccelFRF_test...
==16099== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16099== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16099== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16099== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16099== Estimated CPU clock rate is 2808 MHz
==16099== For more details, rerun with: -v
==16099== 
Generating Eigen Solution for modal based solution
==16099== 
==16099== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16099== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16099== malloc/free: 1564 allocs, 1548 frees, 7280938 bytes allocated.
==16099== For counts of detected errors, rerun with: -v
==16099== searching for pointers to 16 not-freed blocks.
==16099== checked 7047948 bytes.
==16099== 
==16099== LEAK SUMMARY:
==16099==    definitely lost: 0 bytes in 0 blocks.
==16099==    possibly lost:   0 bytes in 0 blocks.
==16099==    still reachable: 27726 bytes in 16 blocks.
==16099==         suppressed: 0 bytes in 0 blocks.
==16099== Reachable blocks (those to which a pointer was found) are not shown.
==16099== To see them, rerun with: --show-reachable=yes
==16099== 
 
     ...Executing modalshock_test...
==16109== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16109== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16109== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16109== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16109== Estimated CPU clock rate is 2829 MHz
==16109== For more details, rerun with: -v
==16109== 
Generating Eigen Solution for modal based solution
==16109== 
==16109== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16109== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16109== malloc/free: 5636 allocs, 5620 frees, 26334113 bytes allocated.
==16109== For counts of detected errors, rerun with: -v
==16109== searching for pointers to 16 not-freed blocks.
==16109== checked 7049228 bytes.
==16109== 
==16109== LEAK SUMMARY:
==16109==    definitely lost: 0 bytes in 0 blocks.
==16109==    possibly lost:   0 bytes in 0 blocks.
==16109==    still reachable: 27726 bytes in 16 blocks.
==16109==         suppressed: 0 bytes in 0 blocks.
==16109== Reachable blocks (those to which a pointer was found) are not shown.
==16109== To see them, rerun with: --show-reachable=yes
==16109== 
 
     ...Executing modaltrans2_test...
==16139== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16139== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16139== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16139== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16139== Estimated CPU clock rate is 2795 MHz
==16139== For more details, rerun with: -v
==16139== 
Recommended shift value is -1. Using -100000
==16139== 
==16139== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16139== malloc/free: in use at exit: 104130 bytes in 18 blocks.
==16139== malloc/free: 2958 allocs, 2940 frees, 17209547 bytes allocated.
==16139== For counts of detected errors, rerun with: -v
==16139== searching for pointers to 18 not-freed blocks.
==16139== checked 7123872 bytes.
==16139== 
==16139== LEAK SUMMARY:
==16139==    definitely lost: 0 bytes in 0 blocks.
==16139==    possibly lost:   0 bytes in 0 blocks.
==16139==    still reachable: 104130 bytes in 18 blocks.
==16139==         suppressed: 0 bytes in 0 blocks.
==16139== Reachable blocks (those to which a pointer was found) are not shown.
==16139== To see them, rerun with: --show-reachable=yes
==16139== 
 
     ...Executing modaltrans_test...
==16152== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16152== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16152== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16152== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16152== Estimated CPU clock rate is 2812 MHz
==16152== For more details, rerun with: -v
==16152== 
Generating Eigen Solution for modal based solution
==16152== 
==16152== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16152== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16152== malloc/free: 1460 allocs, 1444 frees, 6275912 bytes allocated.
==16152== For counts of detected errors, rerun with: -v
==16152== searching for pointers to 16 not-freed blocks.
==16152== checked 7046540 bytes.
==16152== 
==16152== LEAK SUMMARY:
==16152==    definitely lost: 0 bytes in 0 blocks.
==16152==    possibly lost:   0 bytes in 0 blocks.
==16152==    still reachable: 27726 bytes in 16 blocks.
==16152==         suppressed: 0 bytes in 0 blocks.
==16152== Reachable blocks (those to which a pointer was found) are not shown.
==16152== To see them, rerun with: --show-reachable=yes
==16152== 
 
     ...Executing transhock1_test...
==16168== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16168== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16168== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16168== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16168== Estimated CPU clock rate is 2811 MHz
==16168== For more details, rerun with: -v
==16168== 
==16168== 
==16168== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16168== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16168== malloc/free: 9010 allocs, 8994 frees, 48240607 bytes allocated.
==16168== For counts of detected errors, rerun with: -v
==16168== searching for pointers to 16 not-freed blocks.
==16168== checked 7048588 bytes.
==16168== 
==16168== LEAK SUMMARY:
==16168==    definitely lost: 0 bytes in 0 blocks.
==16168==    possibly lost:   0 bytes in 0 blocks.
==16168==    still reachable: 27726 bytes in 16 blocks.
==16168==         suppressed: 0 bytes in 0 blocks.
==16168== Reachable blocks (those to which a pointer was found) are not shown.
==16168== To see them, rerun with: --show-reachable=yes
==16168== 
 
     ...Executing transhock_test...
==16186== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16186== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16186== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16186== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16186== Estimated CPU clock rate is 2811 MHz
==16186== For more details, rerun with: -v
==16186== 
==16186== 
==16186== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16186== malloc/free: in use at exit: 27726 bytes in 16 blocks.
==16186== malloc/free: 9010 allocs, 8994 frees, 48240607 bytes allocated.
==16186== For counts of detected errors, rerun with: -v
==16186== searching for pointers to 16 not-freed blocks.
==16186== checked 7050892 bytes.
==16186== 
==16186== LEAK SUMMARY:
==16186==    definitely lost: 0 bytes in 0 blocks.
==16186==    possibly lost:   0 bytes in 0 blocks.
==16186==    still reachable: 27726 bytes in 16 blocks.
==16186==         suppressed: 0 bytes in 0 blocks.
==16186== Reachable blocks (those to which a pointer was found) are not shown.
==16186== To see them, rerun with: --show-reachable=yes
==16186== 
 
     ...Executing vmodalFRF_rbars_test...
==16200== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16200== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16200== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16200== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16200== Estimated CPU clock rate is 2796 MHz
==16200== For more details, rerun with: -v
==16200== 
Recommended shift value is -1. Using -100000
==16200== 
==16200== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16200== malloc/free: in use at exit: 63682 bytes in 16 blocks.
==16200== malloc/free: 3060 allocs, 3044 frees, 15836282 bytes allocated.
==16200== For counts of detected errors, rerun with: -v
==16200== searching for pointers to 16 not-freed blocks.
==16200== checked 7083040 bytes.
==16200== 
==16200== LEAK SUMMARY:
==16200==    definitely lost: 0 bytes in 0 blocks.
==16200==    possibly lost:   0 bytes in 0 blocks.
==16200==    still reachable: 63682 bytes in 16 blocks.
==16200==         suppressed: 0 bytes in 0 blocks.
==16200== Reachable blocks (those to which a pointer was found) are not shown.
==16200== To see them, rerun with: --show-reachable=yes
==16200== 
 
     ...Executing vmodalshock_rbars_test...
==16213== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16213== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16213== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16213== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16213== Estimated CPU clock rate is 2799 MHz
==16213== For more details, rerun with: -v
==16213== 
Recommended shift value is -1. Using -100000
Unexpected duplicate 'Function' section found.
Trying to calculate inverse tangent of 0/0. Assuming a value of zero.
==16213== 
==16213== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16213== malloc/free: in use at exit: 63682 bytes in 16 blocks.
==16213== malloc/free: 5525 allocs, 5509 frees, 35071935 bytes allocated.
==16213== For counts of detected errors, rerun with: -v
==16213== searching for pointers to 16 not-freed blocks.
==16213== checked 7084704 bytes.
==16213== 
==16213== LEAK SUMMARY:
==16213==    definitely lost: 0 bytes in 0 blocks.
==16213==    possibly lost:   0 bytes in 0 blocks.
==16213==    still reachable: 63682 bytes in 16 blocks.
==16213==         suppressed: 0 bytes in 0 blocks.
==16213== Reachable blocks (those to which a pointer was found) are not shown.
==16213== To see them, rerun with: --show-reachable=yes
==16213== 
 
     ...Executing vmtrans_rbars_test...
==16241== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16241== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16241== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16241== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16241== Estimated CPU clock rate is 2800 MHz
==16241== For more details, rerun with: -v
==16241== 
Recommended shift value is -1. Using -100000
==16241== 
==16241== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16241== malloc/free: in use at exit: 63682 bytes in 16 blocks.
==16241== malloc/free: 3300 allocs, 3284 frees, 15855268 bytes allocated.
==16241== For counts of detected errors, rerun with: -v
==16241== searching for pointers to 16 not-freed blocks.
==16241== checked 7088288 bytes.
==16241== 
==16241== LEAK SUMMARY:
==16241==    definitely lost: 0 bytes in 0 blocks.
==16241==    possibly lost:   0 bytes in 0 blocks.
==16241==    still reachable: 63682 bytes in 16 blocks.
==16241==         suppressed: 0 bytes in 0 blocks.
==16241== Reachable blocks (those to which a pointer was found) are not shown.
==16241== To see them, rerun with: --show-reachable=yes
==16241== 
 
     ...Executing vran0_test...
==16253== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16253== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16253== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16253== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16253== Estimated CPU clock rate is 2819 MHz
==16253== For more details, rerun with: -v
==16253== 
Recommended shift value is -1. Using -100000
1 low frequency modes are truncated in random vib.
==16253== 
==16253== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16253== malloc/free: in use at exit: 63682 bytes in 16 blocks.
==16253== malloc/free: 1954 allocs, 1938 frees, 12272593 bytes allocated.
==16253== For counts of detected errors, rerun with: -v
==16253== searching for pointers to 16 not-freed blocks.
==16253== checked 7089808 bytes.
==16253== 
==16253== LEAK SUMMARY:
==16253==    definitely lost: 0 bytes in 0 blocks.
==16253==    possibly lost:   0 bytes in 0 blocks.
==16253==    still reachable: 63682 bytes in 16 blocks.
==16253==         suppressed: 0 bytes in 0 blocks.
==16253== Reachable blocks (those to which a pointer was found) are not shown.
==16253== To see them, rerun with: --show-reachable=yes
==16253== 
 
     ...Executing vran_rbars_test...
==16268== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16268== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16268== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16268== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16268== Estimated CPU clock rate is 2809 MHz
==16268== For more details, rerun with: -v
==16268== 
Recommended shift value is -1. Using -100000
1 low frequency modes are truncated in random vib.
==16268== 
==16268== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16268== malloc/free: in use at exit: 63682 bytes in 16 blocks.
==16268== malloc/free: 3125 allocs, 3109 frees, 17365720 bytes allocated.
==16268== For counts of detected errors, rerun with: -v
==16268== searching for pointers to 16 not-freed blocks.
==16268== checked 7083552 bytes.
==16268== 
==16268== LEAK SUMMARY:
==16268==    definitely lost: 0 bytes in 0 blocks.
==16268==    possibly lost:   0 bytes in 0 blocks.
==16268==    still reachable: 63682 bytes in 16 blocks.
==16268==         suppressed: 0 bytes in 0 blocks.
==16268== Reachable blocks (those to which a pointer was found) are not shown.
==16268== To see them, rerun with: --show-reachable=yes
==16268== 
 
     ...Executing BoxOnBarA_test...
==16285== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16285== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16285== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16285== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16285== Estimated CPU clock rate is 2807 MHz
==16285== For more details, rerun with: -v
==16285== 
==16285== 
==16285== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16285== malloc/free: in use at exit: 12830 bytes in 12 blocks.
==16285== malloc/free: 1527 allocs, 1515 frees, 899554 bytes allocated.
==16285== For counts of detected errors, rerun with: -v
==16285== searching for pointers to 12 not-freed blocks.
==16285== checked 7032272 bytes.
==16285== 
==16285== LEAK SUMMARY:
==16285==    definitely lost: 0 bytes in 0 blocks.
==16285==    possibly lost:   0 bytes in 0 blocks.
==16285==    still reachable: 12830 bytes in 12 blocks.
==16285==         suppressed: 0 bytes in 0 blocks.
==16285== Reachable blocks (those to which a pointer was found) are not shown.
==16285== To see them, rerun with: --show-reachable=yes
==16285== 
 
     ...Executing BoxOnBarB_test...
==16299== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16299== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16299== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16299== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16299== Estimated CPU clock rate is 2792 MHz
==16299== For more details, rerun with: -v
==16299== 
==16299== 
==16299== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16299== malloc/free: in use at exit: 12830 bytes in 12 blocks.
==16299== malloc/free: 1541 allocs, 1529 frees, 952337 bytes allocated.
==16299== For counts of detected errors, rerun with: -v
==16299== searching for pointers to 12 not-freed blocks.
==16299== checked 7034064 bytes.
==16299== 
==16299== LEAK SUMMARY:
==16299==    definitely lost: 0 bytes in 0 blocks.
==16299==    possibly lost:   0 bytes in 0 blocks.
==16299==    still reachable: 12830 bytes in 12 blocks.
==16299==         suppressed: 0 bytes in 0 blocks.
==16299== Reachable blocks (those to which a pointer was found) are not shown.
==16299== To see them, rerun with: --show-reachable=yes
==16299== 
 
     ...Executing BoxOnBarC_test...
==16311== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16311== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16311== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16311== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16311== Estimated CPU clock rate is 2813 MHz
==16311== For more details, rerun with: -v
==16311== 
==16311== 
==16311== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16311== malloc/free: in use at exit: 12830 bytes in 12 blocks.
==16311== malloc/free: 1532 allocs, 1520 frees, 966632 bytes allocated.
==16311== For counts of detected errors, rerun with: -v
==16311== searching for pointers to 12 not-freed blocks.
==16311== checked 7035600 bytes.
==16311== 
==16311== LEAK SUMMARY:
==16311==    definitely lost: 0 bytes in 0 blocks.
==16311==    possibly lost:   0 bytes in 0 blocks.
==16311==    still reachable: 12830 bytes in 12 blocks.
==16311==         suppressed: 0 bytes in 0 blocks.
==16311== Reachable blocks (those to which a pointer was found) are not shown.
==16311== To see them, rerun with: --show-reachable=yes
==16311== 
 
     ...Executing BoxOnBarF-redundant_test...
==16329== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16329== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16329== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16329== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16329== Estimated CPU clock rate is 2803 MHz
==16329== For more details, rerun with: -v
==16329== 
==16329== 
==16329== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16329== malloc/free: in use at exit: 12830 bytes in 12 blocks.
==16329== malloc/free: 1326 allocs, 1314 frees, 414707 bytes allocated.
==16329== For counts of detected errors, rerun with: -v
==16329== searching for pointers to 12 not-freed blocks.
==16329== checked 7029728 bytes.
==16329== 
==16329== LEAK SUMMARY:
==16329==    definitely lost: 0 bytes in 0 blocks.
==16329==    possibly lost:   0 bytes in 0 blocks.
==16329==    still reachable: 12830 bytes in 12 blocks.
==16329==         suppressed: 0 bytes in 0 blocks.
==16329== Reachable blocks (those to which a pointer was found) are not shown.
==16329== To see them, rerun with: --show-reachable=yes
==16329== 
 
     ...Executing BoxOnBarF_test...
==16350== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16350== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16350== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16350== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16350== Estimated CPU clock rate is 2790 MHz
==16350== For more details, rerun with: -v
==16350== 
==16350== 
==16350== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16350== malloc/free: in use at exit: 12830 bytes in 12 blocks.
==16350== malloc/free: 1322 allocs, 1310 frees, 385595 bytes allocated.
==16350== For counts of detected errors, rerun with: -v
==16350== searching for pointers to 12 not-freed blocks.
==16350== checked 7032400 bytes.
==16350== 
==16350== LEAK SUMMARY:
==16350==    definitely lost: 0 bytes in 0 blocks.
==16350==    possibly lost:   0 bytes in 0 blocks.
==16350==    still reachable: 12830 bytes in 12 blocks.
==16350==         suppressed: 0 bytes in 0 blocks.
==16350== Reachable blocks (those to which a pointer was found) are not shown.
==16350== To see them, rerun with: --show-reachable=yes
==16350== 
 
     ...Executing BoxOnBarRbe3_test...
==16371== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16371== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16371== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16371== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16371== Estimated CPU clock rate is 2804 MHz
==16371== For more details, rerun with: -v
==16371== 
Recommended shift value is -1. Using -1e+06
==16371== 
==16371== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16371== malloc/free: in use at exit: 12830 bytes in 12 blocks.
==16371== malloc/free: 1700 allocs, 1688 frees, 1040608 bytes allocated.
==16371== For counts of detected errors, rerun with: -v
==16371== searching for pointers to 12 not-freed blocks.
==16371== checked 7035088 bytes.
==16371== 
==16371== LEAK SUMMARY:
==16371==    definitely lost: 0 bytes in 0 blocks.
==16371==    possibly lost:   0 bytes in 0 blocks.
==16371==    still reachable: 12830 bytes in 12 blocks.
==16371==         suppressed: 0 bytes in 0 blocks.
==16371== Reachable blocks (those to which a pointer was found) are not shown.
==16371== To see them, rerun with: --show-reachable=yes
==16371== 
 
     ...Executing BoxOnBarS_test...
==16389== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16389== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16389== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16389== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16389== Estimated CPU clock rate is 2827 MHz
==16389== For more details, rerun with: -v
==16389== 
==16389== 
==16389== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16389== malloc/free: in use at exit: 12830 bytes in 12 blocks.
==16389== malloc/free: 1535 allocs, 1523 frees, 948388 bytes allocated.
==16389== For counts of detected errors, rerun with: -v
==16389== searching for pointers to 12 not-freed blocks.
==16389== checked 7029200 bytes.
==16389== 
==16389== LEAK SUMMARY:
==16389==    definitely lost: 0 bytes in 0 blocks.
==16389==    possibly lost:   0 bytes in 0 blocks.
==16389==    still reachable: 12830 bytes in 12 blocks.
==16389==         suppressed: 0 bytes in 0 blocks.
==16389== Reachable blocks (those to which a pointer was found) are not shown.
==16389== To see them, rerun with: --show-reachable=yes
==16389== 
 
     ...Executing gcoord_test...
==16415== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16415== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16415== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16415== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16415== Estimated CPU clock rate is 2812 MHz
==16415== For more details, rerun with: -v
==16415== 
==16415== 
==16415== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16415== malloc/free: in use at exit: 15079 bytes in 18 blocks.
==16415== malloc/free: 1212 allocs, 1194 frees, 765872 bytes allocated.
==16415== For counts of detected errors, rerun with: -v
==16415== searching for pointers to 18 not-freed blocks.
==16415== checked 7037368 bytes.
==16415== 
==16415== LEAK SUMMARY:
==16415==    definitely lost: 0 bytes in 0 blocks.
==16415==    possibly lost:   0 bytes in 0 blocks.
==16415==    still reachable: 15079 bytes in 18 blocks.
==16415==         suppressed: 0 bytes in 0 blocks.
==16415== Reachable blocks (those to which a pointer was found) are not shown.
==16415== To see them, rerun with: --show-reachable=yes
==16415== 
 
     ...Executing mult_rbe3_test...
==16425== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16425== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16425== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16425== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16425== Estimated CPU clock rate is 2793 MHz
==16425== For more details, rerun with: -v
==16425== 
Recommended shift value is -1. Using -100000
Echo of MPC completed
==16425== 
==16425== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16425== malloc/free: in use at exit: 23379 bytes in 18 blocks.
==16425== malloc/free: 1926 allocs, 1908 frees, 1887155 bytes allocated.
==16425== For counts of detected errors, rerun with: -v
==16425== searching for pointers to 18 not-freed blocks.
==16425== checked 7044356 bytes.
==16425== 
==16425== LEAK SUMMARY:
==16425==    definitely lost: 0 bytes in 0 blocks.
==16425==    possibly lost:   0 bytes in 0 blocks.
==16425==    still reachable: 23379 bytes in 18 blocks.
==16425==         suppressed: 0 bytes in 0 blocks.
==16425== Reachable blocks (those to which a pointer was found) are not shown.
==16425== To see them, rerun with: --show-reachable=yes
==16425== 
 
     ...Executing mult_rbe3_test...
==16438== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16438== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16438== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16438== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16438== Estimated CPU clock rate is 2830 MHz
==16438== For more details, rerun with: -v
==16438== 
Redundant MPC equations are present.
  The number of redundant constraints is: 6
==16438== 
==16438== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16438== malloc/free: in use at exit: 12802 bytes in 12 blocks.
==16438== malloc/free: 1626 allocs, 1614 frees, 296037 bytes allocated.
==16438== For counts of detected errors, rerun with: -v
==16438== searching for pointers to 12 not-freed blocks.
==16438== checked 7035444 bytes.
==16438== 
==16438== LEAK SUMMARY:
==16438==    definitely lost: 0 bytes in 0 blocks.
==16438==    possibly lost:   0 bytes in 0 blocks.
==16438==    still reachable: 12802 bytes in 12 blocks.
==16438==         suppressed: 0 bytes in 0 blocks.
==16438== Reachable blocks (those to which a pointer was found) are not shown.
==16438== To see them, rerun with: --show-reachable=yes
==16438== 
 
     ...Executing Obeam100_torsion_test...
==16447== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16447== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16447== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16447== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16447== Estimated CPU clock rate is 2812 MHz
==16447== For more details, rerun with: -v
==16447== 
==16447== 
==16447== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16447== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==16447== malloc/free: 2002 allocs, 1990 frees, 918360 bytes allocated.
==16447== For counts of detected errors, rerun with: -v
==16447== searching for pointers to 12 not-freed blocks.
==16447== checked 7037248 bytes.
==16447== 
==16447== LEAK SUMMARY:
==16447==    definitely lost: 0 bytes in 0 blocks.
==16447==    possibly lost:   0 bytes in 0 blocks.
==16447==    still reachable: 13439 bytes in 12 blocks.
==16447==         suppressed: 0 bytes in 0 blocks.
==16447== Reachable blocks (those to which a pointer was found) are not shown.
==16447== To see them, rerun with: --show-reachable=yes
==16447== 
 
     ...Executing Obeam100_xz_test...
==16457== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16457== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16457== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16457== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16457== Estimated CPU clock rate is 2794 MHz
==16457== For more details, rerun with: -v
==16457== 
==16457== 
==16457== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16457== malloc/free: in use at exit: 13439 bytes in 12 blocks.
==16457== malloc/free: 1604 allocs, 1592 frees, 1075673 bytes allocated.
==16457== For counts of detected errors, rerun with: -v
==16457== searching for pointers to 12 not-freed blocks.
==16457== checked 7030320 bytes.
==16457== 
==16457== LEAK SUMMARY:
==16457==    definitely lost: 0 bytes in 0 blocks.
==16457==    possibly lost:   0 bytes in 0 blocks.
==16457==    still reachable: 13439 bytes in 12 blocks.
==16457==         suppressed: 0 bytes in 0 blocks.
==16457== Reachable blocks (those to which a pointer was found) are not shown.
==16457== To see them, rerun with: --show-reachable=yes
==16457== 
 
     ...Executing cjdamp_test...
==16468== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16468== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16468== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16468== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16468== Estimated CPU clock rate is 2797 MHz
==16468== For more details, rerun with: -v
==16468== 
==16468== 
==16468== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16468== malloc/free: in use at exit: 16029 bytes in 16 blocks.
==16468== malloc/free: 2226 allocs, 2210 frees, 2197279 bytes allocated.
==16468== For counts of detected errors, rerun with: -v
==16468== searching for pointers to 16 not-freed blocks.
==16468== checked 7036908 bytes.
==16468== 
==16468== LEAK SUMMARY:
==16468==    definitely lost: 0 bytes in 0 blocks.
==16468==    possibly lost:   0 bytes in 0 blocks.
==16468==    still reachable: 16029 bytes in 16 blocks.
==16468==         suppressed: 0 bytes in 0 blocks.
==16468== Reachable blocks (those to which a pointer was found) are not shown.
==16468== To see them, rerun with: --show-reachable=yes
==16468== 
 
     ...Executing quad8beam_nlstatics_test...
==16487== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16487== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16487== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16487== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16487== Estimated CPU clock rate is 2814 MHz
==16487== For more details, rerun with: -v
==16487== 
	--- Newton Method Parameters ---
	max_newton_iterations = 10
	num_newton_load_steps = 10
	            tolerance = 1e-08
	       update_tangent = 1
==16487== 
==16487== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16487== malloc/free: in use at exit: 16715 bytes in 12 blocks.
==16487== malloc/free: 9097 allocs, 9085 frees, 544264243 bytes allocated.
==16487== For counts of detected errors, rerun with: -v
==16487== searching for pointers to 12 not-freed blocks.
==16487== checked 7047244 bytes.
==16487== 
==16487== LEAK SUMMARY:
==16487==    definitely lost: 0 bytes in 0 blocks.
==16487==    possibly lost:   0 bytes in 0 blocks.
==16487==    still reachable: 16715 bytes in 12 blocks.
==16487==         suppressed: 0 bytes in 0 blocks.
==16487== Reachable blocks (those to which a pointer was found) are not shown.
==16487== To see them, rerun with: --show-reachable=yes
==16487== 
 
     ...Executing quadbeam_eig_test...
==16751== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16751== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16751== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16751== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16751== Estimated CPU clock rate is 2819 MHz
==16751== For more details, rerun with: -v
==16751== 
==16751== 
==16751== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16751== malloc/free: in use at exit: 43750 bytes in 16 blocks.
==16751== malloc/free: 1221 allocs, 1205 frees, 3816233 bytes allocated.
==16751== For counts of detected errors, rerun with: -v
==16751== searching for pointers to 16 not-freed blocks.
==16751== checked 7068084 bytes.
==16751== 
==16751== LEAK SUMMARY:
==16751==    definitely lost: 0 bytes in 0 blocks.
==16751==    possibly lost:   0 bytes in 0 blocks.
==16751==    still reachable: 43750 bytes in 16 blocks.
==16751==         suppressed: 0 bytes in 0 blocks.
==16751== Reachable blocks (those to which a pointer was found) are not shown.
==16751== To see them, rerun with: --show-reachable=yes
==16751== 
 
     ...Executing quadbeam_nlstatics_test...
==16762== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==16762== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==16762== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==16762== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==16762== Estimated CPU clock rate is 2804 MHz
==16762== For more details, rerun with: -v
==16762== 
	--- Newton Method Parameters ---
	max_newton_iterations = 10
	num_newton_load_steps = 10
	            tolerance = 1e-08
	       update_tangent = 1
==16762== 
==16762== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==16762== malloc/free: in use at exit: 14167 bytes in 12 blocks.
==16762== malloc/free: 12164 allocs, 12152 frees, 312512353 bytes allocated.
==16762== For counts of detected errors, rerun with: -v
==16762== searching for pointers to 12 not-freed blocks.
==16762== checked 7039928 bytes.
==16762== 
==16762== LEAK SUMMARY:
==16762==    definitely lost: 0 bytes in 0 blocks.
==16762==    possibly lost:   0 bytes in 0 blocks.
==16762==    still reachable: 14167 bytes in 12 blocks.
==16762==         suppressed: 0 bytes in 0 blocks.
==16762== Reachable blocks (those to which a pointer was found) are not shown.
==16762== To see them, rerun with: --show-reachable=yes
==16762== 
 
     ...Executing quadbeam_stress_test...
==17124== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17124== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17124== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17124== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17124== Estimated CPU clock rate is 2795 MHz
==17124== For more details, rerun with: -v
==17124== 
==17124== 
==17124== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17124== malloc/free: in use at exit: 14167 bytes in 12 blocks.
==17124== malloc/free: 1429 allocs, 1417 frees, 2633873 bytes allocated.
==17124== For counts of detected errors, rerun with: -v
==17124== searching for pointers to 12 not-freed blocks.
==17124== checked 7037112 bytes.
==17124== 
==17124== LEAK SUMMARY:
==17124==    definitely lost: 0 bytes in 0 blocks.
==17124==    possibly lost:   0 bytes in 0 blocks.
==17124==    still reachable: 14167 bytes in 12 blocks.
==17124==         suppressed: 0 bytes in 0 blocks.
==17124== Reachable blocks (those to which a pointer was found) are not shown.
==17124== To see them, rerun with: --show-reachable=yes
==17124== 
 
     ...Executing quadbeam_test...
==17135== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17135== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17135== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17135== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17135== Estimated CPU clock rate is 2797 MHz
==17135== For more details, rerun with: -v
==17135== 
==17135== 
==17135== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17135== malloc/free: in use at exit: 14167 bytes in 12 blocks.
==17135== malloc/free: 1052 allocs, 1040 frees, 2606936 bytes allocated.
==17135== For counts of detected errors, rerun with: -v
==17135== searching for pointers to 12 not-freed blocks.
==17135== checked 7038504 bytes.
==17135== 
==17135== LEAK SUMMARY:
==17135==    definitely lost: 0 bytes in 0 blocks.
==17135==    possibly lost:   0 bytes in 0 blocks.
==17135==    still reachable: 14167 bytes in 12 blocks.
==17135==         suppressed: 0 bytes in 0 blocks.
==17135== Reachable blocks (those to which a pointer was found) are not shown.
==17135== To see them, rerun with: --show-reachable=yes
==17135== 
 
     ...Executing sphereq_test...
==17149== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17149== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17149== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17149== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17149== Estimated CPU clock rate is 2800 MHz
==17149== For more details, rerun with: -v
==17149== 
==17149== 
==17149== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17149== malloc/free: in use at exit: 71081 bytes in 16 blocks.
==17149== malloc/free: 1377 allocs, 1361 frees, 16003084 bytes allocated.
==17149== For counts of detected errors, rerun with: -v
==17149== searching for pointers to 16 not-freed blocks.
==17149== checked 7097208 bytes.
==17149== 
==17149== LEAK SUMMARY:
==17149==    definitely lost: 0 bytes in 0 blocks.
==17149==    possibly lost:   0 bytes in 0 blocks.
==17149==    still reachable: 71081 bytes in 16 blocks.
==17149==         suppressed: 0 bytes in 0 blocks.
==17149== Reachable blocks (those to which a pointer was found) are not shown.
==17149== To see them, rerun with: --show-reachable=yes
==17149== 
 
     ...Executing Stiffener_test...
==17257== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17257== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17257== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17257== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17257== Estimated CPU clock rate is 2826 MHz
==17257== For more details, rerun with: -v
==17257== 
==17257== 
==17257== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17257== malloc/free: in use at exit: 16029 bytes in 16 blocks.
==17257== malloc/free: 1561 allocs, 1545 frees, 1024537 bytes allocated.
==17257== For counts of detected errors, rerun with: -v
==17257== searching for pointers to 16 not-freed blocks.
==17257== checked 7039596 bytes.
==17257== 
==17257== LEAK SUMMARY:
==17257==    definitely lost: 0 bytes in 0 blocks.
==17257==    possibly lost:   0 bytes in 0 blocks.
==17257==    still reachable: 16029 bytes in 16 blocks.
==17257==         suppressed: 0 bytes in 0 blocks.
==17257== Reachable blocks (those to which a pointer was found) are not shown.
==17257== To see them, rerun with: --show-reachable=yes
==17257== 
 
     ...Executing beam10a_test...
==17288== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17288== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17288== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17288== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17288== Estimated CPU clock rate is 2830 MHz
==17288== For more details, rerun with: -v
==17288== 
==17288== 
==17288== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17288== malloc/free: in use at exit: 12809 bytes in 12 blocks.
==17288== malloc/free: 1240 allocs, 1228 frees, 712038 bytes allocated.
==17288== For counts of detected errors, rerun with: -v
==17288== searching for pointers to 12 not-freed blocks.
==17288== checked 7029564 bytes.
==17288== 
==17288== LEAK SUMMARY:
==17288==    definitely lost: 0 bytes in 0 blocks.
==17288==    possibly lost:   0 bytes in 0 blocks.
==17288==    still reachable: 12809 bytes in 12 blocks.
==17288==         suppressed: 0 bytes in 0 blocks.
==17288== Reachable blocks (those to which a pointer was found) are not shown.
==17288== To see them, rerun with: --show-reachable=yes
==17288== 
 
     ...Executing beam10b_test...
==17300== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17300== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17300== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17300== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17300== Estimated CPU clock rate is 2825 MHz
==17300== For more details, rerun with: -v
==17300== 
==17300== 
==17300== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17300== malloc/free: in use at exit: 12809 bytes in 12 blocks.
==17300== malloc/free: 1241 allocs, 1229 frees, 712380 bytes allocated.
==17300== For counts of detected errors, rerun with: -v
==17300== searching for pointers to 12 not-freed blocks.
==17300== checked 7031100 bytes.
==17300== 
==17300== LEAK SUMMARY:
==17300==    definitely lost: 0 bytes in 0 blocks.
==17300==    possibly lost:   0 bytes in 0 blocks.
==17300==    still reachable: 12809 bytes in 12 blocks.
==17300==         suppressed: 0 bytes in 0 blocks.
==17300== Reachable blocks (those to which a pointer was found) are not shown.
==17300== To see them, rerun with: --show-reachable=yes
==17300== 
 
     ...Executing hex8a_test...
==17312== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17312== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17312== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17312== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17312== Estimated CPU clock rate is 2796 MHz
==17312== For more details, rerun with: -v
==17312== 
==17312== 
==17312== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17312== malloc/free: in use at exit: 12921 bytes in 12 blocks.
==17312== malloc/free: 1107 allocs, 1095 frees, 1026231 bytes allocated.
==17312== For counts of detected errors, rerun with: -v
==17312== searching for pointers to 12 not-freed blocks.
==17312== checked 7032748 bytes.
==17312== 
==17312== LEAK SUMMARY:
==17312==    definitely lost: 0 bytes in 0 blocks.
==17312==    possibly lost:   0 bytes in 0 blocks.
==17312==    still reachable: 12921 bytes in 12 blocks.
==17312==         suppressed: 0 bytes in 0 blocks.
==17312== Reachable blocks (those to which a pointer was found) are not shown.
==17312== To see them, rerun with: --show-reachable=yes
==17312== 
 
     ...Executing hex8b_test...
==17324== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17324== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17324== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17324== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17324== Estimated CPU clock rate is 2794 MHz
==17324== For more details, rerun with: -v
==17324== 
==17324== 
==17324== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17324== malloc/free: in use at exit: 12921 bytes in 12 blocks.
==17324== malloc/free: 1108 allocs, 1096 frees, 1026623 bytes allocated.
==17324== For counts of detected errors, rerun with: -v
==17324== searching for pointers to 12 not-freed blocks.
==17324== checked 7034284 bytes.
==17324== 
==17324== LEAK SUMMARY:
==17324==    definitely lost: 0 bytes in 0 blocks.
==17324==    possibly lost:   0 bytes in 0 blocks.
==17324==    still reachable: 12921 bytes in 12 blocks.
==17324==         suppressed: 0 bytes in 0 blocks.
==17324== Reachable blocks (those to which a pointer was found) are not shown.
==17324== To see them, rerun with: --show-reachable=yes
==17324== 
 
     ...Executing tri8a_test...
==17351== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17351== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17351== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17351== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17351== Estimated CPU clock rate is 2794 MHz
==17351== For more details, rerun with: -v
==17351== 
==17351== 
==17351== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17351== malloc/free: in use at exit: 15074 bytes in 16 blocks.
==17351== malloc/free: 1261 allocs, 1245 frees, 724358 bytes allocated.
==17351== For counts of detected errors, rerun with: -v
==17351== searching for pointers to 16 not-freed blocks.
==17351== checked 7031696 bytes.
==17351== 
==17351== LEAK SUMMARY:
==17351==    definitely lost: 0 bytes in 0 blocks.
==17351==    possibly lost:   0 bytes in 0 blocks.
==17351==    still reachable: 15074 bytes in 16 blocks.
==17351==         suppressed: 0 bytes in 0 blocks.
==17351== Reachable blocks (those to which a pointer was found) are not shown.
==17351== To see them, rerun with: --show-reachable=yes
==17351== 
 
     ...Executing tri8b_test...
==17363== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17363== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17363== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17363== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17363== Estimated CPU clock rate is 2807 MHz
==17363== For more details, rerun with: -v
==17363== 
==17363== 
==17363== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17363== malloc/free: in use at exit: 15074 bytes in 16 blocks.
==17363== malloc/free: 1262 allocs, 1246 frees, 724704 bytes allocated.
==17363== For counts of detected errors, rerun with: -v
==17363== searching for pointers to 16 not-freed blocks.
==17363== checked 7033232 bytes.
==17363== 
==17363== LEAK SUMMARY:
==17363==    definitely lost: 0 bytes in 0 blocks.
==17363==    possibly lost:   0 bytes in 0 blocks.
==17363==    still reachable: 15074 bytes in 16 blocks.
==17363==         suppressed: 0 bytes in 0 blocks.
==17363== Reachable blocks (those to which a pointer was found) are not shown.
==17363== To see them, rerun with: --show-reachable=yes
==17363== 
 
     ...Executing quad4_test...
==17375== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17375== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17375== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17375== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17375== Estimated CPU clock rate is 2795 MHz
==17375== For more details, rerun with: -v
==17375== 
==17375== 
==17375== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17375== malloc/free: in use at exit: 12774 bytes in 12 blocks.
==17375== malloc/free: 1182 allocs, 1170 frees, 124293 bytes allocated.
==17375== For counts of detected errors, rerun with: -v
==17375== searching for pointers to 12 not-freed blocks.
==17375== checked 7035080 bytes.
==17375== 
==17375== LEAK SUMMARY:
==17375==    definitely lost: 0 bytes in 0 blocks.
==17375==    possibly lost:   0 bytes in 0 blocks.
==17375==    still reachable: 12774 bytes in 12 blocks.
==17375==         suppressed: 0 bytes in 0 blocks.
==17375== Reachable blocks (those to which a pointer was found) are not shown.
==17375== To see them, rerun with: --show-reachable=yes
==17375== 
 
     ...Executing hex20_test...
==17388== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17388== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17388== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17388== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17388== Estimated CPU clock rate is 2821 MHz
==17388== For more details, rerun with: -v
==17388== 
==17388== 
==17388== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17388== malloc/free: in use at exit: 12872 bytes in 12 blocks.
==17388== malloc/free: 1404 allocs, 1392 frees, 363076 bytes allocated.
==17388== For counts of detected errors, rerun with: -v
==17388== searching for pointers to 12 not-freed blocks.
==17388== checked 7034236 bytes.
==17388== 
==17388== LEAK SUMMARY:
==17388==    definitely lost: 0 bytes in 0 blocks.
==17388==    possibly lost:   0 bytes in 0 blocks.
==17388==    still reachable: 12872 bytes in 12 blocks.
==17388==         suppressed: 0 bytes in 0 blocks.
==17388== Reachable blocks (those to which a pointer was found) are not shown.
==17388== To see them, rerun with: --show-reachable=yes
==17388== 
 
     ...Executing hex8_test...
==17400== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17400== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17400== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17400== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17400== Estimated CPU clock rate is 2826 MHz
==17400== For more details, rerun with: -v
==17400== 
==17400== 
==17400== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17400== malloc/free: in use at exit: 12788 bytes in 12 blocks.
==17400== malloc/free: 1360 allocs, 1348 frees, 118465 bytes allocated.
==17400== For counts of detected errors, rerun with: -v
==17400== searching for pointers to 12 not-freed blocks.
==17400== checked 7035688 bytes.
==17400== 
==17400== LEAK SUMMARY:
==17400==    definitely lost: 0 bytes in 0 blocks.
==17400==    possibly lost:   0 bytes in 0 blocks.
==17400==    still reachable: 12788 bytes in 12 blocks.
==17400==         suppressed: 0 bytes in 0 blocks.
==17400== Reachable blocks (those to which a pointer was found) are not shown.
==17400== To see them, rerun with: --show-reachable=yes
==17400== 
 
     ...Executing sidebc_test...
==17410== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17410== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17410== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17410== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17410== Estimated CPU clock rate is 2815 MHz
==17410== For more details, rerun with: -v
==17410== 
==17410== 
==17410== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17410== malloc/free: in use at exit: 15175 bytes in 16 blocks.
==17410== malloc/free: 1656 allocs, 1640 frees, 972339 bytes allocated.
==17410== For counts of detected errors, rerun with: -v
==17410== searching for pointers to 16 not-freed blocks.
==17410== checked 7031160 bytes.
==17410== 
==17410== LEAK SUMMARY:
==17410==    definitely lost: 0 bytes in 0 blocks.
==17410==    possibly lost:   0 bytes in 0 blocks.
==17410==    still reachable: 15175 bytes in 16 blocks.
==17410==         suppressed: 0 bytes in 0 blocks.
==17410== Reachable blocks (those to which a pointer was found) are not shown.
==17410== To see them, rerun with: --show-reachable=yes
==17410== 
 
     ...Executing tet10_test...
==17421== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17421== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17421== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17421== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17421== Estimated CPU clock rate is 2810 MHz
==17421== For more details, rerun with: -v
==17421== 
Currently Tet10 elements are not being checked for negative volumes.
==17421== 
==17421== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17421== malloc/free: in use at exit: 12802 bytes in 12 blocks.
==17421== malloc/free: 1204 allocs, 1192 frees, 121626 bytes allocated.
==17421== For counts of detected errors, rerun with: -v
==17421== searching for pointers to 12 not-freed blocks.
==17421== checked 7030196 bytes.
==17421== 
==17421== LEAK SUMMARY:
==17421==    definitely lost: 0 bytes in 0 blocks.
==17421==    possibly lost:   0 bytes in 0 blocks.
==17421==    still reachable: 12802 bytes in 12 blocks.
==17421==         suppressed: 0 bytes in 0 blocks.
==17421== Reachable blocks (those to which a pointer was found) are not shown.
==17421== To see them, rerun with: --show-reachable=yes
==17421== 
 
     ...Executing tet4_test...
==17431== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17431== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17431== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17431== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17431== Estimated CPU clock rate is 2791 MHz
==17431== For more details, rerun with: -v
==17431== 
==17431== 
==17431== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17431== malloc/free: in use at exit: 12760 bytes in 12 blocks.
==17431== malloc/free: 1181 allocs, 1169 frees, 78053 bytes allocated.
==17431== For counts of detected errors, rerun with: -v
==17431== searching for pointers to 12 not-freed blocks.
==17431== checked 7031436 bytes.
==17431== 
==17431== LEAK SUMMARY:
==17431==    definitely lost: 0 bytes in 0 blocks.
==17431==    possibly lost:   0 bytes in 0 blocks.
==17431==    still reachable: 12760 bytes in 12 blocks.
==17431==         suppressed: 0 bytes in 0 blocks.
==17431== Reachable blocks (those to which a pointer was found) are not shown.
==17431== To see them, rerun with: --show-reachable=yes
==17431== 
 
     ...Executing wedge6_test...
==17440== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17440== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17440== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17440== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17440== Estimated CPU clock rate is 2792 MHz
==17440== For more details, rerun with: -v
==17440== 
==17440== 
==17440== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17440== malloc/free: in use at exit: 12774 bytes in 12 blocks.
==17440== malloc/free: 1272 allocs, 1260 frees, 91612 bytes allocated.
==17440== For counts of detected errors, rerun with: -v
==17440== searching for pointers to 12 not-freed blocks.
==17440== checked 7032600 bytes.
==17440== 
==17440== LEAK SUMMARY:
==17440==    definitely lost: 0 bytes in 0 blocks.
==17440==    possibly lost:   0 bytes in 0 blocks.
==17440==    still reachable: 12774 bytes in 12 blocks.
==17440==         suppressed: 0 bytes in 0 blocks.
==17440== Reachable blocks (those to which a pointer was found) are not shown.
==17440== To see them, rerun with: --show-reachable=yes
==17440== 
 
     ...Executing quad8_test...
==17452== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17452== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17452== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17452== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17452== Estimated CPU clock rate is 2790 MHz
==17452== For more details, rerun with: -v
==17452== 
==17452== 
==17452== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17452== malloc/free: in use at exit: 12823 bytes in 12 blocks.
==17452== malloc/free: 1093 allocs, 1081 frees, 238267 bytes allocated.
==17452== For counts of detected errors, rerun with: -v
==17452== searching for pointers to 12 not-freed blocks.
==17452== checked 7043992 bytes.
==17452== 
==17452== LEAK SUMMARY:
==17452==    definitely lost: 0 bytes in 0 blocks.
==17452==    possibly lost:   0 bytes in 0 blocks.
==17452==    still reachable: 12823 bytes in 12 blocks.
==17452==         suppressed: 0 bytes in 0 blocks.
==17452== Reachable blocks (those to which a pointer was found) are not shown.
==17452== To see them, rerun with: --show-reachable=yes
==17452== 
 
     ...Executing tria3_test...
==17466== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17466== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17466== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17466== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17466== Estimated CPU clock rate is 2805 MHz
==17466== For more details, rerun with: -v
==17466== 
==17466== 
==17466== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17466== malloc/free: in use at exit: 12774 bytes in 12 blocks.
==17466== malloc/free: 1083 allocs, 1071 frees, 112960 bytes allocated.
==17466== For counts of detected errors, rerun with: -v
==17466== searching for pointers to 12 not-freed blocks.
==17466== checked 7035944 bytes.
==17466== 
==17466== LEAK SUMMARY:
==17466==    definitely lost: 0 bytes in 0 blocks.
==17466==    possibly lost:   0 bytes in 0 blocks.
==17466==    still reachable: 12774 bytes in 12 blocks.
==17466==         suppressed: 0 bytes in 0 blocks.
==17466== Reachable blocks (those to which a pointer was found) are not shown.
==17466== To see them, rerun with: --show-reachable=yes
==17466== 
 
     ...Executing triashell_test...
==17478== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17478== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17478== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17478== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17478== Estimated CPU clock rate is 2813 MHz
==17478== For more details, rerun with: -v
==17478== 
==17478== 
==17478== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17478== malloc/free: in use at exit: 12774 bytes in 12 blocks.
==17478== malloc/free: 1083 allocs, 1071 frees, 113556 bytes allocated.
==17478== For counts of detected errors, rerun with: -v
==17478== searching for pointers to 12 not-freed blocks.
==17478== checked 7029288 bytes.
==17478== 
==17478== LEAK SUMMARY:
==17478==    definitely lost: 0 bytes in 0 blocks.
==17478==    possibly lost:   0 bytes in 0 blocks.
==17478==    still reachable: 12774 bytes in 12 blocks.
==17478==         suppressed: 0 bytes in 0 blocks.
==17478== Reachable blocks (those to which a pointer was found) are not shown.
==17478== To see them, rerun with: --show-reachable=yes
==17478== 
 
     ...Executing tria6_test...
==17490== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17490== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17490== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17490== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17490== Estimated CPU clock rate is 2829 MHz
==17490== For more details, rerun with: -v
==17490== 
==17490== 
==17490== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17490== malloc/free: in use at exit: 12837 bytes in 12 blocks.
==17490== malloc/free: 1099 allocs, 1087 frees, 236431 bytes allocated.
==17490== For counts of detected errors, rerun with: -v
==17490== searching for pointers to 12 not-freed blocks.
==17490== checked 7033480 bytes.
==17490== 
==17490== LEAK SUMMARY:
==17490==    definitely lost: 0 bytes in 0 blocks.
==17490==    possibly lost:   0 bytes in 0 blocks.
==17490==    still reachable: 12837 bytes in 12 blocks.
==17490==         suppressed: 0 bytes in 0 blocks.
==17490== Reachable blocks (those to which a pointer was found) are not shown.
==17490== To see them, rerun with: --show-reachable=yes
==17490== 
 
     ...Executing a_eigrst_test...
==17504== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17504== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17504== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17504== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17504== Estimated CPU clock rate is 2798 MHz
==17504== For more details, rerun with: -v
==17504== 
==17504== 
==17504== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17504== malloc/free: in use at exit: 35654 bytes in 16 blocks.
==17504== malloc/free: 18840 allocs, 18824 frees, 8958430 bytes allocated.
==17504== For counts of detected errors, rerun with: -v
==17504== searching for pointers to 16 not-freed blocks.
==17504== checked 7058068 bytes.
==17504== 
==17504== LEAK SUMMARY:
==17504==    definitely lost: 0 bytes in 0 blocks.
==17504==    possibly lost:   0 bytes in 0 blocks.
==17504==    still reachable: 35654 bytes in 16 blocks.
==17504==         suppressed: 0 bytes in 0 blocks.
==17504== Reachable blocks (those to which a pointer was found) are not shown.
==17504== To see them, rerun with: --show-reachable=yes
==17504== 
 
     ...Executing b_eigrst_test...
==17516== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17516== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17516== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17516== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17516== Estimated CPU clock rate is 2806 MHz
==17516== For more details, rerun with: -v
==17516== 
==17516== 
==17516== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17516== malloc/free: in use at exit: 35654 bytes in 16 blocks.
==17516== malloc/free: 36260 allocs, 36244 frees, 14191429 bytes allocated.
==17516== For counts of detected errors, rerun with: -v
==17516== searching for pointers to 16 not-freed blocks.
==17516== checked 7059604 bytes.
==17516== 
==17516== LEAK SUMMARY:
==17516==    definitely lost: 0 bytes in 0 blocks.
==17516==    possibly lost:   0 bytes in 0 blocks.
==17516==    still reachable: 35654 bytes in 16 blocks.
==17516==         suppressed: 0 bytes in 0 blocks.
==17516== Reachable blocks (those to which a pointer was found) are not shown.
==17516== To see them, rerun with: --show-reachable=yes
==17516== 
 
     ...Executing tet10_beam_small_eigen_test...
==17628== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17628== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17628== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17628== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17628== Estimated CPU clock rate is 2830 MHz
==17628== For more details, rerun with: -v
==17628== 
==17628== 
==17628== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17628== malloc/free: in use at exit: 19305 bytes in 12 blocks.
==17628== malloc/free: 1633 allocs, 1621 frees, 21126512 bytes allocated.
==17628== For counts of detected errors, rerun with: -v
==17628== searching for pointers to 12 not-freed blocks.
==17628== checked 7038636 bytes.
==17628== 
==17628== LEAK SUMMARY:
==17628==    definitely lost: 0 bytes in 0 blocks.
==17628==    possibly lost:   0 bytes in 0 blocks.
==17628==    still reachable: 19305 bytes in 12 blocks.
==17628==         suppressed: 0 bytes in 0 blocks.
==17628== Reachable blocks (those to which a pointer was found) are not shown.
==17628== To see them, rerun with: --show-reachable=yes
==17628== 
 
     ...Executing tet10_beam_small_statics_test...
==17704== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17704== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17704== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17704== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17704== Estimated CPU clock rate is 2807 MHz
==17704== For more details, rerun with: -v
==17704== 
==17704== 
==17704== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17704== malloc/free: in use at exit: 19305 bytes in 12 blocks.
==17704== malloc/free: 2172 allocs, 2160 frees, 19393324 bytes allocated.
==17704== For counts of detected errors, rerun with: -v
==17704== searching for pointers to 12 not-freed blocks.
==17704== checked 7040172 bytes.
==17704== 
==17704== LEAK SUMMARY:
==17704==    definitely lost: 0 bytes in 0 blocks.
==17704==    possibly lost:   0 bytes in 0 blocks.
==17704==    still reachable: 19305 bytes in 12 blocks.
==17704==         suppressed: 0 bytes in 0 blocks.
==17704== Reachable blocks (those to which a pointer was found) are not shown.
==17704== To see them, rerun with: --show-reachable=yes
==17704== 
 
     ...Executing tet10_sidesets_test...
==17830== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17830== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17830== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17830== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17830== Estimated CPU clock rate is 2812 MHz
==17830== For more details, rerun with: -v
==17830== 
==17830== 
==17830== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17830== malloc/free: in use at exit: 25787 bytes in 12 blocks.
==17830== malloc/free: 3009 allocs, 2997 frees, 35298700 bytes allocated.
==17830== For counts of detected errors, rerun with: -v
==17830== searching for pointers to 12 not-freed blocks.
==17830== checked 7046380 bytes.
==17830== 
==17830== LEAK SUMMARY:
==17830==    definitely lost: 0 bytes in 0 blocks.
==17830==    possibly lost:   0 bytes in 0 blocks.
==17830==    still reachable: 25787 bytes in 12 blocks.
==17830==         suppressed: 0 bytes in 0 blocks.
==17830== Reachable blocks (those to which a pointer was found) are not shown.
==17830== To see them, rerun with: --show-reachable=yes
==17830== 
 
     ...Executing tet4_small_eigen_test...
==17879== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17879== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17879== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17879== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17879== Estimated CPU clock rate is 2816 MHz
==17879== For more details, rerun with: -v
==17879== 
==17879== 
==17879== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17879== malloc/free: in use at exit: 12900 bytes in 12 blocks.
==17879== malloc/free: 1042 allocs, 1030 frees, 761466 bytes allocated.
==17879== For counts of detected errors, rerun with: -v
==17879== searching for pointers to 12 not-freed blocks.
==17879== checked 7031592 bytes.
==17879== 
==17879== LEAK SUMMARY:
==17879==    definitely lost: 0 bytes in 0 blocks.
==17879==    possibly lost:   0 bytes in 0 blocks.
==17879==    still reachable: 12900 bytes in 12 blocks.
==17879==         suppressed: 0 bytes in 0 blocks.
==17879== Reachable blocks (those to which a pointer was found) are not shown.
==17879== To see them, rerun with: --show-reachable=yes
==17879== 
 
     ...Executing tet4_small_statics_test...
==17892== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17892== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17892== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17892== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17892== Estimated CPU clock rate is 2817 MHz
==17892== For more details, rerun with: -v
==17892== 
==17892== 
==17892== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17892== malloc/free: in use at exit: 12900 bytes in 12 blocks.
==17892== malloc/free: 857 allocs, 845 frees, 195822 bytes allocated.
==17892== For counts of detected errors, rerun with: -v
==17892== searching for pointers to 12 not-freed blocks.
==17892== checked 7033256 bytes.
==17892== 
==17892== LEAK SUMMARY:
==17892==    definitely lost: 0 bytes in 0 blocks.
==17892==    possibly lost:   0 bytes in 0 blocks.
==17892==    still reachable: 12900 bytes in 12 blocks.
==17892==         suppressed: 0 bytes in 0 blocks.
==17892== Reachable blocks (those to which a pointer was found) are not shown.
==17892== To see them, rerun with: --show-reachable=yes
==17892== 
 
     ...Executing barely_tied_test...
==17904== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17904== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17904== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17904== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17904== Estimated CPU clock rate is 2817 MHz
==17904== For more details, rerun with: -v
==17904== 
Recommended shift value is -1. Using -10000
==17904== 
==17904== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17904== malloc/free: in use at exit: 27679 bytes in 21 blocks.
==17904== malloc/free: 2445 allocs, 2424 frees, 3196129 bytes allocated.
==17904== For counts of detected errors, rerun with: -v
==17904== searching for pointers to 21 not-freed blocks.
==17904== checked 7048780 bytes.
==17904== 
==17904== LEAK SUMMARY:
==17904==    definitely lost: 0 bytes in 0 blocks.
==17904==    possibly lost:   0 bytes in 0 blocks.
==17904==    still reachable: 27679 bytes in 21 blocks.
==17904==         suppressed: 0 bytes in 0 blocks.
==17904== Reachable blocks (those to which a pointer was found) are not shown.
==17904== To see them, rerun with: --show-reachable=yes
==17904== 
 
     ...Executing hex_tied_surface_test...
==17914== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17914== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17914== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17914== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17914== Estimated CPU clock rate is 2822 MHz
==17914== For more details, rerun with: -v
==17914== 
Recommended shift value is -1. Using -10000
==17914== 
==17914== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17914== malloc/free: in use at exit: 27679 bytes in 21 blocks.
==17914== malloc/free: 3071 allocs, 3050 frees, 4309118 bytes allocated.
==17914== For counts of detected errors, rerun with: -v
==17914== searching for pointers to 21 not-freed blocks.
==17914== checked 7050060 bytes.
==17914== 
==17914== LEAK SUMMARY:
==17914==    definitely lost: 0 bytes in 0 blocks.
==17914==    possibly lost:   0 bytes in 0 blocks.
==17914==    still reachable: 27679 bytes in 21 blocks.
==17914==         suppressed: 0 bytes in 0 blocks.
==17914== Reachable blocks (those to which a pointer was found) are not shown.
==17914== To see them, rerun with: --show-reachable=yes
==17914== 
 
     ...Executing tied_corner_test...
==17924== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17924== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17924== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17924== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17924== Estimated CPU clock rate is 2804 MHz
==17924== For more details, rerun with: -v
==17924== 
Recommended shift value is -1. Using -10000
==17924== 
==17924== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17924== malloc/free: in use at exit: 54506 bytes in 21 blocks.
==17924== malloc/free: 3860 allocs, 3839 frees, 11242715 bytes allocated.
==17924== For counts of detected errors, rerun with: -v
==17924== searching for pointers to 21 not-freed blocks.
==17924== checked 7069972 bytes.
==17924== 
==17924== LEAK SUMMARY:
==17924==    definitely lost: 0 bytes in 0 blocks.
==17924==    possibly lost:   0 bytes in 0 blocks.
==17924==    still reachable: 54506 bytes in 21 blocks.
==17924==         suppressed: 0 bytes in 0 blocks.
==17924== Reachable blocks (those to which a pointer was found) are not shown.
==17924== To see them, rerun with: --show-reachable=yes
==17924== 
 
     ...Executing two_plates_test...
==17947== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17947== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17947== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17947== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17947== Estimated CPU clock rate is 2794 MHz
==17947== For more details, rerun with: -v
==17947== 
Recommended shift value is -1. Using -10000
==17947== 
==17947== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17947== malloc/free: in use at exit: 39367 bytes in 19 blocks.
==17947== malloc/free: 5171 allocs, 5152 frees, 13430766 bytes allocated.
==17947== For counts of detected errors, rerun with: -v
==17947== searching for pointers to 19 not-freed blocks.
==17947== checked 7057780 bytes.
==17947== 
==17947== LEAK SUMMARY:
==17947==    definitely lost: 0 bytes in 0 blocks.
==17947==    possibly lost:   0 bytes in 0 blocks.
==17947==    still reachable: 39367 bytes in 19 blocks.
==17947==         suppressed: 0 bytes in 0 blocks.
==17947== Reachable blocks (those to which a pointer was found) are not shown.
==17947== To see them, rerun with: --show-reachable=yes
==17947== 
 
     ...Executing beam_hex8_test...
==17976== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17976== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17976== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17976== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17976== Estimated CPU clock rate is 2811 MHz
==17976== For more details, rerun with: -v
==17976== 
==17976== 
==17976== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17976== malloc/free: in use at exit: 14055 bytes in 12 blocks.
==17976== malloc/free: 1147 allocs, 1135 frees, 2782940 bytes allocated.
==17976== For counts of detected errors, rerun with: -v
==17976== searching for pointers to 12 not-freed blocks.
==17976== checked 7036952 bytes.
==17976== 
==17976== LEAK SUMMARY:
==17976==    definitely lost: 0 bytes in 0 blocks.
==17976==    possibly lost:   0 bytes in 0 blocks.
==17976==    still reachable: 14055 bytes in 12 blocks.
==17976==         suppressed: 0 bytes in 0 blocks.
==17976== Reachable blocks (those to which a pointer was found) are not shown.
==17976== To see them, rerun with: --show-reachable=yes
==17976== 
 
     ...Executing beam_quad4_2_test...
==17995== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==17995== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==17995== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==17995== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==17995== Estimated CPU clock rate is 2810 MHz
==17995== For more details, rerun with: -v
==17995== 
==17995== 
==17995== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==17995== malloc/free: in use at exit: 12963 bytes in 12 blocks.
==17995== malloc/free: 1103 allocs, 1091 frees, 418240 bytes allocated.
==17995== For counts of detected errors, rerun with: -v
==17995== searching for pointers to 12 not-freed blocks.
==17995== checked 7032692 bytes.
==17995== 
==17995== LEAK SUMMARY:
==17995==    definitely lost: 0 bytes in 0 blocks.
==17995==    possibly lost:   0 bytes in 0 blocks.
==17995==    still reachable: 12963 bytes in 12 blocks.
==17995==         suppressed: 0 bytes in 0 blocks.
==17995== Reachable blocks (those to which a pointer was found) are not shown.
==17995== To see them, rerun with: --show-reachable=yes
==17995== 
 
     ...Executing beam_quad4_test...
==18004== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18004== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18004== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18004== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18004== Estimated CPU clock rate is 2827 MHz
==18004== For more details, rerun with: -v
==18004== 
==18004== 
==18004== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18004== malloc/free: in use at exit: 12963 bytes in 12 blocks.
==18004== malloc/free: 1139 allocs, 1127 frees, 428661 bytes allocated.
==18004== For counts of detected errors, rerun with: -v
==18004== searching for pointers to 12 not-freed blocks.
==18004== checked 7033844 bytes.
==18004== 
==18004== LEAK SUMMARY:
==18004==    definitely lost: 0 bytes in 0 blocks.
==18004==    possibly lost:   0 bytes in 0 blocks.
==18004==    still reachable: 12963 bytes in 12 blocks.
==18004==         suppressed: 0 bytes in 0 blocks.
==18004== Reachable blocks (those to which a pointer was found) are not shown.
==18004== To see them, rerun with: --show-reachable=yes
==18004== 
 
     ...Executing beam_quad8_2_test...
==18013== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18013== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18013== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18013== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18013== Estimated CPU clock rate is 2804 MHz
==18013== For more details, rerun with: -v
==18013== 
==18013== 
==18013== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18013== malloc/free: in use at exit: 13327 bytes in 12 blocks.
==18013== malloc/free: 1115 allocs, 1103 frees, 1078380 bytes allocated.
==18013== For counts of detected errors, rerun with: -v
==18013== searching for pointers to 12 not-freed blocks.
==18013== checked 7042560 bytes.
==18013== 
==18013== LEAK SUMMARY:
==18013==    definitely lost: 0 bytes in 0 blocks.
==18013==    possibly lost:   0 bytes in 0 blocks.
==18013==    still reachable: 13327 bytes in 12 blocks.
==18013==         suppressed: 0 bytes in 0 blocks.
==18013== Reachable blocks (those to which a pointer was found) are not shown.
==18013== To see them, rerun with: --show-reachable=yes
==18013== 
 
     ...Executing beam_quad8_test...
==18022== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18022== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18022== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18022== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18022== Estimated CPU clock rate is 2804 MHz
==18022== For more details, rerun with: -v
==18022== 
==18022== 
==18022== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18022== malloc/free: in use at exit: 13327 bytes in 12 blocks.
==18022== malloc/free: 1151 allocs, 1139 frees, 1098985 bytes allocated.
==18022== For counts of detected errors, rerun with: -v
==18022== searching for pointers to 12 not-freed blocks.
==18022== checked 7043712 bytes.
==18022== 
==18022== LEAK SUMMARY:
==18022==    definitely lost: 0 bytes in 0 blocks.
==18022==    possibly lost:   0 bytes in 0 blocks.
==18022==    still reachable: 13327 bytes in 12 blocks.
==18022==         suppressed: 0 bytes in 0 blocks.
==18022== Reachable blocks (those to which a pointer was found) are not shown.
==18022== To see them, rerun with: --show-reachable=yes
==18022== 
 
     ...Executing beam_tet4_test...
==18033== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18033== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18033== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18033== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18033== Estimated CPU clock rate is 2833 MHz
==18033== For more details, rerun with: -v
==18033== 
Currently Tet4 elements are not being checked for negative volumes.
==18033== 
==18033== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18033== malloc/free: in use at exit: 14055 bytes in 12 blocks.
==18033== malloc/free: 1456 allocs, 1444 frees, 1440454 bytes allocated.
==18033== For counts of detected errors, rerun with: -v
==18033== searching for pointers to 12 not-freed blocks.
==18033== checked 7036056 bytes.
==18033== 
==18033== LEAK SUMMARY:
==18033==    definitely lost: 0 bytes in 0 blocks.
==18033==    possibly lost:   0 bytes in 0 blocks.
==18033==    still reachable: 14055 bytes in 12 blocks.
==18033==         suppressed: 0 bytes in 0 blocks.
==18033== Reachable blocks (those to which a pointer was found) are not shown.
==18033== To see them, rerun with: --show-reachable=yes
==18033== 
 
     ...Executing beam_tria3_2_test...
==18043== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18043== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18043== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18043== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18043== Estimated CPU clock rate is 2799 MHz
==18043== For more details, rerun with: -v
==18043== 
==18043== 
==18043== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18043== malloc/free: in use at exit: 12963 bytes in 12 blocks.
==18043== malloc/free: 1121 allocs, 1109 frees, 401347 bytes allocated.
==18043== For counts of detected errors, rerun with: -v
==18043== searching for pointers to 12 not-freed blocks.
==18043== checked 7036244 bytes.
==18043== 
==18043== LEAK SUMMARY:
==18043==    definitely lost: 0 bytes in 0 blocks.
==18043==    possibly lost:   0 bytes in 0 blocks.
==18043==    still reachable: 12963 bytes in 12 blocks.
==18043==         suppressed: 0 bytes in 0 blocks.
==18043== Reachable blocks (those to which a pointer was found) are not shown.
==18043== To see them, rerun with: --show-reachable=yes
==18043== 
 
     ...Executing beam_tria3_test...
==18052== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18052== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18052== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18052== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18052== Estimated CPU clock rate is 2804 MHz
==18052== For more details, rerun with: -v
==18052== 
==18052== 
==18052== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18052== malloc/free: in use at exit: 12963 bytes in 12 blocks.
==18052== malloc/free: 1197 allocs, 1185 frees, 417528 bytes allocated.
==18052== For counts of detected errors, rerun with: -v
==18052== searching for pointers to 12 not-freed blocks.
==18052== checked 7029204 bytes.
==18052== 
==18052== LEAK SUMMARY:
==18052==    definitely lost: 0 bytes in 0 blocks.
==18052==    possibly lost:   0 bytes in 0 blocks.
==18052==    still reachable: 12963 bytes in 12 blocks.
==18052==         suppressed: 0 bytes in 0 blocks.
==18052== Reachable blocks (those to which a pointer was found) are not shown.
==18052== To see them, rerun with: --show-reachable=yes
==18052== 
 
     ...Executing beam_tria6_2_test...
==18062== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18062== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18062== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18062== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18062== Estimated CPU clock rate is 2807 MHz
==18062== For more details, rerun with: -v
==18062== 
==18062== 
==18062== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18062== malloc/free: in use at exit: 13467 bytes in 12 blocks.
==18062== malloc/free: 1137 allocs, 1125 frees, 1359431 bytes allocated.
==18062== For counts of detected errors, rerun with: -v
==18062== searching for pointers to 12 not-freed blocks.
==18062== checked 7033580 bytes.
==18062== 
==18062== LEAK SUMMARY:
==18062==    definitely lost: 0 bytes in 0 blocks.
==18062==    possibly lost:   0 bytes in 0 blocks.
==18062==    still reachable: 13467 bytes in 12 blocks.
==18062==         suppressed: 0 bytes in 0 blocks.
==18062== Reachable blocks (those to which a pointer was found) are not shown.
==18062== To see them, rerun with: --show-reachable=yes
==18062== 
 
     ...Executing beam_tria6_test...
==18071== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18071== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18071== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18071== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18071== Estimated CPU clock rate is 2832 MHz
==18071== For more details, rerun with: -v
==18071== 
==18071== 
==18071== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18071== malloc/free: in use at exit: 13467 bytes in 12 blocks.
==18071== malloc/free: 1213 allocs, 1201 frees, 1390996 bytes allocated.
==18071== For counts of detected errors, rerun with: -v
==18071== searching for pointers to 12 not-freed blocks.
==18071== checked 7034732 bytes.
==18071== 
==18071== LEAK SUMMARY:
==18071==    definitely lost: 0 bytes in 0 blocks.
==18071==    possibly lost:   0 bytes in 0 blocks.
==18071==    still reachable: 13467 bytes in 12 blocks.
==18071==         suppressed: 0 bytes in 0 blocks.
==18071== Reachable blocks (those to which a pointer was found) are not shown.
==18071== To see them, rerun with: --show-reachable=yes
==18071== 
 
     ...Executing beam_wedge6_test...
==18080== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18080== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18080== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18080== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18080== Estimated CPU clock rate is 2807 MHz
==18080== For more details, rerun with: -v
==18080== 
==18080== 
==18080== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18080== malloc/free: in use at exit: 14055 bytes in 12 blocks.
==18080== malloc/free: 1213 allocs, 1201 frees, 2088332 bytes allocated.
==18080== For counts of detected errors, rerun with: -v
==18080== searching for pointers to 12 not-freed blocks.
==18080== checked 7033896 bytes.
==18080== 
==18080== LEAK SUMMARY:
==18080==    definitely lost: 0 bytes in 0 blocks.
==18080==    possibly lost:   0 bytes in 0 blocks.
==18080==    still reachable: 14055 bytes in 12 blocks.
==18080==         suppressed: 0 bytes in 0 blocks.
==18080== Reachable blocks (those to which a pointer was found) are not shown.
==18080== To see them, rerun with: --show-reachable=yes
==18080== 
 
     ...Executing half_pipe_wedge15_test...
==18091== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18091== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18091== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18091== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18091== Estimated CPU clock rate is 2828 MHz
==18091== For more details, rerun with: -v
==18091== 
==18091== 
==18091== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18091== malloc/free: in use at exit: 14727 bytes in 12 blocks.
==18091== malloc/free: 1402 allocs, 1390 frees, 6625335 bytes allocated.
==18091== For counts of detected errors, rerun with: -v
==18091== searching for pointers to 12 not-freed blocks.
==18091== checked 7035976 bytes.
==18091== 
==18091== LEAK SUMMARY:
==18091==    definitely lost: 0 bytes in 0 blocks.
==18091==    possibly lost:   0 bytes in 0 blocks.
==18091==    still reachable: 14727 bytes in 12 blocks.
==18091==         suppressed: 0 bytes in 0 blocks.
==18091== Reachable blocks (those to which a pointer was found) are not shown.
==18091== To see them, rerun with: --show-reachable=yes
==18091== 
 
     ...Executing blkdmp_test...
==18206== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18206== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18206== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18206== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18206== Estimated CPU clock rate is 2798 MHz
==18206== For more details, rerun with: -v
==18206== 
==18206== 
==18206== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18206== malloc/free: in use at exit: 19196 bytes in 20 blocks.
==18206== malloc/free: 2622 allocs, 2602 frees, 1554919 bytes allocated.
==18206== For counts of detected errors, rerun with: -v
==18206== searching for pointers to 20 not-freed blocks.
==18206== checked 7038760 bytes.
==18206== 
==18206== LEAK SUMMARY:
==18206==    definitely lost: 0 bytes in 0 blocks.
==18206==    possibly lost:   0 bytes in 0 blocks.
==18206==    still reachable: 19196 bytes in 20 blocks.
==18206==         suppressed: 0 bytes in 0 blocks.
==18206== Reachable blocks (those to which a pointer was found) are not shown.
==18206== To see them, rerun with: --show-reachable=yes
==18206== 
 
     ...Executing gen_alpha1_test...
==18232== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18232== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18232== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18232== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18232== Estimated CPU clock rate is 2827 MHz
==18232== For more details, rerun with: -v
==18232== 
==18232== 
==18232== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18232== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==18232== malloc/free: 3994 allocs, 3974 frees, 18637035 bytes allocated.
==18232== For counts of detected errors, rerun with: -v
==18232== searching for pointers to 20 not-freed blocks.
==18232== checked 7064284 bytes.
==18232== 
==18232== LEAK SUMMARY:
==18232==    definitely lost: 0 bytes in 0 blocks.
==18232==    possibly lost:   0 bytes in 0 blocks.
==18232==    still reachable: 41393 bytes in 20 blocks.
==18232==         suppressed: 0 bytes in 0 blocks.
==18232== Reachable blocks (those to which a pointer was found) are not shown.
==18232== To see them, rerun with: --show-reachable=yes
==18232== 
 
     ...Executing gen_alpha2_modaldamping_test...
==18247== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18247== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18247== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18247== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18247== Estimated CPU clock rate is 2829 MHz
==18247== For more details, rerun with: -v
==18247== 
Generating Eigen Solution for modal based solution
==18247== 
==18247== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18247== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==18247== malloc/free: 4117 allocs, 4097 frees, 21257981 bytes allocated.
==18247== For counts of detected errors, rerun with: -v
==18247== searching for pointers to 20 not-freed blocks.
==18247== checked 7058028 bytes.
==18247== 
==18247== LEAK SUMMARY:
==18247==    definitely lost: 0 bytes in 0 blocks.
==18247==    possibly lost:   0 bytes in 0 blocks.
==18247==    still reachable: 41393 bytes in 20 blocks.
==18247==         suppressed: 0 bytes in 0 blocks.
==18247== Reachable blocks (those to which a pointer was found) are not shown.
==18247== To see them, rerun with: --show-reachable=yes
==18247== 
 
     ...Executing gen_alpha2_test...
==18433== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18433== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18433== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18433== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18433== Estimated CPU clock rate is 2819 MHz
==18433== For more details, rerun with: -v
==18433== 
==18433== 
==18433== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18433== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==18433== malloc/free: 3994 allocs, 3974 frees, 18637036 bytes allocated.
==18433== For counts of detected errors, rerun with: -v
==18433== searching for pointers to 20 not-freed blocks.
==18433== checked 7057244 bytes.
==18433== 
==18433== LEAK SUMMARY:
==18433==    definitely lost: 0 bytes in 0 blocks.
==18433==    possibly lost:   0 bytes in 0 blocks.
==18433==    still reachable: 41393 bytes in 20 blocks.
==18433==         suppressed: 0 bytes in 0 blocks.
==18433== Reachable blocks (those to which a pointer was found) are not shown.
==18433== To see them, rerun with: --show-reachable=yes
==18433== 
 
     ...Executing gen_alpha3_test...
==18450== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18450== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18450== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18450== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18450== Estimated CPU clock rate is 2823 MHz
==18450== For more details, rerun with: -v
==18450== 
==18450== 
==18450== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18450== malloc/free: in use at exit: 41393 bytes in 20 blocks.
==18450== malloc/free: 2455 allocs, 2435 frees, 9138674 bytes allocated.
==18450== For counts of detected errors, rerun with: -v
==18450== searching for pointers to 20 not-freed blocks.
==18450== checked 7059420 bytes.
==18450== 
==18450== LEAK SUMMARY:
==18450==    definitely lost: 0 bytes in 0 blocks.
==18450==    possibly lost:   0 bytes in 0 blocks.
==18450==    still reachable: 41393 bytes in 20 blocks.
==18450==         suppressed: 0 bytes in 0 blocks.
==18450== Reachable blocks (those to which a pointer was found) are not shown.
==18450== To see them, rerun with: --show-reachable=yes
==18450== 
 
     ...Executing vepatch_test...
==18460== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18460== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18460== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18460== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18460== Estimated CPU clock rate is 2832 MHz
==18460== For more details, rerun with: -v
==18460== 
==18460== 
==18460== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18460== malloc/free: in use at exit: 19196 bytes in 20 blocks.
==18460== malloc/free: 4930 allocs, 4910 frees, 3113740 bytes allocated.
==18460== For counts of detected errors, rerun with: -v
==18460== searching for pointers to 20 not-freed blocks.
==18460== checked 7038504 bytes.
==18460== 
==18460== LEAK SUMMARY:
==18460==    definitely lost: 0 bytes in 0 blocks.
==18460==    possibly lost:   0 bytes in 0 blocks.
==18460==    still reachable: 19196 bytes in 20 blocks.
==18460==         suppressed: 0 bytes in 0 blocks.
==18460== Reachable blocks (those to which a pointer was found) are not shown.
==18460== To see them, rerun with: --show-reachable=yes
==18460== 
 
     ...Executing sphere600_test...
==18484== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18484== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18484== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18484== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18484== Estimated CPU clock rate is 2796 MHz
==18484== For more details, rerun with: -v
==18484== 
==18484== 
==18484== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18484== malloc/free: in use at exit: 62625 bytes in 16 blocks.
==18484== malloc/free: 1750 allocs, 1734 frees, 12509825 bytes allocated.
==18484== For counts of detected errors, rerun with: -v
==18484== searching for pointers to 16 not-freed blocks.
==18484== checked 7085008 bytes.
==18484== 
==18484== LEAK SUMMARY:
==18484==    definitely lost: 0 bytes in 0 blocks.
==18484==    possibly lost:   0 bytes in 0 blocks.
==18484==    still reachable: 62625 bytes in 16 blocks.
==18484==         suppressed: 0 bytes in 0 blocks.
==18484== Reachable blocks (those to which a pointer was found) are not shown.
==18484== To see them, rerun with: --show-reachable=yes
==18484== 
 
     ...Executing tri-beam_nlstatics_test...
==18522== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==18522== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==18522== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==18522== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==18522== Estimated CPU clock rate is 2793 MHz
==18522== For more details, rerun with: -v
==18522== 
	--- Newton Method Parameters ---
	max_newton_iterations = 100
	num_newton_load_steps = 100
	            tolerance = 1e-08
	       update_tangent = 1
==18522== 
==18522== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==18522== malloc/free: in use at exit: 13327 bytes in 12 blocks.
==18522== malloc/free: 64279 allocs, 64267 frees, 714510453 bytes allocated.
==18522== For counts of detected errors, rerun with: -v
==18522== searching for pointers to 12 not-freed blocks.
==18522== checked 7032400 bytes.
==18522== 
==18522== LEAK SUMMARY:
==18522==    definitely lost: 0 bytes in 0 blocks.
==18522==    possibly lost:   0 bytes in 0 blocks.
==18522==    still reachable: 13327 bytes in 12 blocks.
==18522==         suppressed: 0 bytes in 0 blocks.
==18522== Reachable blocks (those to which a pointer was found) are not shown.
==18522== To see them, rerun with: --show-reachable=yes
==18522== 
 
     ...Executing tri-beam_test...
==24653== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==24653== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==24653== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==24653== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==24653== Estimated CPU clock rate is 2793 MHz
==24653== For more details, rerun with: -v
==24653== 
==24653== 
==24653== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==24653== malloc/free: in use at exit: 13327 bytes in 12 blocks.
==24653== malloc/free: 1239 allocs, 1227 frees, 1074360 bytes allocated.
==24653== For counts of detected errors, rerun with: -v
==24653== searching for pointers to 12 not-freed blocks.
==24653== checked 7030720 bytes.
==24653== 
==24653== LEAK SUMMARY:
==24653==    definitely lost: 0 bytes in 0 blocks.
==24653==    possibly lost:   0 bytes in 0 blocks.
==24653==    still reachable: 13327 bytes in 12 blocks.
==24653==         suppressed: 0 bytes in 0 blocks.
==24653== Reachable blocks (those to which a pointer was found) are not shown.
==24653== To see them, rerun with: --show-reachable=yes
==24653== 
 
     ...Executing tria6_beam_eig_test...
==24667== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==24667== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==24667== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==24667== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==24667== Estimated CPU clock rate is 2794 MHz
==24667== For more details, rerun with: -v
==24667== 
==24667== 
==24667== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==24667== malloc/free: in use at exit: 28650 bytes in 16 blocks.
==24667== malloc/free: 1120 allocs, 1104 frees, 2395973 bytes allocated.
==24667== For counts of detected errors, rerun with: -v
==24667== searching for pointers to 16 not-freed blocks.
==24667== checked 7050440 bytes.
==24667== 
==24667== LEAK SUMMARY:
==24667==    definitely lost: 0 bytes in 0 blocks.
==24667==    possibly lost:   0 bytes in 0 blocks.
==24667==    still reachable: 28650 bytes in 16 blocks.
==24667==         suppressed: 0 bytes in 0 blocks.
==24667== Reachable blocks (those to which a pointer was found) are not shown.
==24667== To see them, rerun with: --show-reachable=yes
==24667== 
 
     ...Executing tria6_beam_nlstatics_test...
==24681== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==24681== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==24681== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==24681== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==24681== Estimated CPU clock rate is 2823 MHz
==24681== For more details, rerun with: -v
==24681== 
==24681== 
==24681== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==24681== malloc/free: in use at exit: 13467 bytes in 12 blocks.
==24681== malloc/free: 48289 allocs, 48277 frees, 694045501 bytes allocated.
==24681== For counts of detected errors, rerun with: -v
==24681== searching for pointers to 12 not-freed blocks.
==24681== checked 7037052 bytes.
==24681== 
==24681== LEAK SUMMARY:
==24681==    definitely lost: 0 bytes in 0 blocks.
==24681==    possibly lost:   0 bytes in 0 blocks.
==24681==    still reachable: 13467 bytes in 12 blocks.
==24681==         suppressed: 0 bytes in 0 blocks.
==24681== Reachable blocks (those to which a pointer was found) are not shown.
==24681== To see them, rerun with: --show-reachable=yes
==24681== 
 
     ...Executing tria6_beam_statics_test...
==25667== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25667== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25667== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25667== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25667== Estimated CPU clock rate is 2807 MHz
==25667== For more details, rerun with: -v
==25667== 
==25667== 
==25667== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25667== malloc/free: in use at exit: 13467 bytes in 12 blocks.
==25667== malloc/free: 949 allocs, 937 frees, 1456018 bytes allocated.
==25667== For counts of detected errors, rerun with: -v
==25667== searching for pointers to 12 not-freed blocks.
==25667== checked 7032188 bytes.
==25667== 
==25667== LEAK SUMMARY:
==25667==    definitely lost: 0 bytes in 0 blocks.
==25667==    possibly lost:   0 bytes in 0 blocks.
==25667==    still reachable: 13467 bytes in 12 blocks.
==25667==         suppressed: 0 bytes in 0 blocks.
==25667== Reachable blocks (those to which a pointer was found) are not shown.
==25667== To see them, rerun with: --show-reachable=yes
==25667== 
 
     ...Executing sphere600_triashell_test...
==25681== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25681== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25681== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25681== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25681== Estimated CPU clock rate is 2796 MHz
==25681== For more details, rerun with: -v
==25681== 
==25681== 
==25681== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25681== malloc/free: in use at exit: 15042 bytes in 12 blocks.
==25681== malloc/free: 1749 allocs, 1737 frees, 12363869 bytes allocated.
==25681== For counts of detected errors, rerun with: -v
==25681== searching for pointers to 12 not-freed blocks.
==25681== checked 7032948 bytes.
==25681== 
==25681== LEAK SUMMARY:
==25681==    definitely lost: 0 bytes in 0 blocks.
==25681==    possibly lost:   0 bytes in 0 blocks.
==25681==    still reachable: 15042 bytes in 12 blocks.
==25681==         suppressed: 0 bytes in 0 blocks.
==25681== Reachable blocks (those to which a pointer was found) are not shown.
==25681== To see them, rerun with: --show-reachable=yes
==25681== 
 
     ...Executing tri-beam-triashell_test...
==25714== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25714== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25714== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25714== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25714== Estimated CPU clock rate is 2819 MHz
==25714== For more details, rerun with: -v
==25714== 
==25714== 
==25714== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25714== malloc/free: in use at exit: 13327 bytes in 12 blocks.
==25714== malloc/free: 1239 allocs, 1227 frees, 1087656 bytes allocated.
==25714== For counts of detected errors, rerun with: -v
==25714== searching for pointers to 12 not-freed blocks.
==25714== checked 7035456 bytes.
==25714== 
==25714== LEAK SUMMARY:
==25714==    definitely lost: 0 bytes in 0 blocks.
==25714==    possibly lost:   0 bytes in 0 blocks.
==25714==    still reachable: 13327 bytes in 12 blocks.
==25714==         suppressed: 0 bytes in 0 blocks.
==25714== Reachable blocks (those to which a pointer was found) are not shown.
==25714== To see them, rerun with: --show-reachable=yes
==25714== 
 
     ...Executing truss32_eigen_test...
==25728== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25728== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25728== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25728== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25728== Estimated CPU clock rate is 2812 MHz
==25728== For more details, rerun with: -v
==25728== 
==25728== 
==25728== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25728== malloc/free: in use at exit: 13152 bytes in 12 blocks.
==25728== malloc/free: 1343 allocs, 1331 frees, 817000 bytes allocated.
==25728== For counts of detected errors, rerun with: -v
==25728== searching for pointers to 12 not-freed blocks.
==25728== checked 7028884 bytes.
==25728== 
==25728== LEAK SUMMARY:
==25728==    definitely lost: 0 bytes in 0 blocks.
==25728==    possibly lost:   0 bytes in 0 blocks.
==25728==    still reachable: 13152 bytes in 12 blocks.
==25728==         suppressed: 0 bytes in 0 blocks.
==25728== Reachable blocks (those to which a pointer was found) are not shown.
==25728== To see them, rerun with: --show-reachable=yes
==25728== 
 
     ...Executing truss32_statics_test...
==25741== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25741== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25741== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25741== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25741== Estimated CPU clock rate is 2793 MHz
==25741== For more details, rerun with: -v
==25741== 
==25741== 
==25741== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25741== malloc/free: in use at exit: 13152 bytes in 12 blocks.
==25741== malloc/free: 1163 allocs, 1151 frees, 212883 bytes allocated.
==25741== For counts of detected errors, rerun with: -v
==25741== searching for pointers to 12 not-freed blocks.
==25741== checked 7030564 bytes.
==25741== 
==25741== LEAK SUMMARY:
==25741==    definitely lost: 0 bytes in 0 blocks.
==25741==    possibly lost:   0 bytes in 0 blocks.
==25741==    still reachable: 13152 bytes in 12 blocks.
==25741==         suppressed: 0 bytes in 0 blocks.
==25741== Reachable blocks (those to which a pointer was found) are not shown.
==25741== To see them, rerun with: --show-reachable=yes
==25741== 
 
     ...Executing truss_nlstatics_test...
==25761== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25761== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25761== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25761== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25761== Estimated CPU clock rate is 2798 MHz
==25761== For more details, rerun with: -v
==25761== 
==25761== 
==25761== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25761== malloc/free: in use at exit: 12753 bytes in 12 blocks.
==25761== malloc/free: 1131 allocs, 1119 frees, 89637 bytes allocated.
==25761== For counts of detected errors, rerun with: -v
==25761== searching for pointers to 12 not-freed blocks.
==25761== checked 7033380 bytes.
==25761== 
==25761== LEAK SUMMARY:
==25761==    definitely lost: 0 bytes in 0 blocks.
==25761==    possibly lost:   0 bytes in 0 blocks.
==25761==    still reachable: 12753 bytes in 12 blocks.
==25761==         suppressed: 0 bytes in 0 blocks.
==25761== Reachable blocks (those to which a pointer was found) are not shown.
==25761== To see them, rerun with: --show-reachable=yes
==25761== 
 
     ...Executing wedge_pure_bend_static_test...
==25771== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25771== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25771== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25771== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25771== Estimated CPU clock rate is 2816 MHz
==25771== For more details, rerun with: -v
==25771== 
==25771== 
==25771== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25771== malloc/free: in use at exit: 57668 bytes in 633 blocks.
==25771== malloc/free: 2862 allocs, 2229 frees, 3002717 bytes allocated.
==25771== For counts of detected errors, rerun with: -v
==25771== searching for pointers to 633 not-freed blocks.
==25771== checked 7070644 bytes.
==25771== 
==25771== LEAK SUMMARY:
==25771==    definitely lost: 0 bytes in 0 blocks.
==25771==    possibly lost:   0 bytes in 0 blocks.
==25771==    still reachable: 57668 bytes in 633 blocks.
==25771==         suppressed: 0 bytes in 0 blocks.
==25771== Reachable blocks (those to which a pointer was found) are not shown.
==25771== To see them, rerun with: --show-reachable=yes
==25771== 
 
     ...Executing wedge6_small_eigen_test...
==25784== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25784== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25784== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25784== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25784== Estimated CPU clock rate is 2796 MHz
==25784== For more details, rerun with: -v
==25784== 
==25784== 
==25784== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25784== malloc/free: in use at exit: 12900 bytes in 12 blocks.
==25784== malloc/free: 1023 allocs, 1011 frees, 819084 bytes allocated.
==25784== For counts of detected errors, rerun with: -v
==25784== searching for pointers to 12 not-freed blocks.
==25784== checked 7035816 bytes.
==25784== 
==25784== LEAK SUMMARY:
==25784==    definitely lost: 0 bytes in 0 blocks.
==25784==    possibly lost:   0 bytes in 0 blocks.
==25784==    still reachable: 12900 bytes in 12 blocks.
==25784==         suppressed: 0 bytes in 0 blocks.
==25784== Reachable blocks (those to which a pointer was found) are not shown.
==25784== To see them, rerun with: --show-reachable=yes
==25784== 
 
     ...Executing wedge6_small_statics_test...
==25797== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25797== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25797== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25797== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25797== Estimated CPU clock rate is 2830 MHz
==25797== For more details, rerun with: -v
==25797== 
==25797== 
==25797== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25797== malloc/free: in use at exit: 12900 bytes in 12 blocks.
==25797== malloc/free: 854 allocs, 842 frees, 253367 bytes allocated.
==25797== For counts of detected errors, rerun with: -v
==25797== searching for pointers to 12 not-freed blocks.
==25797== checked 7029288 bytes.
==25797== 
==25797== LEAK SUMMARY:
==25797==    definitely lost: 0 bytes in 0 blocks.
==25797==    possibly lost:   0 bytes in 0 blocks.
==25797==    still reachable: 12900 bytes in 12 blocks.
==25797==         suppressed: 0 bytes in 0 blocks.
==25797== Reachable blocks (those to which a pointer was found) are not shown.
==25797== To see them, rerun with: --show-reachable=yes
==25797== 
 
     ...Executing wtest6_test...
==25811== Memcheck, a.k.a. Valgrind, a memory error detector for x86-linux.
==25811== Copyright (C) 2002, and GNU GPL'd, by Julian Seward.
==25811== Using valgrind-1.9.6, a program instrumentation system for x86-linux.
==25811== Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.
==25811== Estimated CPU clock rate is 2816 MHz
==25811== For more details, rerun with: -v
==25811== 
==25811== 
==25811== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==25811== malloc/free: in use at exit: 13908 bytes in 12 blocks.
==25811== malloc/free: 1230 allocs, 1218 frees, 2995872 bytes allocated.
==25811== For counts of detected errors, rerun with: -v
==25811== searching for pointers to 12 not-freed blocks.
==25811== checked 7032072 bytes.
==25811== 
==25811== LEAK SUMMARY:
==25811==    definitely lost: 0 bytes in 0 blocks.
==25811==    possibly lost:   0 bytes in 0 blocks.
==25811==    still reachable: 13908 bytes in 12 blocks.
==25811==         suppressed: 0 bytes in 0 blocks.
==25811== Reachable blocks (those to which a pointer was found) are not shown.
==25811== To see them, rerun with: --show-reachable=yes
==25811== 
 
     ...Reading failures and passes...


	We had 0 failures and 647 passes out of 647 comparisons.

 
     ...Type 'clean up' to clean up residual & temp files...
     ...Cleaning Grope Files...
     ...Cleaning Log Files...
     ...Cleaning Exodus Output Files...
     ...Cleaning Temporary Files...
 
 
 
     ...The results are stored in Log_Test_Suite...
 
 
status=0