Want more features on Pastebin? Sign Up, it's FREE!
Guest

prog1B.cpp

By: a guest on Jan 21st, 2014  |  syntax: C++  |  size: 244.27 KB  |  views: 17,593  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string>
  4. #include <cstdint>
  5. #include <cstdlib>
  6. #include <stdexcept>
  7. #include <exception>
  8. using std::cin;
  9. using std::cout;
  10. using std::endl;
  11. class FileNameTooLong :
  12.         public std::exception
  13. {
  14. public:
  15.         virtual const char* what() const throw()
  16.         {
  17.                 return "Sorry; filename must be 80 chars or less.\n";
  18.         }
  19. };
  20. class CouldNotOpenFile :
  21.         public std::exception
  22. {
  23. public:
  24.         virtual const char* what() const throw()
  25.         {
  26.                 return "Sorry, couldn't open file.\n";
  27.         }
  28. };
  29. class BadEntry :
  30.         public std::exception
  31. {
  32. public:
  33.         virtual const char* what() const throw()
  34.         {
  35.                 return "Sorry, that's a bad entry.\n";
  36.         }
  37. };
  38. void read( const std::string FILENAME )
  39. {
  40.         std::ifstream inFile;
  41.         uint8_t filename_size;
  42.         filename_size = FILENAME.length();
  43.         ++filename_size;
  44.         void* filename_c_str_ptr;
  45.         char* filename_c_str;
  46.         filename_c_str_ptr = malloc( filename_size );
  47.         filename_c_str = (char*) filename_c_str_ptr;
  48.         filename_c_str_ptr = nullptr;
  49.         size_t i;
  50.         i = 0;
  51.         char* filename_c_str_iter;
  52.         filename_c_str_iter = filename_c_str;
  53.         char c;
  54.         if( i < filename_size )
  55.         {
  56.                 try
  57.                 {
  58.                         c = FILENAME.at( i );
  59.                 }
  60.                 catch( std::out_of_range& e )
  61.                 {
  62.                         c = 0;
  63.                 }
  64.                 *filename_c_str_iter = c;
  65.                 ++i;
  66.                 ++filename_c_str_iter;
  67.         }
  68.         if( i < filename_size )
  69.         {
  70.                 try
  71.                 {
  72.                         c = FILENAME.at( i );
  73.                 }
  74.                 catch( std::out_of_range& e )
  75.                 {
  76.                         c = 0;
  77.                 }
  78.                 *filename_c_str_iter = c;
  79.                 ++i;
  80.                 ++filename_c_str_iter;
  81.         }
  82.         if( i < filename_size )
  83.         {
  84.                 try
  85.                 {
  86.                         c = FILENAME.at( i );
  87.                 }
  88.                 catch( std::out_of_range& e )
  89.                 {
  90.                         c = 0;
  91.                 }
  92.                 *filename_c_str_iter = c;
  93.                 ++i;
  94.                 ++filename_c_str_iter;
  95.         }
  96.         if( i < filename_size )
  97.         {
  98.                 try
  99.                 {
  100.                         c = FILENAME.at( i );
  101.                 }
  102.                 catch( std::out_of_range& e )
  103.                 {
  104.                         c = 0;
  105.                 }
  106.                 *filename_c_str_iter = c;
  107.                 ++i;
  108.                 ++filename_c_str_iter;
  109.         }
  110.         if( i < filename_size )
  111.         {
  112.                 try
  113.                 {
  114.                         c = FILENAME.at( i );
  115.                 }
  116.                 catch( std::out_of_range& e )
  117.                 {
  118.                         c = 0;
  119.                 }
  120.                 *filename_c_str_iter = c;
  121.                 ++i;
  122.                 ++filename_c_str_iter;
  123.         }
  124.         if( i < filename_size )
  125.         {
  126.                 try
  127.                 {
  128.                         c = FILENAME.at( i );
  129.                 }
  130.                 catch( std::out_of_range& e )
  131.                 {
  132.                         c = 0;
  133.                 }
  134.                 *filename_c_str_iter = c;
  135.                 ++i;
  136.                 ++filename_c_str_iter;
  137.         }
  138.         if( i < filename_size )
  139.         {
  140.                 try
  141.                 {
  142.                         c = FILENAME.at( i );
  143.                 }
  144.                 catch( std::out_of_range& e )
  145.                 {
  146.                         c = 0;
  147.                 }
  148.                 *filename_c_str_iter = c;
  149.                 ++i;
  150.                 ++filename_c_str_iter;
  151.         }
  152.         if( i < filename_size )
  153.         {
  154.                 try
  155.                 {
  156.                         c = FILENAME.at( i );
  157.                 }
  158.                 catch( std::out_of_range& e )
  159.                 {
  160.                         c = 0;
  161.                 }
  162.                 *filename_c_str_iter = c;
  163.                 ++i;
  164.                 ++filename_c_str_iter;
  165.         }
  166.         if( i < filename_size )
  167.         {
  168.                 try
  169.                 {
  170.                         c = FILENAME.at( i );
  171.                 }
  172.                 catch( std::out_of_range& e )
  173.                 {
  174.                         c = 0;
  175.                 }
  176.                 *filename_c_str_iter = c;
  177.                 ++i;
  178.                 ++filename_c_str_iter;
  179.         }
  180.         if( i < filename_size )
  181.         {
  182.                 try
  183.                 {
  184.                         c = FILENAME.at( i );
  185.                 }
  186.                 catch( std::out_of_range& e )
  187.                 {
  188.                         c = 0;
  189.                 }
  190.                 *filename_c_str_iter = c;
  191.                 ++i;
  192.                 ++filename_c_str_iter;
  193.         }
  194.         if( i < filename_size )
  195.         {
  196.                 try
  197.                 {
  198.                         c = FILENAME.at( i );
  199.                 }
  200.                 catch( std::out_of_range& e )
  201.                 {
  202.                         c = 0;
  203.                 }
  204.                 *filename_c_str_iter = c;
  205.                 ++i;
  206.                 ++filename_c_str_iter;
  207.         }
  208.         if( i < filename_size )
  209.         {
  210.                 try
  211.                 {
  212.                         c = FILENAME.at( i );
  213.                 }
  214.                 catch( std::out_of_range& e )
  215.                 {
  216.                         c = 0;
  217.                 }
  218.                 *filename_c_str_iter = c;
  219.                 ++i;
  220.                 ++filename_c_str_iter;
  221.         }
  222.         if( i < filename_size )
  223.         {
  224.                 try
  225.                 {
  226.                         c = FILENAME.at( i );
  227.                 }
  228.                 catch( std::out_of_range& e )
  229.                 {
  230.                         c = 0;
  231.                 }
  232.                 *filename_c_str_iter = c;
  233.                 ++i;
  234.                 ++filename_c_str_iter;
  235.         }
  236.         if( i < filename_size )
  237.         {
  238.                 try
  239.                 {
  240.                         c = FILENAME.at( i );
  241.                 }
  242.                 catch( std::out_of_range& e )
  243.                 {
  244.                         c = 0;
  245.                 }
  246.                 *filename_c_str_iter = c;
  247.                 ++i;
  248.                 ++filename_c_str_iter;
  249.         }
  250.         if( i < filename_size )
  251.         {
  252.                 try
  253.                 {
  254.                         c = FILENAME.at( i );
  255.                 }
  256.                 catch( std::out_of_range& e )
  257.                 {
  258.                         c = 0;
  259.                 }
  260.                 *filename_c_str_iter = c;
  261.                 ++i;
  262.                 ++filename_c_str_iter;
  263.         }
  264.         if( i < filename_size )
  265.         {
  266.                 try
  267.                 {
  268.                         c = FILENAME.at( i );
  269.                 }
  270.                 catch( std::out_of_range& e )
  271.                 {
  272.                         c = 0;
  273.                 }
  274.                 *filename_c_str_iter = c;
  275.                 ++i;
  276.                 ++filename_c_str_iter;
  277.         }
  278.         if( i < filename_size )
  279.         {
  280.                 try
  281.                 {
  282.                         c = FILENAME.at( i );
  283.                 }
  284.                 catch( std::out_of_range& e )
  285.                 {
  286.                         c = 0;
  287.                 }
  288.                 *filename_c_str_iter = c;
  289.                 ++i;
  290.                 ++filename_c_str_iter;
  291.         }
  292.         if( i < filename_size )
  293.         {
  294.                 try
  295.                 {
  296.                         c = FILENAME.at( i );
  297.                 }
  298.                 catch( std::out_of_range& e )
  299.                 {
  300.                         c = 0;
  301.                 }
  302.                 *filename_c_str_iter = c;
  303.                 ++i;
  304.                 ++filename_c_str_iter;
  305.         }
  306.         if( i < filename_size )
  307.         {
  308.                 try
  309.                 {
  310.                         c = FILENAME.at( i );
  311.                 }
  312.                 catch( std::out_of_range& e )
  313.                 {
  314.                         c = 0;
  315.                 }
  316.                 *filename_c_str_iter = c;
  317.                 ++i;
  318.                 ++filename_c_str_iter;
  319.         }
  320.         if( i < filename_size )
  321.         {
  322.                 try
  323.                 {
  324.                         c = FILENAME.at( i );
  325.                 }
  326.                 catch( std::out_of_range& e )
  327.                 {
  328.                         c = 0;
  329.                 }
  330.                 *filename_c_str_iter = c;
  331.                 ++i;
  332.                 ++filename_c_str_iter;
  333.         }
  334.         if( i < filename_size )
  335.         {
  336.                 try
  337.                 {
  338.                         c = FILENAME.at( i );
  339.                 }
  340.                 catch( std::out_of_range& e )
  341.                 {
  342.                         c = 0;
  343.                 }
  344.                 *filename_c_str_iter = c;
  345.                 ++i;
  346.                 ++filename_c_str_iter;
  347.         }
  348.         if( i < filename_size )
  349.         {
  350.                 try
  351.                 {
  352.                         c = FILENAME.at( i );
  353.                 }
  354.                 catch( std::out_of_range& e )
  355.                 {
  356.                         c = 0;
  357.                 }
  358.                 *filename_c_str_iter = c;
  359.                 ++i;
  360.                 ++filename_c_str_iter;
  361.         }
  362.         if( i < filename_size )
  363.         {
  364.                 try
  365.                 {
  366.                         c = FILENAME.at( i );
  367.                 }
  368.                 catch( std::out_of_range& e )
  369.                 {
  370.                         c = 0;
  371.                 }
  372.                 *filename_c_str_iter = c;
  373.                 ++i;
  374.                 ++filename_c_str_iter;
  375.         }
  376.         if( i < filename_size )
  377.         {
  378.                 try
  379.                 {
  380.                         c = FILENAME.at( i );
  381.                 }
  382.                 catch( std::out_of_range& e )
  383.                 {
  384.                         c = 0;
  385.                 }
  386.                 *filename_c_str_iter = c;
  387.                 ++i;
  388.                 ++filename_c_str_iter;
  389.         }
  390.         if( i < filename_size )
  391.         {
  392.                 try
  393.                 {
  394.                         c = FILENAME.at( i );
  395.                 }
  396.                 catch( std::out_of_range& e )
  397.                 {
  398.                         c = 0;
  399.                 }
  400.                 *filename_c_str_iter = c;
  401.                 ++i;
  402.                 ++filename_c_str_iter;
  403.         }
  404.         if( i < filename_size )
  405.         {
  406.                 try
  407.                 {
  408.                         c = FILENAME.at( i );
  409.                 }
  410.                 catch( std::out_of_range& e )
  411.                 {
  412.                         c = 0;
  413.                 }
  414.                 *filename_c_str_iter = c;
  415.                 ++i;
  416.                 ++filename_c_str_iter;
  417.         }
  418.         if( i < filename_size )
  419.         {
  420.                 try
  421.                 {
  422.                         c = FILENAME.at( i );
  423.                 }
  424.                 catch( std::out_of_range& e )
  425.                 {
  426.                         c = 0;
  427.                 }
  428.                 *filename_c_str_iter = c;
  429.                 ++i;
  430.                 ++filename_c_str_iter;
  431.         }
  432.         if( i < filename_size )
  433.         {
  434.                 try
  435.                 {
  436.                         c = FILENAME.at( i );
  437.                 }
  438.                 catch( std::out_of_range& e )
  439.                 {
  440.                         c = 0;
  441.                 }
  442.                 *filename_c_str_iter = c;
  443.                 ++i;
  444.                 ++filename_c_str_iter;
  445.         }
  446.         if( i < filename_size )
  447.         {
  448.                 try
  449.                 {
  450.                         c = FILENAME.at( i );
  451.                 }
  452.                 catch( std::out_of_range& e )
  453.                 {
  454.                         c = 0;
  455.                 }
  456.                 *filename_c_str_iter = c;
  457.                 ++i;
  458.                 ++filename_c_str_iter;
  459.         }
  460.         if( i < filename_size )
  461.         {
  462.                 try
  463.                 {
  464.                         c = FILENAME.at( i );
  465.                 }
  466.                 catch( std::out_of_range& e )
  467.                 {
  468.                         c = 0;
  469.                 }
  470.                 *filename_c_str_iter = c;
  471.                 ++i;
  472.                 ++filename_c_str_iter;
  473.         }
  474.         if( i < filename_size )
  475.         {
  476.                 try
  477.                 {
  478.                         c = FILENAME.at( i );
  479.                 }
  480.                 catch( std::out_of_range& e )
  481.                 {
  482.                         c = 0;
  483.                 }
  484.                 *filename_c_str_iter = c;
  485.                 ++i;
  486.                 ++filename_c_str_iter;
  487.         }
  488.         if( i < filename_size )
  489.         {
  490.                 try
  491.                 {
  492.                         c = FILENAME.at( i );
  493.                 }
  494.                 catch( std::out_of_range& e )
  495.                 {
  496.                         c = 0;
  497.                 }
  498.                 *filename_c_str_iter = c;
  499.                 ++i;
  500.                 ++filename_c_str_iter;
  501.         }
  502.         if( i < filename_size )
  503.         {
  504.                 try
  505.                 {
  506.                         c = FILENAME.at( i );
  507.                 }
  508.                 catch( std::out_of_range& e )
  509.                 {
  510.                         c = 0;
  511.                 }
  512.                 *filename_c_str_iter = c;
  513.                 ++i;
  514.                 ++filename_c_str_iter;
  515.         }
  516.         if( i < filename_size )
  517.         {
  518.                 try
  519.                 {
  520.                         c = FILENAME.at( i );
  521.                 }
  522.                 catch( std::out_of_range& e )
  523.                 {
  524.                         c = 0;
  525.                 }
  526.                 *filename_c_str_iter = c;
  527.                 ++i;
  528.                 ++filename_c_str_iter;
  529.         }
  530.         if( i < filename_size )
  531.         {
  532.                 try
  533.                 {
  534.                         c = FILENAME.at( i );
  535.                 }
  536.                 catch( std::out_of_range& e )
  537.                 {
  538.                         c = 0;
  539.                 }
  540.                 *filename_c_str_iter = c;
  541.                 ++i;
  542.                 ++filename_c_str_iter;
  543.         }
  544.         if( i < filename_size )
  545.         {
  546.                 try
  547.                 {
  548.                         c = FILENAME.at( i );
  549.                 }
  550.                 catch( std::out_of_range& e )
  551.                 {
  552.                         c = 0;
  553.                 }
  554.                 *filename_c_str_iter = c;
  555.                 ++i;
  556.                 ++filename_c_str_iter;
  557.         }
  558.         if( i < filename_size )
  559.         {
  560.                 try
  561.                 {
  562.                         c = FILENAME.at( i );
  563.                 }
  564.                 catch( std::out_of_range& e )
  565.                 {
  566.                         c = 0;
  567.                 }
  568.                 *filename_c_str_iter = c;
  569.                 ++i;
  570.                 ++filename_c_str_iter;
  571.         }
  572.         if( i < filename_size )
  573.         {
  574.                 try
  575.                 {
  576.                         c = FILENAME.at( i );
  577.                 }
  578.                 catch( std::out_of_range& e )
  579.                 {
  580.                         c = 0;
  581.                 }
  582.                 *filename_c_str_iter = c;
  583.                 ++i;
  584.                 ++filename_c_str_iter;
  585.         }
  586.         if( i < filename_size )
  587.         {
  588.                 try
  589.                 {
  590.                         c = FILENAME.at( i );
  591.                 }
  592.                 catch( std::out_of_range& e )
  593.                 {
  594.                         c = 0;
  595.                 }
  596.                 *filename_c_str_iter = c;
  597.                 ++i;
  598.                 ++filename_c_str_iter;
  599.         }
  600.         if( i < filename_size )
  601.         {
  602.                 try
  603.                 {
  604.                         c = FILENAME.at( i );
  605.                 }
  606.                 catch( std::out_of_range& e )
  607.                 {
  608.                         c = 0;
  609.                 }
  610.                 *filename_c_str_iter = c;
  611.                 ++i;
  612.                 ++filename_c_str_iter;
  613.         }
  614.         if( i < filename_size )
  615.         {
  616.                 try
  617.                 {
  618.                         c = FILENAME.at( i );
  619.                 }
  620.                 catch( std::out_of_range& e )
  621.                 {
  622.                         c = 0;
  623.                 }
  624.                 *filename_c_str_iter = c;
  625.                 ++i;
  626.                 ++filename_c_str_iter;
  627.         }
  628.         if( i < filename_size )
  629.         {
  630.                 try
  631.                 {
  632.                         c = FILENAME.at( i );
  633.                 }
  634.                 catch( std::out_of_range& e )
  635.                 {
  636.                         c = 0;
  637.                 }
  638.                 *filename_c_str_iter = c;
  639.                 ++i;
  640.                 ++filename_c_str_iter;
  641.         }
  642.         if( i < filename_size )
  643.         {
  644.                 try
  645.                 {
  646.                         c = FILENAME.at( i );
  647.                 }
  648.                 catch( std::out_of_range& e )
  649.                 {
  650.                         c = 0;
  651.                 }
  652.                 *filename_c_str_iter = c;
  653.                 ++i;
  654.                 ++filename_c_str_iter;
  655.         }
  656.         if( i < filename_size )
  657.         {
  658.                 try
  659.                 {
  660.                         c = FILENAME.at( i );
  661.                 }
  662.                 catch( std::out_of_range& e )
  663.                 {
  664.                         c = 0;
  665.                 }
  666.                 *filename_c_str_iter = c;
  667.                 ++i;
  668.                 ++filename_c_str_iter;
  669.         }
  670.         if( i < filename_size )
  671.         {
  672.                 try
  673.                 {
  674.                         c = FILENAME.at( i );
  675.                 }
  676.                 catch( std::out_of_range& e )
  677.                 {
  678.                         c = 0;
  679.                 }
  680.                 *filename_c_str_iter = c;
  681.                 ++i;
  682.                 ++filename_c_str_iter;
  683.         }
  684.         if( i < filename_size )
  685.         {
  686.                 try
  687.                 {
  688.                         c = FILENAME.at( i );
  689.                 }
  690.                 catch( std::out_of_range& e )
  691.                 {
  692.                         c = 0;
  693.                 }
  694.                 *filename_c_str_iter = c;
  695.                 ++i;
  696.                 ++filename_c_str_iter;
  697.         }
  698.         if( i < filename_size )
  699.         {
  700.                 try
  701.                 {
  702.                         c = FILENAME.at( i );
  703.                 }
  704.                 catch( std::out_of_range& e )
  705.                 {
  706.                         c = 0;
  707.                 }
  708.                 *filename_c_str_iter = c;
  709.                 ++i;
  710.                 ++filename_c_str_iter;
  711.         }
  712.         if( i < filename_size )
  713.         {
  714.                 try
  715.                 {
  716.                         c = FILENAME.at( i );
  717.                 }
  718.                 catch( std::out_of_range& e )
  719.                 {
  720.                         c = 0;
  721.                 }
  722.                 *filename_c_str_iter = c;
  723.                 ++i;
  724.                 ++filename_c_str_iter;
  725.         }
  726.         if( i < filename_size )
  727.         {
  728.                 try
  729.                 {
  730.                         c = FILENAME.at( i );
  731.                 }
  732.                 catch( std::out_of_range& e )
  733.                 {
  734.                         c = 0;
  735.                 }
  736.                 *filename_c_str_iter = c;
  737.                 ++i;
  738.                 ++filename_c_str_iter;
  739.         }
  740.         if( i < filename_size )
  741.         {
  742.                 try
  743.                 {
  744.                         c = FILENAME.at( i );
  745.                 }
  746.                 catch( std::out_of_range& e )
  747.                 {
  748.                         c = 0;
  749.                 }
  750.                 *filename_c_str_iter = c;
  751.                 ++i;
  752.                 ++filename_c_str_iter;
  753.         }
  754.         if( i < filename_size )
  755.         {
  756.                 try
  757.                 {
  758.                         c = FILENAME.at( i );
  759.                 }
  760.                 catch( std::out_of_range& e )
  761.                 {
  762.                         c = 0;
  763.                 }
  764.                 *filename_c_str_iter = c;
  765.                 ++i;
  766.                 ++filename_c_str_iter;
  767.         }
  768.         if( i < filename_size )
  769.         {
  770.                 try
  771.                 {
  772.                         c = FILENAME.at( i );
  773.                 }
  774.                 catch( std::out_of_range& e )
  775.                 {
  776.                         c = 0;
  777.                 }
  778.                 *filename_c_str_iter = c;
  779.                 ++i;
  780.                 ++filename_c_str_iter;
  781.         }
  782.         if( i < filename_size )
  783.         {
  784.                 try
  785.                 {
  786.                         c = FILENAME.at( i );
  787.                 }
  788.                 catch( std::out_of_range& e )
  789.                 {
  790.                         c = 0;
  791.                 }
  792.                 *filename_c_str_iter = c;
  793.                 ++i;
  794.                 ++filename_c_str_iter;
  795.         }
  796.         if( i < filename_size )
  797.         {
  798.                 try
  799.                 {
  800.                         c = FILENAME.at( i );
  801.                 }
  802.                 catch( std::out_of_range& e )
  803.                 {
  804.                         c = 0;
  805.                 }
  806.                 *filename_c_str_iter = c;
  807.                 ++i;
  808.                 ++filename_c_str_iter;
  809.         }
  810.         if( i < filename_size )
  811.         {
  812.                 try
  813.                 {
  814.                         c = FILENAME.at( i );
  815.                 }
  816.                 catch( std::out_of_range& e )
  817.                 {
  818.                         c = 0;
  819.                 }
  820.                 *filename_c_str_iter = c;
  821.                 ++i;
  822.                 ++filename_c_str_iter;
  823.         }
  824.         if( i < filename_size )
  825.         {
  826.                 try
  827.                 {
  828.                         c = FILENAME.at( i );
  829.                 }
  830.                 catch( std::out_of_range& e )
  831.                 {
  832.                         c = 0;
  833.                 }
  834.                 *filename_c_str_iter = c;
  835.                 ++i;
  836.                 ++filename_c_str_iter;
  837.         }
  838.         if( i < filename_size )
  839.         {
  840.                 try
  841.                 {
  842.                         c = FILENAME.at( i );
  843.                 }
  844.                 catch( std::out_of_range& e )
  845.                 {
  846.                         c = 0;
  847.                 }
  848.                 *filename_c_str_iter = c;
  849.                 ++i;
  850.                 ++filename_c_str_iter;
  851.         }
  852.         if( i < filename_size )
  853.         {
  854.                 try
  855.                 {
  856.                         c = FILENAME.at( i );
  857.                 }
  858.                 catch( std::out_of_range& e )
  859.                 {
  860.                         c = 0;
  861.                 }
  862.                 *filename_c_str_iter = c;
  863.                 ++i;
  864.                 ++filename_c_str_iter;
  865.         }
  866.         if( i < filename_size )
  867.         {
  868.                 try
  869.                 {
  870.                         c = FILENAME.at( i );
  871.                 }
  872.                 catch( std::out_of_range& e )
  873.                 {
  874.                         c = 0;
  875.                 }
  876.                 *filename_c_str_iter = c;
  877.                 ++i;
  878.                 ++filename_c_str_iter;
  879.         }
  880.         if( i < filename_size )
  881.         {
  882.                 try
  883.                 {
  884.                         c = FILENAME.at( i );
  885.                 }
  886.                 catch( std::out_of_range& e )
  887.                 {
  888.                         c = 0;
  889.                 }
  890.                 *filename_c_str_iter = c;
  891.                 ++i;
  892.                 ++filename_c_str_iter;
  893.         }
  894.         if( i < filename_size )
  895.         {
  896.                 try
  897.                 {
  898.                         c = FILENAME.at( i );
  899.                 }
  900.                 catch( std::out_of_range& e )
  901.                 {
  902.                         c = 0;
  903.                 }
  904.                 *filename_c_str_iter = c;
  905.                 ++i;
  906.                 ++filename_c_str_iter;
  907.         }
  908.         if( i < filename_size )
  909.         {
  910.                 try
  911.                 {
  912.                         c = FILENAME.at( i );
  913.                 }
  914.                 catch( std::out_of_range& e )
  915.                 {
  916.                         c = 0;
  917.                 }
  918.                 *filename_c_str_iter = c;
  919.                 ++i;
  920.                 ++filename_c_str_iter;
  921.         }
  922.         if( i < filename_size )
  923.         {
  924.                 try
  925.                 {
  926.                         c = FILENAME.at( i );
  927.                 }
  928.                 catch( std::out_of_range& e )
  929.                 {
  930.                         c = 0;
  931.                 }
  932.                 *filename_c_str_iter = c;
  933.                 ++i;
  934.                 ++filename_c_str_iter;
  935.         }
  936.         if( i < filename_size )
  937.         {
  938.                 try
  939.                 {
  940.                         c = FILENAME.at( i );
  941.                 }
  942.                 catch( std::out_of_range& e )
  943.                 {
  944.                         c = 0;
  945.                 }
  946.                 *filename_c_str_iter = c;
  947.                 ++i;
  948.                 ++filename_c_str_iter;
  949.         }
  950.         if( i < filename_size )
  951.         {
  952.                 try
  953.                 {
  954.                         c = FILENAME.at( i );
  955.                 }
  956.                 catch( std::out_of_range& e )
  957.                 {
  958.                         c = 0;
  959.                 }
  960.                 *filename_c_str_iter = c;
  961.                 ++i;
  962.                 ++filename_c_str_iter;
  963.         }
  964.         if( i < filename_size )
  965.         {
  966.                 try
  967.                 {
  968.                         c = FILENAME.at( i );
  969.                 }
  970.                 catch( std::out_of_range& e )
  971.                 {
  972.                         c = 0;
  973.                 }
  974.                 *filename_c_str_iter = c;
  975.                 ++i;
  976.                 ++filename_c_str_iter;
  977.         }
  978.         if( i < filename_size )
  979.         {
  980.                 try
  981.                 {
  982.                         c = FILENAME.at( i );
  983.                 }
  984.                 catch( std::out_of_range& e )
  985.                 {
  986.                         c = 0;
  987.                 }
  988.                 *filename_c_str_iter = c;
  989.                 ++i;
  990.                 ++filename_c_str_iter;
  991.         }
  992.         if( i < filename_size )
  993.         {
  994.                 try
  995.                 {
  996.                         c = FILENAME.at( i );
  997.                 }
  998.                 catch( std::out_of_range& e )
  999.                 {
  1000.                         c = 0;
  1001.                 }
  1002.                 *filename_c_str_iter = c;
  1003.                 ++i;
  1004.                 ++filename_c_str_iter;
  1005.         }
  1006.         if( i < filename_size )
  1007.         {
  1008.                 try
  1009.                 {
  1010.                         c = FILENAME.at( i );
  1011.                 }
  1012.                 catch( std::out_of_range& e )
  1013.                 {
  1014.                         c = 0;
  1015.                 }
  1016.                 *filename_c_str_iter = c;
  1017.                 ++i;
  1018.                 ++filename_c_str_iter;
  1019.         }
  1020.         if( i < filename_size )
  1021.         {
  1022.                 try
  1023.                 {
  1024.                         c = FILENAME.at( i );
  1025.                 }
  1026.                 catch( std::out_of_range& e )
  1027.                 {
  1028.                         c = 0;
  1029.                 }
  1030.                 *filename_c_str_iter = c;
  1031.                 ++i;
  1032.                 ++filename_c_str_iter;
  1033.         }
  1034.         if( i < filename_size )
  1035.         {
  1036.                 try
  1037.                 {
  1038.                         c = FILENAME.at( i );
  1039.                 }
  1040.                 catch( std::out_of_range& e )
  1041.                 {
  1042.                         c = 0;
  1043.                 }
  1044.                 *filename_c_str_iter = c;
  1045.                 ++i;
  1046.                 ++filename_c_str_iter;
  1047.         }
  1048.         if( i < filename_size )
  1049.         {
  1050.                 try
  1051.                 {
  1052.                         c = FILENAME.at( i );
  1053.                 }
  1054.                 catch( std::out_of_range& e )
  1055.                 {
  1056.                         c = 0;
  1057.                 }
  1058.                 *filename_c_str_iter = c;
  1059.                 ++i;
  1060.                 ++filename_c_str_iter;
  1061.         }
  1062.         if( i < filename_size )
  1063.         {
  1064.                 try
  1065.                 {
  1066.                         c = FILENAME.at( i );
  1067.                 }
  1068.                 catch( std::out_of_range& e )
  1069.                 {
  1070.                         c = 0;
  1071.                 }
  1072.                 *filename_c_str_iter = c;
  1073.                 ++i;
  1074.                 ++filename_c_str_iter;
  1075.         }
  1076.         if( i < filename_size )
  1077.         {
  1078.                 try
  1079.                 {
  1080.                         c = FILENAME.at( i );
  1081.                 }
  1082.                 catch( std::out_of_range& e )
  1083.                 {
  1084.                         c = 0;
  1085.                 }
  1086.                 *filename_c_str_iter = c;
  1087.                 ++i;
  1088.                 ++filename_c_str_iter;
  1089.         }
  1090.         if( i < filename_size )
  1091.         {
  1092.                 try
  1093.                 {
  1094.                         c = FILENAME.at( i );
  1095.                 }
  1096.                 catch( std::out_of_range& e )
  1097.                 {
  1098.                         c = 0;
  1099.                 }
  1100.                 *filename_c_str_iter = c;
  1101.                 ++i;
  1102.                 ++filename_c_str_iter;
  1103.         }
  1104.         if( i < filename_size )
  1105.         {
  1106.                 try
  1107.                 {
  1108.                         c = FILENAME.at( i );
  1109.                 }
  1110.                 catch( std::out_of_range& e )
  1111.                 {
  1112.                         c = 0;
  1113.                 }
  1114.                 *filename_c_str_iter = c;
  1115.                 ++i;
  1116.                 ++filename_c_str_iter;
  1117.         }
  1118.         if( i < filename_size )
  1119.         {
  1120.                 try
  1121.                 {
  1122.                         c = FILENAME.at( i );
  1123.                 }
  1124.                 catch( std::out_of_range& e )
  1125.                 {
  1126.                         c = 0;
  1127.                 }
  1128.                 *filename_c_str_iter = c;
  1129.                 ++i;
  1130.                 ++filename_c_str_iter;
  1131.         }
  1132.         if( i < filename_size )
  1133.         {
  1134.                 try
  1135.                 {
  1136.                         c = FILENAME.at( i );
  1137.                 }
  1138.                 catch( std::out_of_range& e )
  1139.                 {
  1140.                         c = 0;
  1141.                 }
  1142.                 *filename_c_str_iter = c;
  1143.                 ++i;
  1144.                 ++filename_c_str_iter;
  1145.         }
  1146.         if( i < filename_size )
  1147.         {
  1148.                 try
  1149.                 {
  1150.                         c = FILENAME.at( i );
  1151.                 }
  1152.                 catch( std::out_of_range& e )
  1153.                 {
  1154.                         c = 0;
  1155.                 }
  1156.                 *filename_c_str_iter = c;
  1157.                 ++i;
  1158.                 ++filename_c_str_iter;
  1159.         }
  1160.         if( i < filename_size )
  1161.         {
  1162.                 try
  1163.                 {
  1164.                         c = FILENAME.at( i );
  1165.                 }
  1166.                 catch( std::out_of_range& e )
  1167.                 {
  1168.                         c = 0;
  1169.                 }
  1170.                 *filename_c_str_iter = c;
  1171.                 ++i;
  1172.                 ++filename_c_str_iter;
  1173.         }
  1174.         if( i < filename_size )
  1175.         {
  1176.                 try
  1177.                 {
  1178.                         c = FILENAME.at( i );
  1179.                 }
  1180.                 catch( std::out_of_range& e )
  1181.                 {
  1182.                         c = 0;
  1183.                 }
  1184.                 *filename_c_str_iter = c;
  1185.                 ++i;
  1186.                 ++filename_c_str_iter;
  1187.         }
  1188.         if( i < filename_size )
  1189.         {
  1190.                 FileNameTooLong err;
  1191.                 throw( err );
  1192.         }
  1193.         inFile.open( filename_c_str, std::ifstream::in );
  1194.         bool is_open;
  1195.         is_open = inFile.is_open();
  1196.         bool isnt_open;
  1197.         isnt_open = ! is_open;
  1198.         if( isnt_open )
  1199.         {
  1200.                 CouldNotOpenFile err;
  1201.                 throw( err );
  1202.         }
  1203.         char d;
  1204.         bool eof;
  1205.         bool not_eof;
  1206.         while( not_eof )
  1207.         {
  1208.                 d = inFile.get();
  1209.                 eof = inFile.eof();
  1210.                 not_eof = ! eof;
  1211.                
  1212.                 if( not_eof )
  1213.                 {
  1214.                         if( d == '0' )
  1215.                         {
  1216.                                 cout << '0';
  1217.                         }
  1218.                         if( d == '1' )
  1219.                         {
  1220.                                 cout << '1';
  1221.                         }
  1222.                         if( d == '2' )
  1223.                         {
  1224.                                 cout << '2';
  1225.                         }
  1226.                         if( d == '3' )
  1227.                         {
  1228.                                 cout << '3';
  1229.                         }
  1230.                         if( d == '4' )
  1231.                         {
  1232.                                 cout << '4';
  1233.                         }
  1234.                         if( d == '5' )
  1235.                         {
  1236.                                 cout << '5';
  1237.                         }
  1238.                         if( d == '6' )
  1239.                         {
  1240.                                 cout << '6';
  1241.                         }
  1242.                         if( d == '7' )
  1243.                         {
  1244.                                 cout << '7';
  1245.                         }
  1246.                         if( d == '8' )
  1247.                         {
  1248.                                 cout << '8';
  1249.                         }
  1250.                         if( d == '9' )
  1251.                         {
  1252.                                 cout << '9';
  1253.                         }
  1254.                         if( d == '.' )
  1255.                         {
  1256.                                 cout << '.';
  1257.                         }
  1258.                         if( d == '-' )
  1259.                         {
  1260.                                 cout << '-';
  1261.                         }
  1262.                         if( d == ' ' )
  1263.                         {
  1264.                                 cout << endl;
  1265.                         }
  1266.                 }
  1267.         }
  1268.         cout << endl;
  1269.         inFile.close();
  1270.         delete filename_c_str;
  1271.         filename_c_str_iter = nullptr;
  1272. }
  1273. void write( const std::string FILENAME )
  1274. {
  1275.         std::ofstream outFile;
  1276.         uint8_t filename_size;
  1277.         filename_size = FILENAME.length();
  1278.         ++filename_size;
  1279.         void* filename_c_str_ptr;
  1280.         char* filename_c_str;
  1281.         filename_c_str_ptr = malloc( filename_size );
  1282.         filename_c_str = (char*) filename_c_str_ptr;
  1283.         filename_c_str_ptr = nullptr;
  1284.         size_t i;
  1285.         i = 0;
  1286.         char* filename_c_str_iter;
  1287.         filename_c_str_iter = filename_c_str;
  1288.         char c;
  1289.         if( i < filename_size )
  1290.         {
  1291.                 try
  1292.                 {
  1293.                         c = FILENAME.at( i );
  1294.                 }
  1295.                 catch( std::out_of_range& e )
  1296.                 {
  1297.                         c = 0;
  1298.                 }
  1299.                 *filename_c_str_iter = c;
  1300.                 ++i;
  1301.                 ++filename_c_str_iter;
  1302.         }
  1303.         if( i < filename_size )
  1304.         {
  1305.                 try
  1306.                 {
  1307.                         c = FILENAME.at( i );
  1308.                 }
  1309.                 catch( std::out_of_range& e )
  1310.                 {
  1311.                         c = 0;
  1312.                 }
  1313.                 *filename_c_str_iter = c;
  1314.                 ++i;
  1315.                 ++filename_c_str_iter;
  1316.         }
  1317.         if( i < filename_size )
  1318.         {
  1319.                 try
  1320.                 {
  1321.                         c = FILENAME.at( i );
  1322.                 }
  1323.                 catch( std::out_of_range& e )
  1324.                 {
  1325.                         c = 0;
  1326.                 }
  1327.                 *filename_c_str_iter = c;
  1328.                 ++i;
  1329.                 ++filename_c_str_iter;
  1330.         }
  1331.         if( i < filename_size )
  1332.         {
  1333.                 try
  1334.                 {
  1335.                         c = FILENAME.at( i );
  1336.                 }
  1337.                 catch( std::out_of_range& e )
  1338.                 {
  1339.                         c = 0;
  1340.                 }
  1341.                 *filename_c_str_iter = c;
  1342.                 ++i;
  1343.                 ++filename_c_str_iter;
  1344.         }
  1345.         if( i < filename_size )
  1346.         {
  1347.                 try
  1348.                 {
  1349.                         c = FILENAME.at( i );
  1350.                 }
  1351.                 catch( std::out_of_range& e )
  1352.                 {
  1353.                         c = 0;
  1354.                 }
  1355.                 *filename_c_str_iter = c;
  1356.                 ++i;
  1357.                 ++filename_c_str_iter;
  1358.         }
  1359.         if( i < filename_size )
  1360.         {
  1361.                 try
  1362.                 {
  1363.                         c = FILENAME.at( i );
  1364.                 }
  1365.                 catch( std::out_of_range& e )
  1366.                 {
  1367.                         c = 0;
  1368.                 }
  1369.                 *filename_c_str_iter = c;
  1370.                 ++i;
  1371.                 ++filename_c_str_iter;
  1372.         }
  1373.         if( i < filename_size )
  1374.         {
  1375.                 try
  1376.                 {
  1377.                         c = FILENAME.at( i );
  1378.                 }
  1379.                 catch( std::out_of_range& e )
  1380.                 {
  1381.                         c = 0;
  1382.                 }
  1383.                 *filename_c_str_iter = c;
  1384.                 ++i;
  1385.                 ++filename_c_str_iter;
  1386.         }
  1387.         if( i < filename_size )
  1388.         {
  1389.                 try
  1390.                 {
  1391.                         c = FILENAME.at( i );
  1392.                 }
  1393.                 catch( std::out_of_range& e )
  1394.                 {
  1395.                         c = 0;
  1396.                 }
  1397.                 *filename_c_str_iter = c;
  1398.                 ++i;
  1399.                 ++filename_c_str_iter;
  1400.         }
  1401.         if( i < filename_size )
  1402.         {
  1403.                 try
  1404.                 {
  1405.                         c = FILENAME.at( i );
  1406.                 }
  1407.                 catch( std::out_of_range& e )
  1408.                 {
  1409.                         c = 0;
  1410.                 }
  1411.                 *filename_c_str_iter = c;
  1412.                 ++i;
  1413.                 ++filename_c_str_iter;
  1414.         }
  1415.         if( i < filename_size )
  1416.         {
  1417.                 try
  1418.                 {
  1419.                         c = FILENAME.at( i );
  1420.                 }
  1421.                 catch( std::out_of_range& e )
  1422.                 {
  1423.                         c = 0;
  1424.                 }
  1425.                 *filename_c_str_iter = c;
  1426.                 ++i;
  1427.                 ++filename_c_str_iter;
  1428.         }
  1429.         if( i < filename_size )
  1430.         {
  1431.                 try
  1432.                 {
  1433.                         c = FILENAME.at( i );
  1434.                 }
  1435.                 catch( std::out_of_range& e )
  1436.                 {
  1437.                         c = 0;
  1438.                 }
  1439.                 *filename_c_str_iter = c;
  1440.                 ++i;
  1441.                 ++filename_c_str_iter;
  1442.         }
  1443.         if( i < filename_size )
  1444.         {
  1445.                 try
  1446.                 {
  1447.                         c = FILENAME.at( i );
  1448.                 }
  1449.                 catch( std::out_of_range& e )
  1450.                 {
  1451.                         c = 0;
  1452.                 }
  1453.                 *filename_c_str_iter = c;
  1454.                 ++i;
  1455.                 ++filename_c_str_iter;
  1456.         }
  1457.         if( i < filename_size )
  1458.         {
  1459.                 try
  1460.                 {
  1461.                         c = FILENAME.at( i );
  1462.                 }
  1463.                 catch( std::out_of_range& e )
  1464.                 {
  1465.                         c = 0;
  1466.                 }
  1467.                 *filename_c_str_iter = c;
  1468.                 ++i;
  1469.                 ++filename_c_str_iter;
  1470.         }
  1471.         if( i < filename_size )
  1472.         {
  1473.                 try
  1474.                 {
  1475.                         c = FILENAME.at( i );
  1476.                 }
  1477.                 catch( std::out_of_range& e )
  1478.                 {
  1479.                         c = 0;
  1480.                 }
  1481.                 *filename_c_str_iter = c;
  1482.                 ++i;
  1483.                 ++filename_c_str_iter;
  1484.         }
  1485.         if( i < filename_size )
  1486.         {
  1487.                 try
  1488.                 {
  1489.                         c = FILENAME.at( i );
  1490.                 }
  1491.                 catch( std::out_of_range& e )
  1492.                 {
  1493.                         c = 0;
  1494.                 }
  1495.                 *filename_c_str_iter = c;
  1496.                 ++i;
  1497.                 ++filename_c_str_iter;
  1498.         }
  1499.         if( i < filename_size )
  1500.         {
  1501.                 try
  1502.                 {
  1503.                         c = FILENAME.at( i );
  1504.                 }
  1505.                 catch( std::out_of_range& e )
  1506.                 {
  1507.                         c = 0;
  1508.                 }
  1509.                 *filename_c_str_iter = c;
  1510.                 ++i;
  1511.                 ++filename_c_str_iter;
  1512.         }
  1513.         if( i < filename_size )
  1514.         {
  1515.                 try
  1516.                 {
  1517.                         c = FILENAME.at( i );
  1518.                 }
  1519.                 catch( std::out_of_range& e )
  1520.                 {
  1521.                         c = 0;
  1522.                 }
  1523.                 *filename_c_str_iter = c;
  1524.                 ++i;
  1525.                 ++filename_c_str_iter;
  1526.         }
  1527.         if( i < filename_size )
  1528.         {
  1529.                 try
  1530.                 {
  1531.                         c = FILENAME.at( i );
  1532.                 }
  1533.                 catch( std::out_of_range& e )
  1534.                 {
  1535.                         c = 0;
  1536.                 }
  1537.                 *filename_c_str_iter = c;
  1538.                 ++i;
  1539.                 ++filename_c_str_iter;
  1540.         }
  1541.         if( i < filename_size )
  1542.         {
  1543.                 try
  1544.                 {
  1545.                         c = FILENAME.at( i );
  1546.                 }
  1547.                 catch( std::out_of_range& e )
  1548.                 {
  1549.                         c = 0;
  1550.                 }
  1551.                 *filename_c_str_iter = c;
  1552.                 ++i;
  1553.                 ++filename_c_str_iter;
  1554.         }
  1555.         if( i < filename_size )
  1556.         {
  1557.                 try
  1558.                 {
  1559.                         c = FILENAME.at( i );
  1560.                 }
  1561.                 catch( std::out_of_range& e )
  1562.                 {
  1563.                         c = 0;
  1564.                 }
  1565.                 *filename_c_str_iter = c;
  1566.                 ++i;
  1567.                 ++filename_c_str_iter;
  1568.         }
  1569.         if( i < filename_size )
  1570.         {
  1571.                 try
  1572.                 {
  1573.                         c = FILENAME.at( i );
  1574.                 }
  1575.                 catch( std::out_of_range& e )
  1576.                 {
  1577.                         c = 0;
  1578.                 }
  1579.                 *filename_c_str_iter = c;
  1580.                 ++i;
  1581.                 ++filename_c_str_iter;
  1582.         }
  1583.         if( i < filename_size )
  1584.         {
  1585.                 try
  1586.                 {
  1587.                         c = FILENAME.at( i );
  1588.                 }
  1589.                 catch( std::out_of_range& e )
  1590.                 {
  1591.                         c = 0;
  1592.                 }
  1593.                 *filename_c_str_iter = c;
  1594.                 ++i;
  1595.                 ++filename_c_str_iter;
  1596.         }
  1597.         if( i < filename_size )
  1598.         {
  1599.                 try
  1600.                 {
  1601.                         c = FILENAME.at( i );
  1602.                 }
  1603.                 catch( std::out_of_range& e )
  1604.                 {
  1605.                         c = 0;
  1606.                 }
  1607.                 *filename_c_str_iter = c;
  1608.                 ++i;
  1609.                 ++filename_c_str_iter;
  1610.         }
  1611.         if( i < filename_size )
  1612.         {
  1613.                 try
  1614.                 {
  1615.                         c = FILENAME.at( i );
  1616.                 }
  1617.                 catch( std::out_of_range& e )
  1618.                 {
  1619.                         c = 0;
  1620.                 }
  1621.                 *filename_c_str_iter = c;
  1622.                 ++i;
  1623.                 ++filename_c_str_iter;
  1624.         }
  1625.         if( i < filename_size )
  1626.         {
  1627.                 try
  1628.                 {
  1629.                         c = FILENAME.at( i );
  1630.                 }
  1631.                 catch( std::out_of_range& e )
  1632.                 {
  1633.                         c = 0;
  1634.                 }
  1635.                 *filename_c_str_iter = c;
  1636.                 ++i;
  1637.                 ++filename_c_str_iter;
  1638.         }
  1639.         if( i < filename_size )
  1640.         {
  1641.                 try
  1642.                 {
  1643.                         c = FILENAME.at( i );
  1644.                 }
  1645.                 catch( std::out_of_range& e )
  1646.                 {
  1647.                         c = 0;
  1648.                 }
  1649.                 *filename_c_str_iter = c;
  1650.                 ++i;
  1651.                 ++filename_c_str_iter;
  1652.         }
  1653.         if( i < filename_size )
  1654.         {
  1655.                 try
  1656.                 {
  1657.                         c = FILENAME.at( i );
  1658.                 }
  1659.                 catch( std::out_of_range& e )
  1660.                 {
  1661.                         c = 0;
  1662.                 }
  1663.                 *filename_c_str_iter = c;
  1664.                 ++i;
  1665.                 ++filename_c_str_iter;
  1666.         }
  1667.         if( i < filename_size )
  1668.         {
  1669.                 try
  1670.                 {
  1671.                         c = FILENAME.at( i );
  1672.                 }
  1673.                 catch( std::out_of_range& e )
  1674.                 {
  1675.                         c = 0;
  1676.                 }
  1677.                 *filename_c_str_iter = c;
  1678.                 ++i;
  1679.                 ++filename_c_str_iter;
  1680.         }
  1681.         if( i < filename_size )
  1682.         {
  1683.                 try
  1684.                 {
  1685.                         c = FILENAME.at( i );
  1686.                 }
  1687.                 catch( std::out_of_range& e )
  1688.                 {
  1689.                         c = 0;
  1690.                 }
  1691.                 *filename_c_str_iter = c;
  1692.                 ++i;
  1693.                 ++filename_c_str_iter;
  1694.         }
  1695.         if( i < filename_size )
  1696.         {
  1697.                 try
  1698.                 {
  1699.                         c = FILENAME.at( i );
  1700.                 }
  1701.                 catch( std::out_of_range& e )
  1702.                 {
  1703.                         c = 0;
  1704.                 }
  1705.                 *filename_c_str_iter = c;
  1706.                 ++i;
  1707.                 ++filename_c_str_iter;
  1708.         }
  1709.         if( i < filename_size )
  1710.         {
  1711.                 try
  1712.                 {
  1713.                         c = FILENAME.at( i );
  1714.                 }
  1715.                 catch( std::out_of_range& e )
  1716.                 {
  1717.                         c = 0;
  1718.                 }
  1719.                 *filename_c_str_iter = c;
  1720.                 ++i;
  1721.                 ++filename_c_str_iter;
  1722.         }
  1723.         if( i < filename_size )
  1724.         {
  1725.                 try
  1726.                 {
  1727.                         c = FILENAME.at( i );
  1728.                 }
  1729.                 catch( std::out_of_range& e )
  1730.                 {
  1731.                         c = 0;
  1732.                 }
  1733.                 *filename_c_str_iter = c;
  1734.                 ++i;
  1735.                 ++filename_c_str_iter;
  1736.         }
  1737.         if( i < filename_size )
  1738.         {
  1739.                 try
  1740.                 {
  1741.                         c = FILENAME.at( i );
  1742.                 }
  1743.                 catch( std::out_of_range& e )
  1744.                 {
  1745.                         c = 0;
  1746.                 }
  1747.                 *filename_c_str_iter = c;
  1748.                 ++i;
  1749.                 ++filename_c_str_iter;
  1750.         }
  1751.         if( i < filename_size )
  1752.         {
  1753.                 try
  1754.                 {
  1755.                         c = FILENAME.at( i );
  1756.                 }
  1757.                 catch( std::out_of_range& e )
  1758.                 {
  1759.                         c = 0;
  1760.                 }
  1761.                 *filename_c_str_iter = c;
  1762.                 ++i;
  1763.                 ++filename_c_str_iter;
  1764.         }
  1765.         if( i < filename_size )
  1766.         {
  1767.                 try
  1768.                 {
  1769.                         c = FILENAME.at( i );
  1770.                 }
  1771.                 catch( std::out_of_range& e )
  1772.                 {
  1773.                         c = 0;
  1774.                 }
  1775.                 *filename_c_str_iter = c;
  1776.                 ++i;
  1777.                 ++filename_c_str_iter;
  1778.         }
  1779.         if( i < filename_size )
  1780.         {
  1781.                 try
  1782.                 {
  1783.                         c = FILENAME.at( i );
  1784.                 }
  1785.                 catch( std::out_of_range& e )
  1786.                 {
  1787.                         c = 0;
  1788.                 }
  1789.                 *filename_c_str_iter = c;
  1790.                 ++i;
  1791.                 ++filename_c_str_iter;
  1792.         }
  1793.         if( i < filename_size )
  1794.         {
  1795.                 try
  1796.                 {
  1797.                         c = FILENAME.at( i );
  1798.                 }
  1799.                 catch( std::out_of_range& e )
  1800.                 {
  1801.                         c = 0;
  1802.                 }
  1803.                 *filename_c_str_iter = c;
  1804.                 ++i;
  1805.                 ++filename_c_str_iter;
  1806.         }
  1807.         if( i < filename_size )
  1808.         {
  1809.                 try
  1810.                 {
  1811.                         c = FILENAME.at( i );
  1812.                 }
  1813.                 catch( std::out_of_range& e )
  1814.                 {
  1815.                         c = 0;
  1816.                 }
  1817.                 *filename_c_str_iter = c;
  1818.                 ++i;
  1819.                 ++filename_c_str_iter;
  1820.         }
  1821.         if( i < filename_size )
  1822.         {
  1823.                 try
  1824.                 {
  1825.                         c = FILENAME.at( i );
  1826.                 }
  1827.                 catch( std::out_of_range& e )
  1828.                 {
  1829.                         c = 0;
  1830.                 }
  1831.                 *filename_c_str_iter = c;
  1832.                 ++i;
  1833.                 ++filename_c_str_iter;
  1834.         }
  1835.         if( i < filename_size )
  1836.         {
  1837.                 try
  1838.                 {
  1839.                         c = FILENAME.at( i );
  1840.                 }
  1841.                 catch( std::out_of_range& e )
  1842.                 {
  1843.                         c = 0;
  1844.                 }
  1845.                 *filename_c_str_iter = c;
  1846.                 ++i;
  1847.                 ++filename_c_str_iter;
  1848.         }
  1849.         if( i < filename_size )
  1850.         {
  1851.                 try
  1852.                 {
  1853.                         c = FILENAME.at( i );
  1854.                 }
  1855.                 catch( std::out_of_range& e )
  1856.                 {
  1857.                         c = 0;
  1858.                 }
  1859.                 *filename_c_str_iter = c;
  1860.                 ++i;
  1861.                 ++filename_c_str_iter;
  1862.         }
  1863.         if( i < filename_size )
  1864.         {
  1865.                 try
  1866.                 {
  1867.                         c = FILENAME.at( i );
  1868.                 }
  1869.                 catch( std::out_of_range& e )
  1870.                 {
  1871.                         c = 0;
  1872.                 }
  1873.                 *filename_c_str_iter = c;
  1874.                 ++i;
  1875.                 ++filename_c_str_iter;
  1876.         }
  1877.         if( i < filename_size )
  1878.         {
  1879.                 try
  1880.                 {
  1881.                         c = FILENAME.at( i );
  1882.                 }
  1883.                 catch( std::out_of_range& e )
  1884.                 {
  1885.                         c = 0;
  1886.                 }
  1887.                 *filename_c_str_iter = c;
  1888.                 ++i;
  1889.                 ++filename_c_str_iter;
  1890.         }
  1891.         if( i < filename_size )
  1892.         {
  1893.                 try
  1894.                 {
  1895.                         c = FILENAME.at( i );
  1896.                 }
  1897.                 catch( std::out_of_range& e )
  1898.                 {
  1899.                         c = 0;
  1900.                 }
  1901.                 *filename_c_str_iter = c;
  1902.                 ++i;
  1903.                 ++filename_c_str_iter;
  1904.         }
  1905.         if( i < filename_size )
  1906.         {
  1907.                 try
  1908.                 {
  1909.                         c = FILENAME.at( i );
  1910.                 }
  1911.                 catch( std::out_of_range& e )
  1912.                 {
  1913.                         c = 0;
  1914.                 }
  1915.                 *filename_c_str_iter = c;
  1916.                 ++i;
  1917.                 ++filename_c_str_iter;
  1918.         }
  1919.         if( i < filename_size )
  1920.         {
  1921.                 try
  1922.                 {
  1923.                         c = FILENAME.at( i );
  1924.                 }
  1925.                 catch( std::out_of_range& e )
  1926.                 {
  1927.                         c = 0;
  1928.                 }
  1929.                 *filename_c_str_iter = c;
  1930.                 ++i;
  1931.                 ++filename_c_str_iter;
  1932.         }
  1933.         if( i < filename_size )
  1934.         {
  1935.                 try
  1936.                 {
  1937.                         c = FILENAME.at( i );
  1938.                 }
  1939.                 catch( std::out_of_range& e )
  1940.                 {
  1941.                         c = 0;
  1942.                 }
  1943.                 *filename_c_str_iter = c;
  1944.                 ++i;
  1945.                 ++filename_c_str_iter;
  1946.         }
  1947.         if( i < filename_size )
  1948.         {
  1949.                 try
  1950.                 {
  1951.                         c = FILENAME.at( i );
  1952.                 }
  1953.                 catch( std::out_of_range& e )
  1954.                 {
  1955.                         c = 0;
  1956.                 }
  1957.                 *filename_c_str_iter = c;
  1958.                 ++i;
  1959.                 ++filename_c_str_iter;
  1960.         }
  1961.         if( i < filename_size )
  1962.         {
  1963.                 try
  1964.                 {
  1965.                         c = FILENAME.at( i );
  1966.                 }
  1967.                 catch( std::out_of_range& e )
  1968.                 {
  1969.                         c = 0;
  1970.                 }
  1971.                 *filename_c_str_iter = c;
  1972.                 ++i;
  1973.                 ++filename_c_str_iter;
  1974.         }
  1975.         if( i < filename_size )
  1976.         {
  1977.                 try
  1978.                 {
  1979.                         c = FILENAME.at( i );
  1980.                 }
  1981.                 catch( std::out_of_range& e )
  1982.                 {
  1983.                         c = 0;
  1984.                 }
  1985.                 *filename_c_str_iter = c;
  1986.                 ++i;
  1987.                 ++filename_c_str_iter;
  1988.         }
  1989.         if( i < filename_size )
  1990.         {
  1991.                 try
  1992.                 {
  1993.                         c = FILENAME.at( i );
  1994.                 }
  1995.                 catch( std::out_of_range& e )
  1996.                 {
  1997.                         c = 0;
  1998.                 }
  1999.                 *filename_c_str_iter = c;
  2000.                 ++i;
  2001.                 ++filename_c_str_iter;
  2002.         }
  2003.         if( i < filename_size )
  2004.         {
  2005.                 try
  2006.                 {
  2007.                         c = FILENAME.at( i );
  2008.                 }
  2009.                 catch( std::out_of_range& e )
  2010.                 {
  2011.                         c = 0;
  2012.                 }
  2013.                 *filename_c_str_iter = c;
  2014.                 ++i;
  2015.                 ++filename_c_str_iter;
  2016.         }
  2017.         if( i < filename_size )
  2018.         {
  2019.                 try
  2020.                 {
  2021.                         c = FILENAME.at( i );
  2022.                 }
  2023.                 catch( std::out_of_range& e )
  2024.                 {
  2025.                         c = 0;
  2026.                 }
  2027.                 *filename_c_str_iter = c;
  2028.                 ++i;
  2029.                 ++filename_c_str_iter;
  2030.         }
  2031.         if( i < filename_size )
  2032.         {
  2033.                 try
  2034.                 {
  2035.                         c = FILENAME.at( i );
  2036.                 }
  2037.                 catch( std::out_of_range& e )
  2038.                 {
  2039.                         c = 0;
  2040.                 }
  2041.                 *filename_c_str_iter = c;
  2042.                 ++i;
  2043.                 ++filename_c_str_iter;
  2044.         }
  2045.         if( i < filename_size )
  2046.         {
  2047.                 try
  2048.                 {
  2049.                         c = FILENAME.at( i );
  2050.                 }
  2051.                 catch( std::out_of_range& e )
  2052.                 {
  2053.                         c = 0;
  2054.                 }
  2055.                 *filename_c_str_iter = c;
  2056.                 ++i;
  2057.                 ++filename_c_str_iter;
  2058.         }
  2059.         if( i < filename_size )
  2060.         {
  2061.                 try
  2062.                 {
  2063.                         c = FILENAME.at( i );
  2064.                 }
  2065.                 catch( std::out_of_range& e )
  2066.                 {
  2067.                         c = 0;
  2068.                 }
  2069.                 *filename_c_str_iter = c;
  2070.                 ++i;
  2071.                 ++filename_c_str_iter;
  2072.         }
  2073.         if( i < filename_size )
  2074.         {
  2075.                 try
  2076.                 {
  2077.                         c = FILENAME.at( i );
  2078.                 }
  2079.                 catch( std::out_of_range& e )
  2080.                 {
  2081.                         c = 0;
  2082.                 }
  2083.                 *filename_c_str_iter = c;
  2084.                 ++i;
  2085.                 ++filename_c_str_iter;
  2086.         }
  2087.         if( i < filename_size )
  2088.         {
  2089.                 try
  2090.                 {
  2091.                         c = FILENAME.at( i );
  2092.                 }
  2093.                 catch( std::out_of_range& e )
  2094.                 {
  2095.                         c = 0;
  2096.                 }
  2097.                 *filename_c_str_iter = c;
  2098.                 ++i;
  2099.                 ++filename_c_str_iter;
  2100.         }
  2101.         if( i < filename_size )
  2102.         {
  2103.                 try
  2104.                 {
  2105.                         c = FILENAME.at( i );
  2106.                 }
  2107.                 catch( std::out_of_range& e )
  2108.                 {
  2109.                         c = 0;
  2110.                 }
  2111.                 *filename_c_str_iter = c;
  2112.                 ++i;
  2113.                 ++filename_c_str_iter;
  2114.         }
  2115.         if( i < filename_size )
  2116.         {
  2117.                 try
  2118.                 {
  2119.                         c = FILENAME.at( i );
  2120.                 }
  2121.                 catch( std::out_of_range& e )
  2122.                 {
  2123.                         c = 0;
  2124.                 }
  2125.                 *filename_c_str_iter = c;
  2126.                 ++i;
  2127.                 ++filename_c_str_iter;
  2128.         }
  2129.         if( i < filename_size )
  2130.         {
  2131.                 try
  2132.                 {
  2133.                         c = FILENAME.at( i );
  2134.                 }
  2135.                 catch( std::out_of_range& e )
  2136.                 {
  2137.                         c = 0;
  2138.                 }
  2139.                 *filename_c_str_iter = c;
  2140.                 ++i;
  2141.                 ++filename_c_str_iter;
  2142.         }
  2143.         if( i < filename_size )
  2144.         {
  2145.                 try
  2146.                 {
  2147.                         c = FILENAME.at( i );
  2148.                 }
  2149.                 catch( std::out_of_range& e )
  2150.                 {
  2151.                         c = 0;
  2152.                 }
  2153.                 *filename_c_str_iter = c;
  2154.                 ++i;
  2155.                 ++filename_c_str_iter;
  2156.         }
  2157.         if( i < filename_size )
  2158.         {
  2159.                 try
  2160.                 {
  2161.                         c = FILENAME.at( i );
  2162.                 }
  2163.                 catch( std::out_of_range& e )
  2164.                 {
  2165.                         c = 0;
  2166.                 }
  2167.                 *filename_c_str_iter = c;
  2168.                 ++i;
  2169.                 ++filename_c_str_iter;
  2170.         }
  2171.         if( i < filename_size )
  2172.         {
  2173.                 try
  2174.                 {
  2175.                         c = FILENAME.at( i );
  2176.                 }
  2177.                 catch( std::out_of_range& e )
  2178.                 {
  2179.                         c = 0;
  2180.                 }
  2181.                 *filename_c_str_iter = c;
  2182.                 ++i;
  2183.                 ++filename_c_str_iter;
  2184.         }
  2185.         if( i < filename_size )
  2186.         {
  2187.                 try
  2188.                 {
  2189.                         c = FILENAME.at( i );
  2190.                 }
  2191.                 catch( std::out_of_range& e )
  2192.                 {
  2193.                         c = 0;
  2194.                 }
  2195.                 *filename_c_str_iter = c;
  2196.                 ++i;
  2197.                 ++filename_c_str_iter;
  2198.         }
  2199.         if( i < filename_size )
  2200.         {
  2201.                 try
  2202.                 {
  2203.                         c = FILENAME.at( i );
  2204.                 }
  2205.                 catch( std::out_of_range& e )
  2206.                 {
  2207.                         c = 0;
  2208.                 }
  2209.                 *filename_c_str_iter = c;
  2210.                 ++i;
  2211.                 ++filename_c_str_iter;
  2212.         }
  2213.         if( i < filename_size )
  2214.         {
  2215.                 try
  2216.                 {
  2217.                         c = FILENAME.at( i );
  2218.                 }
  2219.                 catch( std::out_of_range& e )
  2220.                 {
  2221.                         c = 0;
  2222.                 }
  2223.                 *filename_c_str_iter = c;
  2224.                 ++i;
  2225.                 ++filename_c_str_iter;
  2226.         }
  2227.         if( i < filename_size )
  2228.         {
  2229.                 try
  2230.                 {
  2231.                         c = FILENAME.at( i );
  2232.                 }
  2233.                 catch( std::out_of_range& e )
  2234.                 {
  2235.                         c = 0;
  2236.                 }
  2237.                 *filename_c_str_iter = c;
  2238.                 ++i;
  2239.                 ++filename_c_str_iter;
  2240.         }
  2241.         if( i < filename_size )
  2242.         {
  2243.                 try
  2244.                 {
  2245.                         c = FILENAME.at( i );
  2246.                 }
  2247.                 catch( std::out_of_range& e )
  2248.                 {
  2249.                         c = 0;
  2250.                 }
  2251.                 *filename_c_str_iter = c;
  2252.                 ++i;
  2253.                 ++filename_c_str_iter;
  2254.         }
  2255.         if( i < filename_size )
  2256.         {
  2257.                 try
  2258.                 {
  2259.                         c = FILENAME.at( i );
  2260.                 }
  2261.                 catch( std::out_of_range& e )
  2262.                 {
  2263.                         c = 0;
  2264.                 }
  2265.                 *filename_c_str_iter = c;
  2266.                 ++i;
  2267.                 ++filename_c_str_iter;
  2268.         }
  2269.         if( i < filename_size )
  2270.         {
  2271.                 try
  2272.                 {
  2273.                         c = FILENAME.at( i );
  2274.                 }
  2275.                 catch( std::out_of_range& e )
  2276.                 {
  2277.                         c = 0;
  2278.                 }
  2279.                 *filename_c_str_iter = c;
  2280.                 ++i;
  2281.                 ++filename_c_str_iter;
  2282.         }
  2283.         if( i < filename_size )
  2284.         {
  2285.                 try
  2286.                 {
  2287.                         c = FILENAME.at( i );
  2288.                 }
  2289.                 catch( std::out_of_range& e )
  2290.                 {
  2291.                         c = 0;
  2292.                 }
  2293.                 *filename_c_str_iter = c;
  2294.                 ++i;
  2295.                 ++filename_c_str_iter;
  2296.         }
  2297.         if( i < filename_size )
  2298.         {
  2299.                 try
  2300.                 {
  2301.                         c = FILENAME.at( i );
  2302.                 }
  2303.                 catch( std::out_of_range& e )
  2304.                 {
  2305.                         c = 0;
  2306.                 }
  2307.                 *filename_c_str_iter = c;
  2308.                 ++i;
  2309.                 ++filename_c_str_iter;
  2310.         }
  2311.         if( i < filename_size )
  2312.         {
  2313.                 try
  2314.                 {
  2315.                         c = FILENAME.at( i );
  2316.                 }
  2317.                 catch( std::out_of_range& e )
  2318.                 {
  2319.                         c = 0;
  2320.                 }
  2321.                 *filename_c_str_iter = c;
  2322.                 ++i;
  2323.                 ++filename_c_str_iter;
  2324.         }
  2325.         if( i < filename_size )
  2326.         {
  2327.                 try
  2328.                 {
  2329.                         c = FILENAME.at( i );
  2330.                 }
  2331.                 catch( std::out_of_range& e )
  2332.                 {
  2333.                         c = 0;
  2334.                 }
  2335.                 *filename_c_str_iter = c;
  2336.                 ++i;
  2337.                 ++filename_c_str_iter;
  2338.         }
  2339.         if( i < filename_size )
  2340.         {
  2341.                 try
  2342.                 {
  2343.                         c = FILENAME.at( i );
  2344.                 }
  2345.                 catch( std::out_of_range& e )
  2346.                 {
  2347.                         c = 0;
  2348.                 }
  2349.                 *filename_c_str_iter = c;
  2350.                 ++i;
  2351.                 ++filename_c_str_iter;
  2352.         }
  2353.         if( i < filename_size )
  2354.         {
  2355.                 try
  2356.                 {
  2357.                         c = FILENAME.at( i );
  2358.                 }
  2359.                 catch( std::out_of_range& e )
  2360.                 {
  2361.                         c = 0;
  2362.                 }
  2363.                 *filename_c_str_iter = c;
  2364.                 ++i;
  2365.                 ++filename_c_str_iter;
  2366.         }
  2367.         if( i < filename_size )
  2368.         {
  2369.                 try
  2370.                 {
  2371.                         c = FILENAME.at( i );
  2372.                 }
  2373.                 catch( std::out_of_range& e )
  2374.                 {
  2375.                         c = 0;
  2376.                 }
  2377.                 *filename_c_str_iter = c;
  2378.                 ++i;
  2379.                 ++filename_c_str_iter;
  2380.         }
  2381.         if( i < filename_size )
  2382.         {
  2383.                 try
  2384.                 {
  2385.                         c = FILENAME.at( i );
  2386.                 }
  2387.                 catch( std::out_of_range& e )
  2388.                 {
  2389.                         c = 0;
  2390.                 }
  2391.                 *filename_c_str_iter = c;
  2392.                 ++i;
  2393.                 ++filename_c_str_iter;
  2394.         }
  2395.         if( i < filename_size )
  2396.         {
  2397.                 try
  2398.                 {
  2399.                         c = FILENAME.at( i );
  2400.                 }
  2401.                 catch( std::out_of_range& e )
  2402.                 {
  2403.                         c = 0;
  2404.                 }
  2405.                 *filename_c_str_iter = c;
  2406.                 ++i;
  2407.                 ++filename_c_str_iter;
  2408.         }
  2409.         if( i < filename_size )
  2410.         {
  2411.                 try
  2412.                 {
  2413.                         c = FILENAME.at( i );
  2414.                 }
  2415.                 catch( std::out_of_range& e )
  2416.                 {
  2417.                         c = 0;
  2418.                 }
  2419.                 *filename_c_str_iter = c;
  2420.                 ++i;
  2421.                 ++filename_c_str_iter;
  2422.         }
  2423.         if( i < filename_size )
  2424.         {
  2425.                 FileNameTooLong err;
  2426.                 throw( err );
  2427.         }
  2428.         outFile.open( filename_c_str, std::ofstream::out );
  2429.         bool is_open;
  2430.         is_open = outFile.is_open();
  2431.         bool isnt_open;
  2432.         isnt_open = ! is_open;
  2433.         if( isnt_open )
  2434.         {
  2435.                 CouldNotOpenFile err;
  2436.                 throw( err );
  2437.         }
  2438.         uint8_t number_of_entries;
  2439.         cout << "How many entries will you have?";
  2440.         cout << endl;
  2441.         cout << ">> ";
  2442.         cin  >> number_of_entries;
  2443.         number_of_entries -= '0';
  2444.         float entry;
  2445.         uint16_t j;
  2446.         uint8_t ones_digit;
  2447.         bool cin_is_good;
  2448.         bool cin_isnt_good;
  2449.         j = 0;
  2450.         std::string ordinal;
  2451.                 if( j < number_of_entries )
  2452.         {
  2453.                 ++j;
  2454.                 ones_digit = j % 10;
  2455.                 cout << "Please input the ";
  2456.                 cout << j;
  2457.                 switch( ones_digit )
  2458.                 {
  2459.                 case 1:
  2460.                         ordinal = "st";
  2461.                         break;
  2462.                 case 2:
  2463.                         ordinal = "nd";
  2464.                         break;
  2465.                 case 3:
  2466.                         ordinal = "rd";
  2467.                         break;
  2468.                 case 4:
  2469.                         ordinal = "th";
  2470.                         break;
  2471.                 case 5:
  2472.                         ordinal = "th";
  2473.                         break;
  2474.                 case 6:
  2475.                         ordinal = "th";
  2476.                         break;
  2477.                 case 7:
  2478.                         ordinal = "th";
  2479.                         break;
  2480.                 case 8:
  2481.                         ordinal = "th";
  2482.                         break;
  2483.                 case 9:
  2484.                         ordinal = "th";
  2485.                         break;
  2486.                 case 0:
  2487.                         ordinal = "th";
  2488.                         break;
  2489.                 }
  2490.                 cout << ordinal;
  2491.                 cout << " number.";
  2492.                 cout << endl;
  2493.                 cout << ">> ";
  2494.                 cin  >> entry;
  2495.                 cin_is_good = cin.good();
  2496.                 cin_isnt_good = ! cin_is_good;
  2497.                 if( cin_isnt_good )
  2498.                 {
  2499.                         BadEntry err;
  2500.                         throw( err );
  2501.                 }
  2502.                 outFile << entry;
  2503.                 outFile << ' ';
  2504.         }
  2505.         if( j < number_of_entries )
  2506.         {
  2507.                 ++j;
  2508.                 ones_digit = j % 10;
  2509.                 cout << "Please input the ";
  2510.                 cout << j;
  2511.                 switch( ones_digit )
  2512.                 {
  2513.                 case 1:
  2514.                         ordinal = "st";
  2515.                         break;
  2516.                 case 2:
  2517.                         ordinal = "nd";
  2518.                         break;
  2519.                 case 3:
  2520.                         ordinal = "rd";
  2521.                         break;
  2522.                 case 4:
  2523.                         ordinal = "th";
  2524.                         break;
  2525.                 case 5:
  2526.                         ordinal = "th";
  2527.                         break;
  2528.                 case 6:
  2529.                         ordinal = "th";
  2530.                         break;
  2531.                 case 7:
  2532.                         ordinal = "th";
  2533.                         break;
  2534.                 case 8:
  2535.                         ordinal = "th";
  2536.                         break;
  2537.                 case 9:
  2538.                         ordinal = "th";
  2539.                         break;
  2540.                 case 0:
  2541.                         ordinal = "th";
  2542.                         break;
  2543.                 }
  2544.                 cout << ordinal;
  2545.                 cout << " number.";
  2546.                 cout << endl;
  2547.                 cout << ">> ";
  2548.                 cin  >> entry;
  2549.                 cin_is_good = cin.good();
  2550.                 cin_isnt_good = ! cin_is_good;
  2551.                 if( cin_isnt_good )
  2552.                 {
  2553.                         BadEntry err;
  2554.                         throw( err );
  2555.                 }
  2556.                 outFile << entry;
  2557.                 outFile << ' ';
  2558.         }
  2559.         if( j < number_of_entries )
  2560.         {
  2561.                 ++j;
  2562.                 ones_digit = j % 10;
  2563.                 cout << "Please input the ";
  2564.                 cout << j;
  2565.                 switch( ones_digit )
  2566.                 {
  2567.                 case 1:
  2568.                         ordinal = "st";
  2569.                         break;
  2570.                 case 2:
  2571.                         ordinal = "nd";
  2572.                         break;
  2573.                 case 3:
  2574.                         ordinal = "rd";
  2575.                         break;
  2576.                 case 4:
  2577.                         ordinal = "th";
  2578.                         break;
  2579.                 case 5:
  2580.                         ordinal = "th";
  2581.                         break;
  2582.                 case 6:
  2583.                         ordinal = "th";
  2584.                         break;
  2585.                 case 7:
  2586.                         ordinal = "th";
  2587.                         break;
  2588.                 case 8:
  2589.                         ordinal = "th";
  2590.                         break;
  2591.                 case 9:
  2592.                         ordinal = "th";
  2593.                         break;
  2594.                 case 0:
  2595.                         ordinal = "th";
  2596.                         break;
  2597.                 }
  2598.                 cout << ordinal;
  2599.                 cout << " number.";
  2600.                 cout << endl;
  2601.                 cout << ">> ";
  2602.                 cin  >> entry;
  2603.                 cin_is_good = cin.good();
  2604.                 cin_isnt_good = ! cin_is_good;
  2605.                 if( cin_isnt_good )
  2606.                 {
  2607.                         BadEntry err;
  2608.                         throw( err );
  2609.                 }
  2610.                 outFile << entry;
  2611.                 outFile << ' ';
  2612.         }
  2613.         if( j < number_of_entries )
  2614.         {
  2615.                 ++j;
  2616.                 ones_digit = j % 10;
  2617.                 cout << "Please input the ";
  2618.                 cout << j;
  2619.                 switch( ones_digit )
  2620.                 {
  2621.                 case 1:
  2622.                         ordinal = "st";
  2623.                         break;
  2624.                 case 2:
  2625.                         ordinal = "nd";
  2626.                         break;
  2627.                 case 3:
  2628.                         ordinal = "rd";
  2629.                         break;
  2630.                 case 4:
  2631.                         ordinal = "th";
  2632.                         break;
  2633.                 case 5:
  2634.                         ordinal = "th";
  2635.                         break;
  2636.                 case 6:
  2637.                         ordinal = "th";
  2638.                         break;
  2639.                 case 7:
  2640.                         ordinal = "th";
  2641.                         break;
  2642.                 case 8:
  2643.                         ordinal = "th";
  2644.                         break;
  2645.                 case 9:
  2646.                         ordinal = "th";
  2647.                         break;
  2648.                 case 0:
  2649.                         ordinal = "th";
  2650.                         break;
  2651.                 }
  2652.                 cout << ordinal;
  2653.                 cout << " number.";
  2654.                 cout << endl;
  2655.                 cout << ">> ";
  2656.                 cin  >> entry;
  2657.                 cin_is_good = cin.good();
  2658.                 cin_isnt_good = ! cin_is_good;
  2659.                 if( cin_isnt_good )
  2660.                 {
  2661.                         BadEntry err;
  2662.                         throw( err );
  2663.                 }
  2664.                 outFile << entry;
  2665.                 outFile << ' ';
  2666.         }
  2667.         if( j < number_of_entries )
  2668.         {
  2669.                 ++j;
  2670.                 ones_digit = j % 10;
  2671.                 cout << "Please input the ";
  2672.                 cout << j;
  2673.                 switch( ones_digit )
  2674.                 {
  2675.                 case 1:
  2676.                         ordinal = "st";
  2677.                         break;
  2678.                 case 2:
  2679.                         ordinal = "nd";
  2680.                         break;
  2681.                 case 3:
  2682.                         ordinal = "rd";
  2683.                         break;
  2684.                 case 4:
  2685.                         ordinal = "th";
  2686.                         break;
  2687.                 case 5:
  2688.                         ordinal = "th";
  2689.                         break;
  2690.                 case 6:
  2691.                         ordinal = "th";
  2692.                         break;
  2693.                 case 7:
  2694.                         ordinal = "th";
  2695.                         break;
  2696.                 case 8:
  2697.                         ordinal = "th";
  2698.                         break;
  2699.                 case 9:
  2700.                         ordinal = "th";
  2701.                         break;
  2702.                 case 0:
  2703.                         ordinal = "th";
  2704.                         break;
  2705.                 }
  2706.                 cout << ordinal;
  2707.                 cout << " number.";
  2708.                 cout << endl;
  2709.                 cout << ">> ";
  2710.                 cin  >> entry;
  2711.                 cin_is_good = cin.good();
  2712.                 cin_isnt_good = ! cin_is_good;
  2713.                 if( cin_isnt_good )
  2714.                 {
  2715.                         BadEntry err;
  2716.                         throw( err );
  2717.                 }
  2718.                 outFile << entry;
  2719.                 outFile << ' ';
  2720.         }
  2721.         if( j < number_of_entries )
  2722.         {
  2723.                 ++j;
  2724.                 ones_digit = j % 10;
  2725.                 cout << "Please input the ";
  2726.                 cout << j;
  2727.                 switch( ones_digit )
  2728.                 {
  2729.                 case 1:
  2730.                         ordinal = "st";
  2731.                         break;
  2732.                 case 2:
  2733.                         ordinal = "nd";
  2734.                         break;
  2735.                 case 3:
  2736.                         ordinal = "rd";
  2737.                         break;
  2738.                 case 4:
  2739.                         ordinal = "th";
  2740.                         break;
  2741.                 case 5:
  2742.                         ordinal = "th";
  2743.                         break;
  2744.                 case 6:
  2745.                         ordinal = "th";
  2746.                         break;
  2747.                 case 7:
  2748.                         ordinal = "th";
  2749.                         break;
  2750.                 case 8:
  2751.                         ordinal = "th";
  2752.                         break;
  2753.                 case 9:
  2754.                         ordinal = "th";
  2755.                         break;
  2756.                 case 0:
  2757.                         ordinal = "th";
  2758.                         break;
  2759.                 }
  2760.                 cout << ordinal;
  2761.                 cout << " number.";
  2762.                 cout << endl;
  2763.                 cout << ">> ";
  2764.                 cin  >> entry;
  2765.                 cin_is_good = cin.good();
  2766.                 cin_isnt_good = ! cin_is_good;
  2767.                 if( cin_isnt_good )
  2768.                 {
  2769.                         BadEntry err;
  2770.                         throw( err );
  2771.                 }
  2772.                 outFile << entry;
  2773.                 outFile << ' ';
  2774.         }
  2775.         if( j < number_of_entries )
  2776.         {
  2777.                 ++j;
  2778.                 ones_digit = j % 10;
  2779.                 cout << "Please input the ";
  2780.                 cout << j;
  2781.                 switch( ones_digit )
  2782.                 {
  2783.                 case 1:
  2784.                         ordinal = "st";
  2785.                         break;
  2786.                 case 2:
  2787.                         ordinal = "nd";
  2788.                         break;
  2789.                 case 3:
  2790.                         ordinal = "rd";
  2791.                         break;
  2792.                 case 4:
  2793.                         ordinal = "th";
  2794.                         break;
  2795.                 case 5:
  2796.                         ordinal = "th";
  2797.                         break;
  2798.                 case 6:
  2799.                         ordinal = "th";
  2800.                         break;
  2801.                 case 7:
  2802.                         ordinal = "th";
  2803.                         break;
  2804.                 case 8:
  2805.                         ordinal = "th";
  2806.                         break;
  2807.                 case 9:
  2808.                         ordinal = "th";
  2809.                         break;
  2810.                 case 0:
  2811.                         ordinal = "th";
  2812.                         break;
  2813.                 }
  2814.                 cout << ordinal;
  2815.                 cout << " number.";
  2816.                 cout << endl;
  2817.                 cout << ">> ";
  2818.                 cin  >> entry;
  2819.                 cin_is_good = cin.good();
  2820.                 cin_isnt_good = ! cin_is_good;
  2821.                 if( cin_isnt_good )
  2822.                 {
  2823.                         BadEntry err;
  2824.                         throw( err );
  2825.                 }
  2826.                 outFile << entry;
  2827.                 outFile << ' ';
  2828.         }
  2829.         if( j < number_of_entries )
  2830.         {
  2831.                 ++j;
  2832.                 ones_digit = j % 10;
  2833.                 cout << "Please input the ";
  2834.                 cout << j;
  2835.                 switch( ones_digit )
  2836.                 {
  2837.                 case 1:
  2838.                         ordinal = "st";
  2839.                         break;
  2840.                 case 2:
  2841.                         ordinal = "nd";
  2842.                         break;
  2843.                 case 3:
  2844.                         ordinal = "rd";
  2845.                         break;
  2846.                 case 4:
  2847.                         ordinal = "th";
  2848.                         break;
  2849.                 case 5:
  2850.                         ordinal = "th";
  2851.                         break;
  2852.                 case 6:
  2853.                         ordinal = "th";
  2854.                         break;
  2855.                 case 7:
  2856.                         ordinal = "th";
  2857.                         break;
  2858.                 case 8:
  2859.                         ordinal = "th";
  2860.                         break;
  2861.                 case 9:
  2862.                         ordinal = "th";
  2863.                         break;
  2864.                 case 0:
  2865.                         ordinal = "th";
  2866.                         break;
  2867.                 }
  2868.                 cout << ordinal;
  2869.                 cout << " number.";
  2870.                 cout << endl;
  2871.                 cout << ">> ";
  2872.                 cin  >> entry;
  2873.                 cin_is_good = cin.good();
  2874.                 cin_isnt_good = ! cin_is_good;
  2875.                 if( cin_isnt_good )
  2876.                 {
  2877.                         BadEntry err;
  2878.                         throw( err );
  2879.                 }
  2880.                 outFile << entry;
  2881.                 outFile << ' ';
  2882.         }
  2883.         if( j < number_of_entries )
  2884.         {
  2885.                 ++j;
  2886.                 ones_digit = j % 10;
  2887.                 cout << "Please input the ";
  2888.                 cout << j;
  2889.                 switch( ones_digit )
  2890.                 {
  2891.                 case 1:
  2892.                         ordinal = "st";
  2893.                         break;
  2894.                 case 2:
  2895.                         ordinal = "nd";
  2896.                         break;
  2897.                 case 3:
  2898.                         ordinal = "rd";
  2899.                         break;
  2900.                 case 4:
  2901.                         ordinal = "th";
  2902.                         break;
  2903.                 case 5:
  2904.                         ordinal = "th";
  2905.                         break;
  2906.                 case 6:
  2907.                         ordinal = "th";
  2908.                         break;
  2909.                 case 7:
  2910.                         ordinal = "th";
  2911.                         break;
  2912.                 case 8:
  2913.                         ordinal = "th";
  2914.                         break;
  2915.                 case 9:
  2916.                         ordinal = "th";
  2917.                         break;
  2918.                 case 0:
  2919.                         ordinal = "th";
  2920.                         break;
  2921.                 }
  2922.                 cout << ordinal;
  2923.                 cout << " number.";
  2924.                 cout << endl;
  2925.                 cout << ">> ";
  2926.                 cin  >> entry;
  2927.                 cin_is_good = cin.good();
  2928.                 cin_isnt_good = ! cin_is_good;
  2929.                 if( cin_isnt_good )
  2930.                 {
  2931.                         BadEntry err;
  2932.                         throw( err );
  2933.                 }
  2934.                 outFile << entry;
  2935.                 outFile << ' ';
  2936.         }
  2937.         if( j < number_of_entries )
  2938.         {
  2939.                 ++j;
  2940.                 ones_digit = j % 10;
  2941.                 cout << "Please input the ";
  2942.                 cout << j;
  2943.                 switch( ones_digit )
  2944.                 {
  2945.                 case 1:
  2946.                         ordinal = "st";
  2947.                         break;
  2948.                 case 2:
  2949.                         ordinal = "nd";
  2950.                         break;
  2951.                 case 3:
  2952.                         ordinal = "rd";
  2953.                         break;
  2954.                 case 4:
  2955.                         ordinal = "th";
  2956.                         break;
  2957.                 case 5:
  2958.                         ordinal = "th";
  2959.                         break;
  2960.                 case 6:
  2961.                         ordinal = "th";
  2962.                         break;
  2963.                 case 7:
  2964.                         ordinal = "th";
  2965.                         break;
  2966.                 case 8:
  2967.                         ordinal = "th";
  2968.                         break;
  2969.                 case 9:
  2970.                         ordinal = "th";
  2971.                         break;
  2972.                 case 0:
  2973.                         ordinal = "th";
  2974.                         break;
  2975.                 }
  2976.                 cout << ordinal;
  2977.                 cout << " number.";
  2978.                 cout << endl;
  2979.                 cout << ">> ";
  2980.                 cin  >> entry;
  2981.                 cin_is_good = cin.good();
  2982.                 cin_isnt_good = ! cin_is_good;
  2983.                 if( cin_isnt_good )
  2984.                 {
  2985.                         BadEntry err;
  2986.                         throw( err );
  2987.                 }
  2988.                 outFile << entry;
  2989.                 outFile << ' ';
  2990.         }
  2991.         if( j < number_of_entries )
  2992.         {
  2993.                 ++j;
  2994.                 ones_digit = j % 10;
  2995.                 cout << "Please input the ";
  2996.                 cout << j;
  2997.                 switch( ones_digit )
  2998.                 {
  2999.                 case 1:
  3000.                         ordinal = "st";
  3001.                         break;
  3002.                 case 2:
  3003.                         ordinal = "nd";
  3004.                         break;
  3005.                 case 3:
  3006.                         ordinal = "rd";
  3007.                         break;
  3008.                 case 4:
  3009.                         ordinal = "th";
  3010.                         break;
  3011.                 case 5:
  3012.                         ordinal = "th";
  3013.                         break;
  3014.                 case 6:
  3015.                         ordinal = "th";
  3016.                         break;
  3017.                 case 7:
  3018.                         ordinal = "th";
  3019.                         break;
  3020.                 case 8:
  3021.                         ordinal = "th";
  3022.                         break;
  3023.                 case 9:
  3024.                         ordinal = "th";
  3025.                         break;
  3026.                 case 0:
  3027.                         ordinal = "th";
  3028.                         break;
  3029.                 }
  3030.                 cout << ordinal;
  3031.                 cout << " number.";
  3032.                 cout << endl;
  3033.                 cout << ">> ";
  3034.                 cin  >> entry;
  3035.                 cin_is_good = cin.good();
  3036.                 cin_isnt_good = ! cin_is_good;
  3037.                 if( cin_isnt_good )
  3038.                 {
  3039.                         BadEntry err;
  3040.                         throw( err );
  3041.                 }
  3042.                 outFile << entry;
  3043.                 outFile << ' ';
  3044.         }
  3045.         if( j < number_of_entries )
  3046.         {
  3047.                 ++j;
  3048.                 ones_digit = j % 10;
  3049.                 cout << "Please input the ";
  3050.                 cout << j;
  3051.                 switch( ones_digit )
  3052.                 {
  3053.                 case 1:
  3054.                         ordinal = "st";
  3055.                         break;
  3056.                 case 2:
  3057.                         ordinal = "nd";
  3058.                         break;
  3059.                 case 3:
  3060.                         ordinal = "rd";
  3061.                         break;
  3062.                 case 4:
  3063.                         ordinal = "th";
  3064.                         break;
  3065.                 case 5:
  3066.                         ordinal = "th";
  3067.                         break;
  3068.                 case 6:
  3069.                         ordinal = "th";
  3070.                         break;
  3071.                 case 7:
  3072.                         ordinal = "th";
  3073.                         break;
  3074.                 case 8:
  3075.                         ordinal = "th";
  3076.                         break;
  3077.                 case 9:
  3078.                         ordinal = "th";
  3079.                         break;
  3080.                 case 0:
  3081.                         ordinal = "th";
  3082.                         break;
  3083.                 }
  3084.                 cout << ordinal;
  3085.                 cout << " number.";
  3086.                 cout << endl;
  3087.                 cout << ">> ";
  3088.                 cin  >> entry;
  3089.                 cin_is_good = cin.good();
  3090.                 cin_isnt_good = ! cin_is_good;
  3091.                 if( cin_isnt_good )
  3092.                 {
  3093.                         BadEntry err;
  3094.                         throw( err );
  3095.                 }
  3096.                 outFile << entry;
  3097.                 outFile << ' ';
  3098.         }
  3099.         if( j < number_of_entries )
  3100.         {
  3101.                 ++j;
  3102.                 ones_digit = j % 10;
  3103.                 cout << "Please input the ";
  3104.                 cout << j;
  3105.                 switch( ones_digit )
  3106.                 {
  3107.                 case 1:
  3108.                         ordinal = "st";
  3109.                         break;
  3110.                 case 2:
  3111.                         ordinal = "nd";
  3112.                         break;
  3113.                 case 3:
  3114.                         ordinal = "rd";
  3115.                         break;
  3116.                 case 4:
  3117.                         ordinal = "th";
  3118.                         break;
  3119.                 case 5:
  3120.                         ordinal = "th";
  3121.                         break;
  3122.                 case 6:
  3123.                         ordinal = "th";
  3124.                         break;
  3125.                 case 7:
  3126.                         ordinal = "th";
  3127.                         break;
  3128.                 case 8:
  3129.                         ordinal = "th";
  3130.                         break;
  3131.                 case 9:
  3132.                         ordinal = "th";
  3133.                         break;
  3134.                 case 0:
  3135.                         ordinal = "th";
  3136.                         break;
  3137.                 }
  3138.                 cout << ordinal;
  3139.                 cout << " number.";
  3140.                 cout << endl;
  3141.                 cout << ">> ";
  3142.                 cin  >> entry;
  3143.                 cin_is_good = cin.good();
  3144.                 cin_isnt_good = ! cin_is_good;
  3145.                 if( cin_isnt_good )
  3146.                 {
  3147.                         BadEntry err;
  3148.                         throw( err );
  3149.                 }
  3150.                 outFile << entry;
  3151.                 outFile << ' ';
  3152.         }
  3153.         if( j < number_of_entries )
  3154.         {
  3155.                 ++j;
  3156.                 ones_digit = j % 10;
  3157.                 cout << "Please input the ";
  3158.                 cout << j;
  3159.                 switch( ones_digit )
  3160.                 {
  3161.                 case 1:
  3162.                         ordinal = "st";
  3163.                         break;
  3164.                 case 2:
  3165.                         ordinal = "nd";
  3166.                         break;
  3167.                 case 3:
  3168.                         ordinal = "rd";
  3169.                         break;
  3170.                 case 4:
  3171.                         ordinal = "th";
  3172.                         break;
  3173.                 case 5:
  3174.                         ordinal = "th";
  3175.                         break;
  3176.                 case 6:
  3177.                         ordinal = "th";
  3178.                         break;
  3179.                 case 7:
  3180.                         ordinal = "th";
  3181.                         break;
  3182.                 case 8:
  3183.                         ordinal = "th";
  3184.                         break;
  3185.                 case 9:
  3186.                         ordinal = "th";
  3187.                         break;
  3188.                 case 0:
  3189.                         ordinal = "th";
  3190.                         break;
  3191.                 }
  3192.                 cout << ordinal;
  3193.                 cout << " number.";
  3194.                 cout << endl;
  3195.                 cout << ">> ";
  3196.                 cin  >> entry;
  3197.                 cin_is_good = cin.good();
  3198.                 cin_isnt_good = ! cin_is_good;
  3199.                 if( cin_isnt_good )
  3200.                 {
  3201.                         BadEntry err;
  3202.                         throw( err );
  3203.                 }
  3204.                 outFile << entry;
  3205.                 outFile << ' ';
  3206.         }
  3207.         if( j < number_of_entries )
  3208.         {
  3209.                 ++j;
  3210.                 ones_digit = j % 10;
  3211.                 cout << "Please input the ";
  3212.                 cout << j;
  3213.                 switch( ones_digit )
  3214.                 {
  3215.                 case 1:
  3216.                         ordinal = "st";
  3217.                         break;
  3218.                 case 2:
  3219.                         ordinal = "nd";
  3220.                         break;
  3221.                 case 3:
  3222.                         ordinal = "rd";
  3223.                         break;
  3224.                 case 4:
  3225.                         ordinal = "th";
  3226.                         break;
  3227.                 case 5:
  3228.                         ordinal = "th";
  3229.                         break;
  3230.                 case 6:
  3231.                         ordinal = "th";
  3232.                         break;
  3233.                 case 7:
  3234.                         ordinal = "th";
  3235.                         break;
  3236.                 case 8:
  3237.                         ordinal = "th";
  3238.                         break;
  3239.                 case 9:
  3240.                         ordinal = "th";
  3241.                         break;
  3242.                 case 0:
  3243.                         ordinal = "th";
  3244.                         break;
  3245.                 }
  3246.                 cout << ordinal;
  3247.                 cout << " number.";
  3248.                 cout << endl;
  3249.                 cout << ">> ";
  3250.                 cin  >> entry;
  3251.                 cin_is_good = cin.good();
  3252.                 cin_isnt_good = ! cin_is_good;
  3253.                 if( cin_isnt_good )
  3254.                 {
  3255.                         BadEntry err;
  3256.                         throw( err );
  3257.                 }
  3258.                 outFile << entry;
  3259.                 outFile << ' ';
  3260.         }
  3261.         if( j < number_of_entries )
  3262.         {
  3263.                 ++j;
  3264.                 ones_digit = j % 10;
  3265.                 cout << "Please input the ";
  3266.                 cout << j;
  3267.                 switch( ones_digit )
  3268.                 {
  3269.                 case 1:
  3270.                         ordinal = "st";
  3271.                         break;
  3272.                 case 2:
  3273.                         ordinal = "nd";
  3274.                         break;
  3275.                 case 3:
  3276.                         ordinal = "rd";
  3277.                         break;
  3278.                 case 4:
  3279.                         ordinal = "th";
  3280.                         break;
  3281.                 case 5:
  3282.                         ordinal = "th";
  3283.                         break;
  3284.                 case 6:
  3285.                         ordinal = "th";
  3286.                         break;
  3287.                 case 7:
  3288.                         ordinal = "th";
  3289.                         break;
  3290.                 case 8:
  3291.                         ordinal = "th";
  3292.                         break;
  3293.                 case 9:
  3294.                         ordinal = "th";
  3295.                         break;
  3296.                 case 0:
  3297.                         ordinal = "th";
  3298.                         break;
  3299.                 }
  3300.                 cout << ordinal;
  3301.                 cout << " number.";
  3302.                 cout << endl;
  3303.                 cout << ">> ";
  3304.                 cin  >> entry;
  3305.                 cin_is_good = cin.good();
  3306.                 cin_isnt_good = ! cin_is_good;
  3307.                 if( cin_isnt_good )
  3308.                 {
  3309.                         BadEntry err;
  3310.                         throw( err );
  3311.                 }
  3312.                 outFile << entry;
  3313.                 outFile << ' ';
  3314.         }
  3315.         if( j < number_of_entries )
  3316.         {
  3317.                 ++j;
  3318.                 ones_digit = j % 10;
  3319.                 cout << "Please input the ";
  3320.                 cout << j;
  3321.                 switch( ones_digit )
  3322.                 {
  3323.                 case 1:
  3324.                         ordinal = "st";
  3325.                         break;
  3326.                 case 2:
  3327.                         ordinal = "nd";
  3328.                         break;
  3329.                 case 3:
  3330.                         ordinal = "rd";
  3331.                         break;
  3332.                 case 4:
  3333.                         ordinal = "th";
  3334.                         break;
  3335.                 case 5:
  3336.                         ordinal = "th";
  3337.                         break;
  3338.                 case 6:
  3339.                         ordinal = "th";
  3340.                         break;
  3341.                 case 7:
  3342.                         ordinal = "th";
  3343.                         break;
  3344.                 case 8:
  3345.                         ordinal = "th";
  3346.                         break;
  3347.                 case 9:
  3348.                         ordinal = "th";
  3349.                         break;
  3350.                 case 0:
  3351.                         ordinal = "th";
  3352.                         break;
  3353.                 }
  3354.                 cout << ordinal;
  3355.                 cout << " number.";
  3356.                 cout << endl;
  3357.                 cout << ">> ";
  3358.                 cin  >> entry;
  3359.                 cin_is_good = cin.good();
  3360.                 cin_isnt_good = ! cin_is_good;
  3361.                 if( cin_isnt_good )
  3362.                 {
  3363.                         BadEntry err;
  3364.                         throw( err );
  3365.                 }
  3366.                 outFile << entry;
  3367.                 outFile << ' ';
  3368.         }
  3369.         if( j < number_of_entries )
  3370.         {
  3371.                 ++j;
  3372.                 ones_digit = j % 10;
  3373.                 cout << "Please input the ";
  3374.                 cout << j;
  3375.                 switch( ones_digit )
  3376.                 {
  3377.                 case 1:
  3378.                         ordinal = "st";
  3379.                         break;
  3380.                 case 2:
  3381.                         ordinal = "nd";
  3382.                         break;
  3383.                 case 3:
  3384.                         ordinal = "rd";
  3385.                         break;
  3386.                 case 4:
  3387.                         ordinal = "th";
  3388.                         break;
  3389.                 case 5:
  3390.                         ordinal = "th";
  3391.                         break;
  3392.                 case 6:
  3393.                         ordinal = "th";
  3394.                         break;
  3395.                 case 7:
  3396.                         ordinal = "th";
  3397.                         break;
  3398.                 case 8:
  3399.                         ordinal = "th";
  3400.                         break;
  3401.                 case 9:
  3402.                         ordinal = "th";
  3403.                         break;
  3404.                 case 0:
  3405.                         ordinal = "th";
  3406.                         break;
  3407.                 }
  3408.                 cout << ordinal;
  3409.                 cout << " number.";
  3410.                 cout << endl;
  3411.                 cout << ">> ";
  3412.                 cin  >> entry;
  3413.                 cin_is_good = cin.good();
  3414.                 cin_isnt_good = ! cin_is_good;
  3415.                 if( cin_isnt_good )
  3416.                 {
  3417.                         BadEntry err;
  3418.                         throw( err );
  3419.                 }
  3420.                 outFile << entry;
  3421.                 outFile << ' ';
  3422.         }
  3423.         if( j < number_of_entries )
  3424.         {
  3425.                 ++j;
  3426.                 ones_digit = j % 10;
  3427.                 cout << "Please input the ";
  3428.                 cout << j;
  3429.                 switch( ones_digit )
  3430.                 {
  3431.                 case 1:
  3432.                         ordinal = "st";
  3433.                         break;
  3434.                 case 2:
  3435.                         ordinal = "nd";
  3436.                         break;
  3437.                 case 3:
  3438.                         ordinal = "rd";
  3439.                         break;
  3440.                 case 4:
  3441.                         ordinal = "th";
  3442.                         break;
  3443.                 case 5:
  3444.                         ordinal = "th";
  3445.                         break;
  3446.                 case 6:
  3447.                         ordinal = "th";
  3448.                         break;
  3449.                 case 7:
  3450.                         ordinal = "th";
  3451.                         break;
  3452.                 case 8:
  3453.                         ordinal = "th";
  3454.                         break;
  3455.                 case 9:
  3456.                         ordinal = "th";
  3457.                         break;
  3458.                 case 0:
  3459.                         ordinal = "th";
  3460.                         break;
  3461.                 }
  3462.                 cout << ordinal;
  3463.                 cout << " number.";
  3464.                 cout << endl;
  3465.                 cout << ">> ";
  3466.                 cin  >> entry;
  3467.                 cin_is_good = cin.good();
  3468.                 cin_isnt_good = ! cin_is_good;
  3469.                 if( cin_isnt_good )
  3470.                 {
  3471.                         BadEntry err;
  3472.                         throw( err );
  3473.                 }
  3474.                 outFile << entry;
  3475.                 outFile << ' ';
  3476.         }
  3477.         if( j < number_of_entries )
  3478.         {
  3479.                 ++j;
  3480.                 ones_digit = j % 10;
  3481.                 cout << "Please input the ";
  3482.                 cout << j;
  3483.                 switch( ones_digit )
  3484.                 {
  3485.                 case 1:
  3486.                         ordinal = "st";
  3487.                         break;
  3488.                 case 2:
  3489.                         ordinal = "nd";
  3490.                         break;
  3491.                 case 3:
  3492.                         ordinal = "rd";
  3493.                         break;
  3494.                 case 4:
  3495.                         ordinal = "th";
  3496.                         break;
  3497.                 case 5:
  3498.                         ordinal = "th";
  3499.                         break;
  3500.                 case 6:
  3501.                         ordinal = "th";
  3502.                         break;
  3503.                 case 7:
  3504.                         ordinal = "th";
  3505.                         break;
  3506.                 case 8:
  3507.                         ordinal = "th";
  3508.                         break;
  3509.                 case 9:
  3510.                         ordinal = "th";
  3511.                         break;
  3512.                 case 0:
  3513.                         ordinal = "th";
  3514.                         break;
  3515.                 }
  3516.                 cout << ordinal;
  3517.                 cout << " number.";
  3518.                 cout << endl;
  3519.                 cout << ">> ";
  3520.                 cin  >> entry;
  3521.                 cin_is_good = cin.good();
  3522.                 cin_isnt_good = ! cin_is_good;
  3523.                 if( cin_isnt_good )
  3524.                 {
  3525.                         BadEntry err;
  3526.                         throw( err );
  3527.                 }
  3528.                 outFile << entry;
  3529.                 outFile << ' ';
  3530.         }
  3531.         if( j < number_of_entries )
  3532.         {
  3533.                 ++j;
  3534.                 ones_digit = j % 10;
  3535.                 cout << "Please input the ";
  3536.                 cout << j;
  3537.                 switch( ones_digit )
  3538.                 {
  3539.                 case 1:
  3540.                         ordinal = "st";
  3541.                         break;
  3542.                 case 2:
  3543.                         ordinal = "nd";
  3544.                         break;
  3545.                 case 3:
  3546.                         ordinal = "rd";
  3547.                         break;
  3548.                 case 4:
  3549.                         ordinal = "th";
  3550.                         break;
  3551.                 case 5:
  3552.                         ordinal = "th";
  3553.                         break;
  3554.                 case 6:
  3555.                         ordinal = "th";
  3556.                         break;
  3557.                 case 7:
  3558.                         ordinal = "th";
  3559.                         break;
  3560.                 case 8:
  3561.                         ordinal = "th";
  3562.                         break;
  3563.                 case 9:
  3564.                         ordinal = "th";
  3565.                         break;
  3566.                 case 0:
  3567.                         ordinal = "th";
  3568.                         break;
  3569.                 }
  3570.                 cout << ordinal;
  3571.                 cout << " number.";
  3572.                 cout << endl;
  3573.                 cout << ">> ";
  3574.                 cin  >> entry;
  3575.                 cin_is_good = cin.good();
  3576.                 cin_isnt_good = ! cin_is_good;
  3577.                 if( cin_isnt_good )
  3578.                 {
  3579.                         BadEntry err;
  3580.                         throw( err );
  3581.                 }
  3582.                 outFile << entry;
  3583.                 outFile << ' ';
  3584.         }
  3585.         if( j < number_of_entries )
  3586.         {
  3587.                 ++j;
  3588.                 ones_digit = j % 10;
  3589.                 cout << "Please input the ";
  3590.                 cout << j;
  3591.                 switch( ones_digit )
  3592.                 {
  3593.                 case 1:
  3594.                         ordinal = "st";
  3595.                         break;
  3596.                 case 2:
  3597.                         ordinal = "nd";
  3598.                         break;
  3599.                 case 3:
  3600.                         ordinal = "rd";
  3601.                         break;
  3602.                 case 4:
  3603.                         ordinal = "th";
  3604.                         break;
  3605.                 case 5:
  3606.                         ordinal = "th";
  3607.                         break;
  3608.                 case 6:
  3609.                         ordinal = "th";
  3610.                         break;
  3611.                 case 7:
  3612.                         ordinal = "th";
  3613.                         break;
  3614.                 case 8:
  3615.                         ordinal = "th";
  3616.                         break;
  3617.                 case 9:
  3618.                         ordinal = "th";
  3619.                         break;
  3620.                 case 0:
  3621.                         ordinal = "th";
  3622.                         break;
  3623.                 }
  3624.                 cout << ordinal;
  3625.                 cout << " number.";
  3626.                 cout << endl;
  3627.                 cout << ">> ";
  3628.                 cin  >> entry;
  3629.                 cin_is_good = cin.good();
  3630.                 cin_isnt_good = ! cin_is_good;
  3631.                 if( cin_isnt_good )
  3632.                 {
  3633.                         BadEntry err;
  3634.                         throw( err );
  3635.                 }
  3636.                 outFile << entry;
  3637.                 outFile << ' ';
  3638.         }
  3639.         if( j < number_of_entries )
  3640.         {
  3641.                 ++j;
  3642.                 ones_digit = j % 10;
  3643.                 cout << "Please input the ";
  3644.                 cout << j;
  3645.                 switch( ones_digit )
  3646.                 {
  3647.                 case 1:
  3648.                         ordinal = "st";
  3649.                         break;
  3650.                 case 2:
  3651.                         ordinal = "nd";
  3652.                         break;
  3653.                 case 3:
  3654.                         ordinal = "rd";
  3655.                         break;
  3656.                 case 4:
  3657.                         ordinal = "th";
  3658.                         break;
  3659.                 case 5:
  3660.                         ordinal = "th";
  3661.                         break;
  3662.                 case 6:
  3663.                         ordinal = "th";
  3664.                         break;
  3665.                 case 7:
  3666.                         ordinal = "th";
  3667.                         break;
  3668.                 case 8:
  3669.                         ordinal = "th";
  3670.                         break;
  3671.                 case 9:
  3672.                         ordinal = "th";
  3673.                         break;
  3674.                 case 0:
  3675.                         ordinal = "th";
  3676.                         break;
  3677.                 }
  3678.                 cout << ordinal;
  3679.                 cout << " number.";
  3680.                 cout << endl;
  3681.                 cout << ">> ";
  3682.                 cin  >> entry;
  3683.                 cin_is_good = cin.good();
  3684.                 cin_isnt_good = ! cin_is_good;
  3685.                 if( cin_isnt_good )
  3686.                 {
  3687.                         BadEntry err;
  3688.                         throw( err );
  3689.                 }
  3690.                 outFile << entry;
  3691.                 outFile << ' ';
  3692.         }
  3693.         if( j < number_of_entries )
  3694.         {
  3695.                 ++j;
  3696.                 ones_digit = j % 10;
  3697.                 cout << "Please input the ";
  3698.                 cout << j;
  3699.                 switch( ones_digit )
  3700.                 {
  3701.                 case 1:
  3702.                         ordinal = "st";
  3703.                         break;
  3704.                 case 2:
  3705.                         ordinal = "nd";
  3706.                         break;
  3707.                 case 3:
  3708.                         ordinal = "rd";
  3709.                         break;
  3710.                 case 4:
  3711.                         ordinal = "th";
  3712.                         break;
  3713.                 case 5:
  3714.                         ordinal = "th";
  3715.                         break;
  3716.                 case 6:
  3717.                         ordinal = "th";
  3718.                         break;
  3719.                 case 7:
  3720.                         ordinal = "th";
  3721.                         break;
  3722.                 case 8:
  3723.                         ordinal = "th";
  3724.                         break;
  3725.                 case 9:
  3726.                         ordinal = "th";
  3727.                         break;
  3728.                 case 0:
  3729.                         ordinal = "th";
  3730.                         break;
  3731.                 }
  3732.                 cout << ordinal;
  3733.                 cout << " number.";
  3734.                 cout << endl;
  3735.                 cout << ">> ";
  3736.                 cin  >> entry;
  3737.                 cin_is_good = cin.good();
  3738.                 cin_isnt_good = ! cin_is_good;
  3739.                 if( cin_isnt_good )
  3740.                 {
  3741.                         BadEntry err;
  3742.                         throw( err );
  3743.                 }
  3744.                 outFile << entry;
  3745.                 outFile << ' ';
  3746.         }
  3747.         if( j < number_of_entries )
  3748.         {
  3749.                 ++j;
  3750.                 ones_digit = j % 10;
  3751.                 cout << "Please input the ";
  3752.                 cout << j;
  3753.                 switch( ones_digit )
  3754.                 {
  3755.                 case 1:
  3756.                         ordinal = "st";
  3757.                         break;
  3758.                 case 2:
  3759.                         ordinal = "nd";
  3760.                         break;
  3761.                 case 3:
  3762.                         ordinal = "rd";
  3763.                         break;
  3764.                 case 4:
  3765.                         ordinal = "th";
  3766.                         break;
  3767.                 case 5:
  3768.                         ordinal = "th";
  3769.                         break;
  3770.                 case 6:
  3771.                         ordinal = "th";
  3772.                         break;
  3773.                 case 7:
  3774.                         ordinal = "th";
  3775.                         break;
  3776.                 case 8:
  3777.                         ordinal = "th";
  3778.                         break;
  3779.                 case 9:
  3780.                         ordinal = "th";
  3781.                         break;
  3782.                 case 0:
  3783.                         ordinal = "th";
  3784.                         break;
  3785.                 }
  3786.                 cout << ordinal;
  3787.                 cout << " number.";
  3788.                 cout << endl;
  3789.                 cout << ">> ";
  3790.                 cin  >> entry;
  3791.                 cin_is_good = cin.good();
  3792.                 cin_isnt_good = ! cin_is_good;
  3793.                 if( cin_isnt_good )
  3794.                 {
  3795.                         BadEntry err;
  3796.                         throw( err );
  3797.                 }
  3798.                 outFile << entry;
  3799.                 outFile << ' ';
  3800.         }
  3801.         if( j < number_of_entries )
  3802.         {
  3803.                 ++j;
  3804.                 ones_digit = j % 10;
  3805.                 cout << "Please input the ";
  3806.                 cout << j;
  3807.                 switch( ones_digit )
  3808.                 {
  3809.                 case 1:
  3810.                         ordinal = "st";
  3811.                         break;
  3812.                 case 2:
  3813.                         ordinal = "nd";
  3814.                         break;
  3815.                 case 3:
  3816.                         ordinal = "rd";
  3817.                         break;
  3818.                 case 4:
  3819.                         ordinal = "th";
  3820.                         break;
  3821.                 case 5:
  3822.                         ordinal = "th";
  3823.                         break;
  3824.                 case 6:
  3825.                         ordinal = "th";
  3826.                         break;
  3827.                 case 7:
  3828.                         ordinal = "th";
  3829.                         break;
  3830.                 case 8:
  3831.                         ordinal = "th";
  3832.                         break;
  3833.                 case 9:
  3834.                         ordinal = "th";
  3835.                         break;
  3836.                 case 0:
  3837.                         ordinal = "th";
  3838.                         break;
  3839.                 }
  3840.                 cout << ordinal;
  3841.                 cout << " number.";
  3842.                 cout << endl;
  3843.                 cout << ">> ";
  3844.                 cin  >> entry;
  3845.                 cin_is_good = cin.good();
  3846.                 cin_isnt_good = ! cin_is_good;
  3847.                 if( cin_isnt_good )
  3848.                 {
  3849.                         BadEntry err;
  3850.                         throw( err );
  3851.                 }
  3852.                 outFile << entry;
  3853.                 outFile << ' ';
  3854.         }
  3855.         if( j < number_of_entries )
  3856.         {
  3857.                 ++j;
  3858.                 ones_digit = j % 10;
  3859.                 cout << "Please input the ";
  3860.                 cout << j;
  3861.                 switch( ones_digit )
  3862.                 {
  3863.                 case 1:
  3864.                         ordinal = "st";
  3865.                         break;
  3866.                 case 2:
  3867.                         ordinal = "nd";
  3868.                         break;
  3869.                 case 3:
  3870.                         ordinal = "rd";
  3871.                         break;
  3872.                 case 4:
  3873.                         ordinal = "th";
  3874.                         break;
  3875.                 case 5:
  3876.                         ordinal = "th";
  3877.                         break;
  3878.                 case 6:
  3879.                         ordinal = "th";
  3880.                         break;
  3881.                 case 7:
  3882.                         ordinal = "th";
  3883.                         break;
  3884.                 case 8:
  3885.                         ordinal = "th";
  3886.                         break;
  3887.                 case 9:
  3888.                         ordinal = "th";
  3889.                         break;
  3890.                 case 0:
  3891.                         ordinal = "th";
  3892.                         break;
  3893.                 }
  3894.                 cout << ordinal;
  3895.                 cout << " number.";
  3896.                 cout << endl;
  3897.                 cout << ">> ";
  3898.                 cin  >> entry;
  3899.                 cin_is_good = cin.good();
  3900.                 cin_isnt_good = ! cin_is_good;
  3901.                 if( cin_isnt_good )
  3902.                 {
  3903.                         BadEntry err;
  3904.                         throw( err );
  3905.                 }
  3906.                 outFile << entry;
  3907.                 outFile << ' ';
  3908.         }
  3909.         if( j < number_of_entries )
  3910.         {
  3911.                 ++j;
  3912.                 ones_digit = j % 10;
  3913.                 cout << "Please input the ";
  3914.                 cout << j;
  3915.                 switch( ones_digit )
  3916.                 {
  3917.                 case 1:
  3918.                         ordinal = "st";
  3919.                         break;
  3920.                 case 2:
  3921.                         ordinal = "nd";
  3922.                         break;
  3923.                 case 3:
  3924.                         ordinal = "rd";
  3925.                         break;
  3926.                 case 4:
  3927.                         ordinal = "th";
  3928.                         break;
  3929.                 case 5:
  3930.                         ordinal = "th";
  3931.                         break;
  3932.                 case 6:
  3933.                         ordinal = "th";
  3934.                         break;
  3935.                 case 7:
  3936.                         ordinal = "th";
  3937.                         break;
  3938.                 case 8:
  3939.                         ordinal = "th";
  3940.                         break;
  3941.                 case 9:
  3942.                         ordinal = "th";
  3943.                         break;
  3944.                 case 0:
  3945.                         ordinal = "th";
  3946.                         break;
  3947.                 }
  3948.                 cout << ordinal;
  3949.                 cout << " number.";
  3950.                 cout << endl;
  3951.                 cout << ">> ";
  3952.                 cin  >> entry;
  3953.                 cin_is_good = cin.good();
  3954.                 cin_isnt_good = ! cin_is_good;
  3955.                 if( cin_isnt_good )
  3956.                 {
  3957.                         BadEntry err;
  3958.                         throw( err );
  3959.                 }
  3960.                 outFile << entry;
  3961.                 outFile << ' ';
  3962.         }
  3963.         if( j < number_of_entries )
  3964.         {
  3965.                 ++j;
  3966.                 ones_digit = j % 10;
  3967.                 cout << "Please input the ";
  3968.                 cout << j;
  3969.                 switch( ones_digit )
  3970.                 {
  3971.                 case 1:
  3972.                         ordinal = "st";
  3973.                         break;
  3974.                 case 2:
  3975.                         ordinal = "nd";
  3976.                         break;
  3977.                 case 3:
  3978.                         ordinal = "rd";
  3979.                         break;
  3980.                 case 4:
  3981.                         ordinal = "th";
  3982.                         break;
  3983.                 case 5:
  3984.                         ordinal = "th";
  3985.                         break;
  3986.                 case 6:
  3987.                         ordinal = "th";
  3988.                         break;
  3989.                 case 7:
  3990.                         ordinal = "th";
  3991.                         break;
  3992.                 case 8:
  3993.                         ordinal = "th";
  3994.                         break;
  3995.                 case 9:
  3996.                         ordinal = "th";
  3997.                         break;
  3998.                 case 0:
  3999.                         ordinal = "th";
  4000.                         break;
  4001.                 }
  4002.                 cout << ordinal;
  4003.                 cout << " number.";
  4004.                 cout << endl;
  4005.                 cout << ">> ";
  4006.                 cin  >> entry;
  4007.                 cin_is_good = cin.good();
  4008.                 cin_isnt_good = ! cin_is_good;
  4009.                 if( cin_isnt_good )
  4010.                 {
  4011.                         BadEntry err;
  4012.                         throw( err );
  4013.                 }
  4014.                 outFile << entry;
  4015.                 outFile << ' ';
  4016.         }
  4017.         if( j < number_of_entries )
  4018.         {
  4019.                 ++j;
  4020.                 ones_digit = j % 10;
  4021.                 cout << "Please input the ";
  4022.                 cout << j;
  4023.                 switch( ones_digit )
  4024.                 {
  4025.                 case 1:
  4026.                         ordinal = "st";
  4027.                         break;
  4028.                 case 2:
  4029.                         ordinal = "nd";
  4030.                         break;
  4031.                 case 3:
  4032.                         ordinal = "rd";
  4033.                         break;
  4034.                 case 4:
  4035.                         ordinal = "th";
  4036.                         break;
  4037.                 case 5:
  4038.                         ordinal = "th";
  4039.                         break;
  4040.                 case 6:
  4041.                         ordinal = "th";
  4042.                         break;
  4043.                 case 7:
  4044.                         ordinal = "th";
  4045.                         break;
  4046.                 case 8:
  4047.                         ordinal = "th";
  4048.                         break;
  4049.                 case 9:
  4050.                         ordinal = "th";
  4051.                         break;
  4052.                 case 0:
  4053.                         ordinal = "th";
  4054.                         break;
  4055.                 }
  4056.                 cout << ordinal;
  4057.                 cout << " number.";
  4058.                 cout << endl;
  4059.                 cout << ">> ";
  4060.                 cin  >> entry;
  4061.                 cin_is_good = cin.good();
  4062.                 cin_isnt_good = ! cin_is_good;
  4063.                 if( cin_isnt_good )
  4064.                 {
  4065.                         BadEntry err;
  4066.                         throw( err );
  4067.                 }
  4068.                 outFile << entry;
  4069.                 outFile << ' ';
  4070.         }
  4071.         if( j < number_of_entries )
  4072.         {
  4073.                 ++j;
  4074.                 ones_digit = j % 10;
  4075.                 cout << "Please input the ";
  4076.                 cout << j;
  4077.                 switch( ones_digit )
  4078.                 {
  4079.                 case 1:
  4080.                         ordinal = "st";
  4081.                         break;
  4082.                 case 2:
  4083.                         ordinal = "nd";
  4084.                         break;
  4085.                 case 3:
  4086.                         ordinal = "rd";
  4087.                         break;
  4088.                 case 4:
  4089.                         ordinal = "th";
  4090.                         break;
  4091.                 case 5:
  4092.                         ordinal = "th";
  4093.                         break;
  4094.                 case 6:
  4095.                         ordinal = "th";
  4096.                         break;
  4097.                 case 7:
  4098.                         ordinal = "th";
  4099.                         break;
  4100.                 case 8:
  4101.                         ordinal = "th";
  4102.                         break;
  4103.                 case 9:
  4104.                         ordinal = "th";
  4105.                         break;
  4106.                 case 0:
  4107.                         ordinal = "th";
  4108.                         break;
  4109.                 }
  4110.                 cout << ordinal;
  4111.                 cout << " number.";
  4112.                 cout << endl;
  4113.                 cout << ">> ";
  4114.                 cin  >> entry;
  4115.                 cin_is_good = cin.good();
  4116.                 cin_isnt_good = ! cin_is_good;
  4117.                 if( cin_isnt_good )
  4118.                 {
  4119.                         BadEntry err;
  4120.                         throw( err );
  4121.                 }
  4122.                 outFile << entry;
  4123.                 outFile << ' ';
  4124.         }
  4125.         if( j < number_of_entries )
  4126.         {
  4127.                 ++j;
  4128.                 ones_digit = j % 10;
  4129.                 cout << "Please input the ";
  4130.                 cout << j;
  4131.                 switch( ones_digit )
  4132.                 {
  4133.                 case 1:
  4134.                         ordinal = "st";
  4135.                         break;
  4136.                 case 2:
  4137.                         ordinal = "nd";
  4138.                         break;
  4139.                 case 3:
  4140.                         ordinal = "rd";
  4141.                         break;
  4142.                 case 4:
  4143.                         ordinal = "th";
  4144.                         break;
  4145.                 case 5:
  4146.                         ordinal = "th";
  4147.                         break;
  4148.                 case 6:
  4149.                         ordinal = "th";
  4150.                         break;
  4151.                 case 7:
  4152.                         ordinal = "th";
  4153.                         break;
  4154.                 case 8:
  4155.                         ordinal = "th";
  4156.                         break;
  4157.                 case 9:
  4158.                         ordinal = "th";
  4159.                         break;
  4160.                 case 0:
  4161.                         ordinal = "th";
  4162.                         break;
  4163.                 }
  4164.                 cout << ordinal;
  4165.                 cout << " number.";
  4166.                 cout << endl;
  4167.                 cout << ">> ";
  4168.                 cin  >> entry;
  4169.                 cin_is_good = cin.good();
  4170.                 cin_isnt_good = ! cin_is_good;
  4171.                 if( cin_isnt_good )
  4172.                 {
  4173.                         BadEntry err;
  4174.                         throw( err );
  4175.                 }
  4176.                 outFile << entry;
  4177.                 outFile << ' ';
  4178.         }
  4179.         if( j < number_of_entries )
  4180.         {
  4181.                 ++j;
  4182.                 ones_digit = j % 10;
  4183.                 cout << "Please input the ";
  4184.                 cout << j;
  4185.                 switch( ones_digit )
  4186.                 {
  4187.                 case 1:
  4188.                         ordinal = "st";
  4189.                         break;
  4190.                 case 2:
  4191.                         ordinal = "nd";
  4192.                         break;
  4193.                 case 3:
  4194.                         ordinal = "rd";
  4195.                         break;
  4196.                 case 4:
  4197.                         ordinal = "th";
  4198.                         break;
  4199.                 case 5:
  4200.                         ordinal = "th";
  4201.                         break;
  4202.                 case 6:
  4203.                         ordinal = "th";
  4204.                         break;
  4205.                 case 7:
  4206.                         ordinal = "th";
  4207.                         break;
  4208.                 case 8:
  4209.                         ordinal = "th";
  4210.                         break;
  4211.                 case 9:
  4212.                         ordinal = "th";
  4213.                         break;
  4214.                 case 0:
  4215.                         ordinal = "th";
  4216.                         break;
  4217.                 }
  4218.                 cout << ordinal;
  4219.                 cout << " number.";
  4220.                 cout << endl;
  4221.                 cout << ">> ";
  4222.                 cin  >> entry;
  4223.                 cin_is_good = cin.good();
  4224.                 cin_isnt_good = ! cin_is_good;
  4225.                 if( cin_isnt_good )
  4226.                 {
  4227.                         BadEntry err;
  4228.                         throw( err );
  4229.                 }
  4230.                 outFile << entry;
  4231.                 outFile << ' ';
  4232.         }
  4233.         if( j < number_of_entries )
  4234.         {
  4235.                 ++j;
  4236.                 ones_digit = j % 10;
  4237.                 cout << "Please input the ";
  4238.                 cout << j;
  4239.                 switch( ones_digit )
  4240.                 {
  4241.                 case 1:
  4242.                         ordinal = "st";
  4243.                         break;
  4244.                 case 2:
  4245.                         ordinal = "nd";
  4246.                         break;
  4247.                 case 3:
  4248.                         ordinal = "rd";
  4249.                         break;
  4250.                 case 4:
  4251.                         ordinal = "th";
  4252.                         break;
  4253.                 case 5:
  4254.                         ordinal = "th";
  4255.                         break;
  4256.                 case 6:
  4257.                         ordinal = "th";
  4258.                         break;
  4259.                 case 7:
  4260.                         ordinal = "th";
  4261.                         break;
  4262.                 case 8:
  4263.                         ordinal = "th";
  4264.                         break;
  4265.                 case 9:
  4266.                         ordinal = "th";
  4267.                         break;
  4268.                 case 0:
  4269.                         ordinal = "th";
  4270.                         break;
  4271.                 }
  4272.                 cout << ordinal;
  4273.                 cout << " number.";
  4274.                 cout << endl;
  4275.                 cout << ">> ";
  4276.                 cin  >> entry;
  4277.                 cin_is_good = cin.good();
  4278.                 cin_isnt_good = ! cin_is_good;
  4279.                 if( cin_isnt_good )
  4280.                 {
  4281.                         BadEntry err;
  4282.                         throw( err );
  4283.                 }
  4284.                 outFile << entry;
  4285.                 outFile << ' ';
  4286.         }
  4287.         if( j < number_of_entries )
  4288.         {
  4289.                 ++j;
  4290.                 ones_digit = j % 10;
  4291.                 cout << "Please input the ";
  4292.                 cout << j;
  4293.                 switch( ones_digit )
  4294.                 {
  4295.                 case 1:
  4296.                         ordinal = "st";
  4297.                         break;
  4298.                 case 2:
  4299.                         ordinal = "nd";
  4300.                         break;
  4301.                 case 3:
  4302.                         ordinal = "rd";
  4303.                         break;
  4304.                 case 4:
  4305.                         ordinal = "th";
  4306.                         break;
  4307.                 case 5:
  4308.                         ordinal = "th";
  4309.                         break;
  4310.                 case 6:
  4311.                         ordinal = "th";
  4312.                         break;
  4313.                 case 7:
  4314.                         ordinal = "th";
  4315.                         break;
  4316.                 case 8:
  4317.                         ordinal = "th";
  4318.                         break;
  4319.                 case 9:
  4320.                         ordinal = "th";
  4321.                         break;
  4322.                 case 0:
  4323.                         ordinal = "th";
  4324.                         break;
  4325.                 }
  4326.                 cout << ordinal;
  4327.                 cout << " number.";
  4328.                 cout << endl;
  4329.                 cout << ">> ";
  4330.                 cin  >> entry;
  4331.                 cin_is_good = cin.good();
  4332.                 cin_isnt_good = ! cin_is_good;
  4333.                 if( cin_isnt_good )
  4334.                 {
  4335.                         BadEntry err;
  4336.                         throw( err );
  4337.                 }
  4338.                 outFile << entry;
  4339.                 outFile << ' ';
  4340.         }
  4341.         if( j < number_of_entries )
  4342.         {
  4343.                 ++j;
  4344.                 ones_digit = j % 10;
  4345.                 cout << "Please input the ";
  4346.                 cout << j;
  4347.                 switch( ones_digit )
  4348.                 {
  4349.                 case 1:
  4350.                         ordinal = "st";
  4351.                         break;
  4352.                 case 2:
  4353.                         ordinal = "nd";
  4354.                         break;
  4355.                 case 3:
  4356.                         ordinal = "rd";
  4357.                         break;
  4358.                 case 4:
  4359.                         ordinal = "th";
  4360.                         break;
  4361.                 case 5:
  4362.                         ordinal = "th";
  4363.                         break;
  4364.                 case 6:
  4365.                         ordinal = "th";
  4366.                         break;
  4367.                 case 7:
  4368.                         ordinal = "th";
  4369.                         break;
  4370.                 case 8:
  4371.                         ordinal = "th";
  4372.                         break;
  4373.                 case 9:
  4374.                         ordinal = "th";
  4375.                         break;
  4376.                 case 0:
  4377.                         ordinal = "th";
  4378.                         break;
  4379.                 }
  4380.                 cout << ordinal;
  4381.                 cout << " number.";
  4382.                 cout << endl;
  4383.                 cout << ">> ";
  4384.                 cin  >> entry;
  4385.                 cin_is_good = cin.good();
  4386.                 cin_isnt_good = ! cin_is_good;
  4387.                 if( cin_isnt_good )
  4388.                 {
  4389.                         BadEntry err;
  4390.                         throw( err );
  4391.                 }
  4392.                 outFile << entry;
  4393.                 outFile << ' ';
  4394.         }
  4395.         if( j < number_of_entries )
  4396.         {
  4397.                 ++j;
  4398.                 ones_digit = j % 10;
  4399.                 cout << "Please input the ";
  4400.                 cout << j;
  4401.                 switch( ones_digit )
  4402.                 {
  4403.                 case 1:
  4404.                         ordinal = "st";
  4405.                         break;
  4406.                 case 2:
  4407.                         ordinal = "nd";
  4408.                         break;
  4409.                 case 3:
  4410.                         ordinal = "rd";
  4411.                         break;
  4412.                 case 4:
  4413.                         ordinal = "th";
  4414.                         break;
  4415.                 case 5:
  4416.                         ordinal = "th";
  4417.                         break;
  4418.                 case 6:
  4419.                         ordinal = "th";
  4420.                         break;
  4421.                 case 7:
  4422.                         ordinal = "th";
  4423.                         break;
  4424.                 case 8:
  4425.                         ordinal = "th";
  4426.                         break;
  4427.                 case 9:
  4428.                         ordinal = "th";
  4429.                         break;
  4430.                 case 0:
  4431.                         ordinal = "th";
  4432.                         break;
  4433.                 }
  4434.                 cout << ordinal;
  4435.                 cout << " number.";
  4436.                 cout << endl;
  4437.                 cout << ">> ";
  4438.                 cin  >> entry;
  4439.                 cin_is_good = cin.good();
  4440.                 cin_isnt_good = ! cin_is_good;
  4441.                 if( cin_isnt_good )
  4442.                 {
  4443.                         BadEntry err;
  4444.                         throw( err );
  4445.                 }
  4446.                 outFile << entry;
  4447.                 outFile << ' ';
  4448.         }
  4449.         if( j < number_of_entries )
  4450.         {
  4451.                 ++j;
  4452.                 ones_digit = j % 10;
  4453.                 cout << "Please input the ";
  4454.                 cout << j;
  4455.                 switch( ones_digit )
  4456.                 {
  4457.                 case 1:
  4458.                         ordinal = "st";
  4459.                         break;
  4460.                 case 2:
  4461.                         ordinal = "nd";
  4462.                         break;
  4463.                 case 3:
  4464.                         ordinal = "rd";
  4465.                         break;
  4466.                 case 4:
  4467.                         ordinal = "th";
  4468.                         break;
  4469.                 case 5:
  4470.                         ordinal = "th";
  4471.                         break;
  4472.                 case 6:
  4473.                         ordinal = "th";
  4474.                         break;
  4475.                 case 7:
  4476.                         ordinal = "th";
  4477.                         break;
  4478.                 case 8:
  4479.                         ordinal = "th";
  4480.                         break;
  4481.                 case 9:
  4482.                         ordinal = "th";
  4483.                         break;
  4484.                 case 0:
  4485.                         ordinal = "th";
  4486.                         break;
  4487.                 }
  4488.                 cout << ordinal;
  4489.                 cout << " number.";
  4490.                 cout << endl;
  4491.                 cout << ">> ";
  4492.                 cin  >> entry;
  4493.                 cin_is_good = cin.good();
  4494.                 cin_isnt_good = ! cin_is_good;
  4495.                 if( cin_isnt_good )
  4496.                 {
  4497.                         BadEntry err;
  4498.                         throw( err );
  4499.                 }
  4500.                 outFile << entry;
  4501.                 outFile << ' ';
  4502.         }
  4503.         if( j < number_of_entries )
  4504.         {
  4505.                 ++j;
  4506.                 ones_digit = j % 10;
  4507.                 cout << "Please input the ";
  4508.                 cout << j;
  4509.                 switch( ones_digit )
  4510.                 {
  4511.                 case 1:
  4512.                         ordinal = "st";
  4513.                         break;
  4514.                 case 2:
  4515.                         ordinal = "nd";
  4516.                         break;
  4517.                 case 3:
  4518.                         ordinal = "rd";
  4519.                         break;
  4520.                 case 4:
  4521.                         ordinal = "th";
  4522.                         break;
  4523.                 case 5:
  4524.                         ordinal = "th";
  4525.                         break;
  4526.                 case 6:
  4527.                         ordinal = "th";
  4528.                         break;
  4529.                 case 7:
  4530.                         ordinal = "th";
  4531.                         break;
  4532.                 case 8:
  4533.                         ordinal = "th";
  4534.                         break;
  4535.                 case 9:
  4536.                         ordinal = "th";
  4537.                         break;
  4538.                 case 0:
  4539.                         ordinal = "th";
  4540.                         break;
  4541.                 }
  4542.                 cout << ordinal;
  4543.                 cout << " number.";
  4544.                 cout << endl;
  4545.                 cout << ">> ";
  4546.                 cin  >> entry;
  4547.                 cin_is_good = cin.good();
  4548.                 cin_isnt_good = ! cin_is_good;
  4549.                 if( cin_isnt_good )
  4550.                 {
  4551.                         BadEntry err;
  4552.                         throw( err );
  4553.                 }
  4554.                 outFile << entry;
  4555.                 outFile << ' ';
  4556.         }
  4557.         if( j < number_of_entries )
  4558.         {
  4559.                 ++j;
  4560.                 ones_digit = j % 10;
  4561.                 cout << "Please input the ";
  4562.                 cout << j;
  4563.                 switch( ones_digit )
  4564.                 {
  4565.                 case 1:
  4566.                         ordinal = "st";
  4567.                         break;
  4568.                 case 2:
  4569.                         ordinal = "nd";
  4570.                         break;
  4571.                 case 3:
  4572.                         ordinal = "rd";
  4573.                         break;
  4574.                 case 4:
  4575.                         ordinal = "th";
  4576.                         break;
  4577.                 case 5:
  4578.                         ordinal = "th";
  4579.                         break;
  4580.                 case 6:
  4581.                         ordinal = "th";
  4582.                         break;
  4583.                 case 7:
  4584.                         ordinal = "th";
  4585.                         break;
  4586.                 case 8:
  4587.                         ordinal = "th";
  4588.                         break;
  4589.                 case 9:
  4590.                         ordinal = "th";
  4591.                         break;
  4592.                 case 0:
  4593.                         ordinal = "th";
  4594.                         break;
  4595.                 }
  4596.                 cout << ordinal;
  4597.                 cout << " number.";
  4598.                 cout << endl;
  4599.                 cout << ">> ";
  4600.                 cin  >> entry;
  4601.                 cin_is_good = cin.good();
  4602.                 cin_isnt_good = ! cin_is_good;
  4603.                 if( cin_isnt_good )
  4604.                 {
  4605.                         BadEntry err;
  4606.                         throw( err );
  4607.                 }
  4608.                 outFile << entry;
  4609.                 outFile << ' ';
  4610.         }
  4611.         if( j < number_of_entries )
  4612.         {
  4613.                 ++j;
  4614.                 ones_digit = j % 10;
  4615.                 cout << "Please input the ";
  4616.                 cout << j;
  4617.                 switch( ones_digit )
  4618.                 {
  4619.                 case 1:
  4620.                         ordinal = "st";
  4621.                         break;
  4622.                 case 2:
  4623.                         ordinal = "nd";
  4624.                         break;
  4625.                 case 3:
  4626.                         ordinal = "rd";
  4627.                         break;
  4628.                 case 4:
  4629.                         ordinal = "th";
  4630.                         break;
  4631.                 case 5:
  4632.                         ordinal = "th";
  4633.                         break;
  4634.                 case 6:
  4635.                         ordinal = "th";
  4636.                         break;
  4637.                 case 7:
  4638.                         ordinal = "th";
  4639.                         break;
  4640.                 case 8:
  4641.                         ordinal = "th";
  4642.                         break;
  4643.                 case 9:
  4644.                         ordinal = "th";
  4645.                         break;
  4646.                 case 0:
  4647.                         ordinal = "th";
  4648.                         break;
  4649.                 }
  4650.                 cout << ordinal;
  4651.                 cout << " number.";
  4652.                 cout << endl;
  4653.                 cout << ">> ";
  4654.                 cin  >> entry;
  4655.                 cin_is_good = cin.good();
  4656.                 cin_isnt_good = ! cin_is_good;
  4657.                 if( cin_isnt_good )
  4658.                 {
  4659.                         BadEntry err;
  4660.                         throw( err );
  4661.                 }
  4662.                 outFile << entry;
  4663.                 outFile << ' ';
  4664.         }
  4665.         if( j < number_of_entries )
  4666.         {
  4667.                 ++j;
  4668.                 ones_digit = j % 10;
  4669.                 cout << "Please input the ";
  4670.                 cout << j;
  4671.                 switch( ones_digit )
  4672.                 {
  4673.                 case 1:
  4674.                         ordinal = "st";
  4675.                         break;
  4676.                 case 2:
  4677.                         ordinal = "nd";
  4678.                         break;
  4679.                 case 3:
  4680.                         ordinal = "rd";
  4681.                         break;
  4682.                 case 4:
  4683.                         ordinal = "th";
  4684.                         break;
  4685.                 case 5:
  4686.                         ordinal = "th";
  4687.                         break;
  4688.                 case 6:
  4689.                         ordinal = "th";
  4690.                         break;
  4691.                 case 7:
  4692.                         ordinal = "th";
  4693.                         break;
  4694.                 case 8:
  4695.                         ordinal = "th";
  4696.                         break;
  4697.                 case 9:
  4698.                         ordinal = "th";
  4699.                         break;
  4700.                 case 0:
  4701.                         ordinal = "th";
  4702.                         break;
  4703.                 }
  4704.                 cout << ordinal;
  4705.                 cout << " number.";
  4706.                 cout << endl;
  4707.                 cout << ">> ";
  4708.                 cin  >> entry;
  4709.                 cin_is_good = cin.good();
  4710.                 cin_isnt_good = ! cin_is_good;
  4711.                 if( cin_isnt_good )
  4712.                 {
  4713.                         BadEntry err;
  4714.                         throw( err );
  4715.                 }
  4716.                 outFile << entry;
  4717.                 outFile << ' ';
  4718.         }
  4719.         if( j < number_of_entries )
  4720.         {
  4721.                 ++j;
  4722.                 ones_digit = j % 10;
  4723.                 cout << "Please input the ";
  4724.                 cout << j;
  4725.                 switch( ones_digit )
  4726.                 {
  4727.                 case 1:
  4728.                         ordinal = "st";
  4729.                         break;
  4730.                 case 2:
  4731.                         ordinal = "nd";
  4732.                         break;
  4733.                 case 3:
  4734.                         ordinal = "rd";
  4735.                         break;
  4736.                 case 4:
  4737.                         ordinal = "th";
  4738.                         break;
  4739.                 case 5:
  4740.                         ordinal = "th";
  4741.                         break;
  4742.                 case 6:
  4743.                         ordinal = "th";
  4744.                         break;
  4745.                 case 7:
  4746.                         ordinal = "th";
  4747.                         break;
  4748.                 case 8:
  4749.                         ordinal = "th";
  4750.                         break;
  4751.                 case 9:
  4752.                         ordinal = "th";
  4753.                         break;
  4754.                 case 0:
  4755.                         ordinal = "th";
  4756.                         break;
  4757.                 }
  4758.                 cout << ordinal;
  4759.                 cout << " number.";
  4760.                 cout << endl;
  4761.                 cout << ">> ";
  4762.                 cin  >> entry;
  4763.                 cin_is_good = cin.good();
  4764.                 cin_isnt_good = ! cin_is_good;
  4765.                 if( cin_isnt_good )
  4766.                 {
  4767.                         BadEntry err;
  4768.                         throw( err );
  4769.                 }
  4770.                 outFile << entry;
  4771.                 outFile << ' ';
  4772.         }
  4773.         if( j < number_of_entries )
  4774.         {
  4775.                 ++j;
  4776.                 ones_digit = j % 10;
  4777.                 cout << "Please input the ";
  4778.                 cout << j;
  4779.                 switch( ones_digit )
  4780.                 {
  4781.                 case 1:
  4782.                         ordinal = "st";
  4783.                         break;
  4784.                 case 2:
  4785.                         ordinal = "nd";
  4786.                         break;
  4787.                 case 3:
  4788.                         ordinal = "rd";
  4789.                         break;
  4790.                 case 4:
  4791.                         ordinal = "th";
  4792.                         break;
  4793.                 case 5:
  4794.                         ordinal = "th";
  4795.                         break;
  4796.                 case 6:
  4797.                         ordinal = "th";
  4798.                         break;
  4799.                 case 7:
  4800.                         ordinal = "th";
  4801.                         break;
  4802.                 case 8:
  4803.                         ordinal = "th";
  4804.                         break;
  4805.                 case 9:
  4806.                         ordinal = "th";
  4807.                         break;
  4808.                 case 0:
  4809.                         ordinal = "th";
  4810.                         break;
  4811.                 }
  4812.                 cout << ordinal;
  4813.                 cout << " number.";
  4814.                 cout << endl;
  4815.                 cout << ">> ";
  4816.                 cin  >> entry;
  4817.                 cin_is_good = cin.good();
  4818.                 cin_isnt_good = ! cin_is_good;
  4819.                 if( cin_isnt_good )
  4820.                 {
  4821.                         BadEntry err;
  4822.                         throw( err );
  4823.                 }
  4824.                 outFile << entry;
  4825.                 outFile << ' ';
  4826.         }
  4827.         if( j < number_of_entries )
  4828.         {
  4829.                 ++j;
  4830.                 ones_digit = j % 10;
  4831.                 cout << "Please input the ";
  4832.                 cout << j;
  4833.                 switch( ones_digit )
  4834.                 {
  4835.                 case 1:
  4836.                         ordinal = "st";
  4837.                         break;
  4838.                 case 2:
  4839.                         ordinal = "nd";
  4840.                         break;
  4841.                 case 3:
  4842.                         ordinal = "rd";
  4843.                         break;
  4844.                 case 4:
  4845.                         ordinal = "th";
  4846.                         break;
  4847.                 case 5:
  4848.                         ordinal = "th";
  4849.                         break;
  4850.                 case 6:
  4851.                         ordinal = "th";
  4852.                         break;
  4853.                 case 7:
  4854.                         ordinal = "th";
  4855.                         break;
  4856.                 case 8:
  4857.                         ordinal = "th";
  4858.                         break;
  4859.                 case 9:
  4860.                         ordinal = "th";
  4861.                         break;
  4862.                 case 0:
  4863.                         ordinal = "th";
  4864.                         break;
  4865.                 }
  4866.                 cout << ordinal;
  4867.                 cout << " number.";
  4868.                 cout << endl;
  4869.                 cout << ">> ";
  4870.                 cin  >> entry;
  4871.                 cin_is_good = cin.good();
  4872.                 cin_isnt_good = ! cin_is_good;
  4873.                 if( cin_isnt_good )
  4874.                 {
  4875.                         BadEntry err;
  4876.                         throw( err );
  4877.                 }
  4878.                 outFile << entry;
  4879.                 outFile << ' ';
  4880.         }
  4881.         if( j < number_of_entries )
  4882.         {
  4883.                 ++j;
  4884.                 ones_digit = j % 10;
  4885.                 cout << "Please input the ";
  4886.                 cout << j;
  4887.                 switch( ones_digit )
  4888.                 {
  4889.                 case 1:
  4890.                         ordinal = "st";
  4891.                         break;
  4892.                 case 2:
  4893.                         ordinal = "nd";
  4894.                         break;
  4895.                 case 3:
  4896.                         ordinal = "rd";
  4897.                         break;
  4898.                 case 4:
  4899.                         ordinal = "th";
  4900.                         break;
  4901.                 case 5:
  4902.                         ordinal = "th";
  4903.                         break;
  4904.                 case 6:
  4905.                         ordinal = "th";
  4906.                         break;
  4907.                 case 7:
  4908.                         ordinal = "th";
  4909.                         break;
  4910.                 case 8:
  4911.                         ordinal = "th";
  4912.                         break;
  4913.                 case 9:
  4914.                         ordinal = "th";
  4915.                         break;
  4916.                 case 0:
  4917.                         ordinal = "th";
  4918.                         break;
  4919.                 }
  4920.                 cout << ordinal;
  4921.                 cout << " number.";
  4922.                 cout << endl;
  4923.                 cout << ">> ";
  4924.                 cin  >> entry;
  4925.                 cin_is_good = cin.good();
  4926.                 cin_isnt_good = ! cin_is_good;
  4927.                 if( cin_isnt_good )
  4928.                 {
  4929.                         BadEntry err;
  4930.                         throw( err );
  4931.                 }
  4932.                 outFile << entry;
  4933.                 outFile << ' ';
  4934.         }
  4935.         if( j < number_of_entries )
  4936.         {
  4937.                 ++j;
  4938.                 ones_digit = j % 10;
  4939.                 cout << "Please input the ";
  4940.                 cout << j;
  4941.                 switch( ones_digit )
  4942.                 {
  4943.                 case 1:
  4944.                         ordinal = "st";
  4945.                         break;
  4946.                 case 2:
  4947.                         ordinal = "nd";
  4948.                         break;
  4949.                 case 3:
  4950.                         ordinal = "rd";
  4951.                         break;
  4952.                 case 4:
  4953.                         ordinal = "th";
  4954.                         break;
  4955.                 case 5:
  4956.                         ordinal = "th";
  4957.                         break;
  4958.                 case 6:
  4959.                         ordinal = "th";
  4960.                         break;
  4961.                 case 7:
  4962.                         ordinal = "th";
  4963.                         break;
  4964.                 case 8:
  4965.                         ordinal = "th";
  4966.                         break;
  4967.                 case 9:
  4968.                         ordinal = "th";
  4969.                         break;
  4970.                 case 0:
  4971.                         ordinal = "th";
  4972.                         break;
  4973.                 }
  4974.                 cout << ordinal;
  4975.                 cout << " number.";
  4976.                 cout << endl;
  4977.                 cout << ">> ";
  4978.                 cin  >> entry;
  4979.                 cin_is_good = cin.good();
  4980.                 cin_isnt_good = ! cin_is_good;
  4981.                 if( cin_isnt_good )
  4982.                 {
  4983.                         BadEntry err;
  4984.                         throw( err );
  4985.                 }
  4986.                 outFile << entry;
  4987.                 outFile << ' ';
  4988.         }
  4989.         if( j < number_of_entries )
  4990.         {
  4991.                 ++j;
  4992.                 ones_digit = j % 10;
  4993.                 cout << "Please input the ";
  4994.                 cout << j;
  4995.                 switch( ones_digit )
  4996.                 {
  4997.                 case 1:
  4998.                         ordinal = "st";
  4999.                         break;
  5000.                 case 2:
  5001.                         ordinal = "nd";
  5002.                         break;
  5003.                 case 3:
  5004.                         ordinal = "rd";
  5005.                         break;
  5006.                 case 4:
  5007.                         ordinal = "th";
  5008.                         break;
  5009.                 case 5:
  5010.                         ordinal = "th";
  5011.                         break;
  5012.                 case 6:
  5013.                         ordinal = "th";
  5014.                         break;
  5015.                 case 7:
  5016.                         ordinal = "th";
  5017.                         break;
  5018.                 case 8:
  5019.                         ordinal = "th";
  5020.                         break;
  5021.                 case 9:
  5022.                         ordinal = "th";
  5023.                         break;
  5024.                 case 0:
  5025.                         ordinal = "th";
  5026.                         break;
  5027.                 }
  5028.                 cout << ordinal;
  5029.                 cout << " number.";
  5030.                 cout << endl;
  5031.                 cout << ">> ";
  5032.                 cin  >> entry;
  5033.                 cin_is_good = cin.good();
  5034.                 cin_isnt_good = ! cin_is_good;
  5035.                 if( cin_isnt_good )
  5036.                 {
  5037.                         BadEntry err;
  5038.                         throw( err );
  5039.                 }
  5040.                 outFile << entry;
  5041.                 outFile << ' ';
  5042.         }
  5043.         if( j < number_of_entries )
  5044.         {
  5045.                 ++j;
  5046.                 ones_digit = j % 10;
  5047.                 cout << "Please input the ";
  5048.                 cout << j;
  5049.                 switch( ones_digit )
  5050.                 {
  5051.                 case 1:
  5052.                         ordinal = "st";
  5053.                         break;
  5054.                 case 2:
  5055.                         ordinal = "nd";
  5056.                         break;
  5057.                 case 3:
  5058.                         ordinal = "rd";
  5059.                         break;
  5060.                 case 4:
  5061.                         ordinal = "th";
  5062.                         break;
  5063.                 case 5:
  5064.                         ordinal = "th";
  5065.                         break;
  5066.                 case 6:
  5067.                         ordinal = "th";
  5068.                         break;
  5069.                 case 7:
  5070.                         ordinal = "th";
  5071.                         break;
  5072.                 case 8:
  5073.                         ordinal = "th";
  5074.                         break;
  5075.                 case 9:
  5076.                         ordinal = "th";
  5077.                         break;
  5078.                 case 0:
  5079.                         ordinal = "th";
  5080.                         break;
  5081.                 }
  5082.                 cout << ordinal;
  5083.                 cout << " number.";
  5084.                 cout << endl;
  5085.                 cout << ">> ";
  5086.                 cin  >> entry;
  5087.                 cin_is_good = cin.good();
  5088.                 cin_isnt_good = ! cin_is_good;
  5089.                 if( cin_isnt_good )
  5090.                 {
  5091.                         BadEntry err;
  5092.                         throw( err );
  5093.                 }
  5094.                 outFile << entry;
  5095.                 outFile << ' ';
  5096.         }
  5097.         if( j < number_of_entries )
  5098.         {
  5099.                 ++j;
  5100.                 ones_digit = j % 10;
  5101.                 cout << "Please input the ";
  5102.                 cout << j;
  5103.                 switch( ones_digit )
  5104.                 {
  5105.                 case 1:
  5106.                         ordinal = "st";
  5107.                         break;
  5108.                 case 2:
  5109.                         ordinal = "nd";
  5110.                         break;
  5111.                 case 3:
  5112.                         ordinal = "rd";
  5113.                         break;
  5114.                 case 4:
  5115.                         ordinal = "th";
  5116.                         break;
  5117.                 case 5:
  5118.                         ordinal = "th";
  5119.                         break;
  5120.                 case 6:
  5121.                         ordinal = "th";
  5122.                         break;
  5123.                 case 7:
  5124.                         ordinal = "th";
  5125.                         break;
  5126.                 case 8:
  5127.                         ordinal = "th";
  5128.                         break;
  5129.                 case 9:
  5130.                         ordinal = "th";
  5131.                         break;
  5132.                 case 0:
  5133.                         ordinal = "th";
  5134.                         break;
  5135.                 }
  5136.                 cout << ordinal;
  5137.                 cout << " number.";
  5138.                 cout << endl;
  5139.                 cout << ">> ";
  5140.                 cin  >> entry;
  5141.                 cin_is_good = cin.good();
  5142.                 cin_isnt_good = ! cin_is_good;
  5143.                 if( cin_isnt_good )
  5144.                 {
  5145.                         BadEntry err;
  5146.                         throw( err );
  5147.                 }
  5148.                 outFile << entry;
  5149.                 outFile << ' ';
  5150.         }
  5151.         if( j < number_of_entries )
  5152.         {
  5153.                 ++j;
  5154.                 ones_digit = j % 10;
  5155.                 cout << "Please input the ";
  5156.                 cout << j;
  5157.                 switch( ones_digit )
  5158.                 {
  5159.                 case 1:
  5160.                         ordinal = "st";
  5161.                         break;
  5162.                 case 2:
  5163.                         ordinal = "nd";
  5164.                         break;
  5165.                 case 3:
  5166.                         ordinal = "rd";
  5167.                         break;
  5168.                 case 4:
  5169.                         ordinal = "th";
  5170.                         break;
  5171.                 case 5:
  5172.                         ordinal = "th";
  5173.                         break;
  5174.                 case 6:
  5175.                         ordinal = "th";
  5176.                         break;
  5177.                 case 7:
  5178.                         ordinal = "th";
  5179.                         break;
  5180.                 case 8:
  5181.                         ordinal = "th";
  5182.                         break;
  5183.                 case 9:
  5184.                         ordinal = "th";
  5185.                         break;
  5186.                 case 0:
  5187.                         ordinal = "th";
  5188.                         break;
  5189.                 }
  5190.                 cout << ordinal;
  5191.                 cout << " number.";
  5192.                 cout << endl;
  5193.                 cout << ">> ";
  5194.                 cin  >> entry;
  5195.                 cin_is_good = cin.good();
  5196.                 cin_isnt_good = ! cin_is_good;
  5197.                 if( cin_isnt_good )
  5198.                 {
  5199.                         BadEntry err;
  5200.                         throw( err );
  5201.                 }
  5202.                 outFile << entry;
  5203.                 outFile << ' ';
  5204.         }
  5205.         if( j < number_of_entries )
  5206.         {
  5207.                 ++j;
  5208.                 ones_digit = j % 10;
  5209.                 cout << "Please input the ";
  5210.                 cout << j;
  5211.                 switch( ones_digit )
  5212.                 {
  5213.                 case 1:
  5214.                         ordinal = "st";
  5215.                         break;
  5216.                 case 2:
  5217.                         ordinal = "nd";
  5218.                         break;
  5219.                 case 3:
  5220.                         ordinal = "rd";
  5221.                         break;
  5222.                 case 4:
  5223.                         ordinal = "th";
  5224.                         break;
  5225.                 case 5:
  5226.                         ordinal = "th";
  5227.                         break;
  5228.                 case 6:
  5229.                         ordinal = "th";
  5230.                         break;
  5231.                 case 7:
  5232.                         ordinal = "th";
  5233.                         break;
  5234.                 case 8:
  5235.                         ordinal = "th";
  5236.                         break;
  5237.                 case 9:
  5238.                         ordinal = "th";
  5239.                         break;
  5240.                 case 0:
  5241.                         ordinal = "th";
  5242.                         break;
  5243.                 }
  5244.                 cout << ordinal;
  5245.                 cout << " number.";
  5246.                 cout << endl;
  5247.                 cout << ">> ";
  5248.                 cin  >> entry;
  5249.                 cin_is_good = cin.good();
  5250.                 cin_isnt_good = ! cin_is_good;
  5251.                 if( cin_isnt_good )
  5252.                 {
  5253.                         BadEntry err;
  5254.                         throw( err );
  5255.                 }
  5256.                 outFile << entry;
  5257.                 outFile << ' ';
  5258.         }
  5259.         if( j < number_of_entries )
  5260.         {
  5261.                 ++j;
  5262.                 ones_digit = j % 10;
  5263.                 cout << "Please input the ";
  5264.                 cout << j;
  5265.                 switch( ones_digit )
  5266.                 {
  5267.                 case 1:
  5268.                         ordinal = "st";
  5269.                         break;
  5270.                 case 2:
  5271.                         ordinal = "nd";
  5272.                         break;
  5273.                 case 3:
  5274.                         ordinal = "rd";
  5275.                         break;
  5276.                 case 4:
  5277.                         ordinal = "th";
  5278.                         break;
  5279.                 case 5:
  5280.                         ordinal = "th";
  5281.                         break;
  5282.                 case 6:
  5283.                         ordinal = "th";
  5284.                         break;
  5285.                 case 7:
  5286.                         ordinal = "th";
  5287.                         break;
  5288.                 case 8:
  5289.                         ordinal = "th";
  5290.                         break;
  5291.                 case 9:
  5292.                         ordinal = "th";
  5293.                         break;
  5294.                 case 0:
  5295.                         ordinal = "th";
  5296.                         break;
  5297.                 }
  5298.                 cout << ordinal;
  5299.                 cout << " number.";
  5300.                 cout << endl;
  5301.                 cout << ">> ";
  5302.                 cin  >> entry;
  5303.                 cin_is_good = cin.good();
  5304.                 cin_isnt_good = ! cin_is_good;
  5305.                 if( cin_isnt_good )
  5306.                 {
  5307.                         BadEntry err;
  5308.                         throw( err );
  5309.                 }
  5310.                 outFile << entry;
  5311.                 outFile << ' ';
  5312.         }
  5313.         if( j < number_of_entries )
  5314.         {
  5315.                 ++j;
  5316.                 ones_digit = j % 10;
  5317.                 cout << "Please input the ";
  5318.                 cout << j;
  5319.                 switch( ones_digit )
  5320.                 {
  5321.                 case 1:
  5322.                         ordinal = "st";
  5323.                         break;
  5324.                 case 2:
  5325.                         ordinal = "nd";
  5326.                         break;
  5327.                 case 3:
  5328.                         ordinal = "rd";
  5329.                         break;
  5330.                 case 4:
  5331.                         ordinal = "th";
  5332.                         break;
  5333.                 case 5:
  5334.                         ordinal = "th";
  5335.                         break;
  5336.                 case 6:
  5337.                         ordinal = "th";
  5338.                         break;
  5339.                 case 7:
  5340.                         ordinal = "th";
  5341.                         break;
  5342.                 case 8:
  5343.                         ordinal = "th";
  5344.                         break;
  5345.                 case 9:
  5346.                         ordinal = "th";
  5347.                         break;
  5348.                 case 0:
  5349.                         ordinal = "th";
  5350.                         break;
  5351.                 }
  5352.                 cout << ordinal;
  5353.                 cout << " number.";
  5354.                 cout << endl;
  5355.                 cout << ">> ";
  5356.                 cin  >> entry;
  5357.                 cin_is_good = cin.good();
  5358.                 cin_isnt_good = ! cin_is_good;
  5359.                 if( cin_isnt_good )
  5360.                 {
  5361.                         BadEntry err;
  5362.                         throw( err );
  5363.                 }
  5364.                 outFile << entry;
  5365.                 outFile << ' ';
  5366.         }
  5367.         if( j < number_of_entries )
  5368.         {
  5369.                 ++j;
  5370.                 ones_digit = j % 10;
  5371.                 cout << "Please input the ";
  5372.                 cout << j;
  5373.                 switch( ones_digit )
  5374.                 {
  5375.                 case 1:
  5376.                         ordinal = "st";
  5377.                         break;
  5378.                 case 2:
  5379.                         ordinal = "nd";
  5380.                         break;
  5381.                 case 3:
  5382.                         ordinal = "rd";
  5383.                         break;
  5384.                 case 4:
  5385.                         ordinal = "th";
  5386.                         break;
  5387.                 case 5:
  5388.                         ordinal = "th";
  5389.                         break;
  5390.                 case 6:
  5391.                         ordinal = "th";
  5392.                         break;
  5393.                 case 7:
  5394.                         ordinal = "th";
  5395.                         break;
  5396.                 case 8:
  5397.                         ordinal = "th";
  5398.                         break;
  5399.                 case 9:
  5400.                         ordinal = "th";
  5401.                         break;
  5402.                 case 0:
  5403.                         ordinal = "th";
  5404.                         break;
  5405.                 }
  5406.                 cout << ordinal;
  5407.                 cout << " number.";
  5408.                 cout << endl;
  5409.                 cout << ">> ";
  5410.                 cin  >> entry;
  5411.                 cin_is_good = cin.good();
  5412.                 cin_isnt_good = ! cin_is_good;
  5413.                 if( cin_isnt_good )
  5414.                 {
  5415.                         BadEntry err;
  5416.                         throw( err );
  5417.                 }
  5418.                 outFile << entry;
  5419.                 outFile << ' ';
  5420.         }
  5421.         if( j < number_of_entries )
  5422.         {
  5423.                 ++j;
  5424.                 ones_digit = j % 10;
  5425.                 cout << "Please input the ";
  5426.                 cout << j;
  5427.                 switch( ones_digit )
  5428.                 {
  5429.                 case 1:
  5430.                         ordinal = "st";
  5431.                         break;
  5432.                 case 2:
  5433.                         ordinal = "nd";
  5434.                         break;
  5435.                 case 3:
  5436.                         ordinal = "rd";
  5437.                         break;
  5438.                 case 4:
  5439.                         ordinal = "th";
  5440.                         break;
  5441.                 case 5:
  5442.                         ordinal = "th";
  5443.                         break;
  5444.                 case 6:
  5445.                         ordinal = "th";
  5446.                         break;
  5447.                 case 7:
  5448.                         ordinal = "th";
  5449.                         break;
  5450.                 case 8:
  5451.                         ordinal = "th";
  5452.                         break;
  5453.                 case 9:
  5454.                         ordinal = "th";
  5455.                         break;
  5456.                 case 0:
  5457.                         ordinal = "th";
  5458.                         break;
  5459.                 }
  5460.                 cout << ordinal;
  5461.                 cout << " number.";
  5462.                 cout << endl;
  5463.                 cout << ">> ";
  5464.                 cin  >> entry;
  5465.                 cin_is_good = cin.good();
  5466.                 cin_isnt_good = ! cin_is_good;
  5467.                 if( cin_isnt_good )
  5468.                 {
  5469.                         BadEntry err;
  5470.                         throw( err );
  5471.                 }
  5472.                 outFile << entry;
  5473.                 outFile << ' ';
  5474.         }
  5475.         if( j < number_of_entries )
  5476.         {
  5477.                 ++j;
  5478.                 ones_digit = j % 10;
  5479.                 cout << "Please input the ";
  5480.                 cout << j;
  5481.                 switch( ones_digit )
  5482.                 {
  5483.                 case 1:
  5484.                         ordinal = "st";
  5485.                         break;
  5486.                 case 2:
  5487.                         ordinal = "nd";
  5488.                         break;
  5489.                 case 3:
  5490.                         ordinal = "rd";
  5491.                         break;
  5492.                 case 4:
  5493.                         ordinal = "th";
  5494.                         break;
  5495.                 case 5:
  5496.                         ordinal = "th";
  5497.                         break;
  5498.                 case 6:
  5499.                         ordinal = "th";
  5500.                         break;
  5501.                 case 7:
  5502.                         ordinal = "th";
  5503.                         break;
  5504.                 case 8:
  5505.                         ordinal = "th";
  5506.                         break;
  5507.                 case 9:
  5508.                         ordinal = "th";
  5509.                         break;
  5510.                 case 0:
  5511.                         ordinal = "th";
  5512.                         break;
  5513.                 }
  5514.                 cout << ordinal;
  5515.                 cout << " number.";
  5516.                 cout << endl;
  5517.                 cout << ">> ";
  5518.                 cin  >> entry;
  5519.                 cin_is_good = cin.good();
  5520.                 cin_isnt_good = ! cin_is_good;
  5521.                 if( cin_isnt_good )
  5522.                 {
  5523.                         BadEntry err;
  5524.                         throw( err );
  5525.                 }
  5526.                 outFile << entry;
  5527.                 outFile << ' ';
  5528.         }
  5529.         if( j < number_of_entries )
  5530.         {
  5531.                 ++j;
  5532.                 ones_digit = j % 10;
  5533.                 cout << "Please input the ";
  5534.                 cout << j;
  5535.                 switch( ones_digit )
  5536.                 {
  5537.                 case 1:
  5538.                         ordinal = "st";
  5539.                         break;
  5540.                 case 2:
  5541.                         ordinal = "nd";
  5542.                         break;
  5543.                 case 3:
  5544.                         ordinal = "rd";
  5545.                         break;
  5546.                 case 4:
  5547.                         ordinal = "th";
  5548.                         break;
  5549.                 case 5:
  5550.                         ordinal = "th";
  5551.                         break;
  5552.                 case 6:
  5553.                         ordinal = "th";
  5554.                         break;
  5555.                 case 7:
  5556.                         ordinal = "th";
  5557.                         break;
  5558.                 case 8:
  5559.                         ordinal = "th";
  5560.                         break;
  5561.                 case 9:
  5562.                         ordinal = "th";
  5563.                         break;
  5564.                 case 0:
  5565.                         ordinal = "th";
  5566.                         break;
  5567.                 }
  5568.                 cout << ordinal;
  5569.                 cout << " number.";
  5570.                 cout << endl;
  5571.                 cout << ">> ";
  5572.                 cin  >> entry;
  5573.                 cin_is_good = cin.good();
  5574.                 cin_isnt_good = ! cin_is_good;
  5575.                 if( cin_isnt_good )
  5576.                 {
  5577.                         BadEntry err;
  5578.                         throw( err );
  5579.                 }
  5580.                 outFile << entry;
  5581.                 outFile << ' ';
  5582.         }
  5583.         if( j < number_of_entries )
  5584.         {
  5585.                 ++j;
  5586.                 ones_digit = j % 10;
  5587.                 cout << "Please input the ";
  5588.                 cout << j;
  5589.                 switch( ones_digit )
  5590.                 {
  5591.                 case 1:
  5592.                         ordinal = "st";
  5593.                         break;
  5594.                 case 2:
  5595.                         ordinal = "nd";
  5596.                         break;
  5597.                 case 3:
  5598.                         ordinal = "rd";
  5599.                         break;
  5600.                 case 4:
  5601.                         ordinal = "th";
  5602.                         break;
  5603.                 case 5:
  5604.                         ordinal = "th";
  5605.                         break;
  5606.                 case 6:
  5607.                         ordinal = "th";
  5608.                         break;
  5609.                 case 7:
  5610.                         ordinal = "th";
  5611.                         break;
  5612.                 case 8:
  5613.                         ordinal = "th";
  5614.                         break;
  5615.                 case 9:
  5616.                         ordinal = "th";
  5617.                         break;
  5618.                 case 0:
  5619.                         ordinal = "th";
  5620.                         break;
  5621.                 }
  5622.                 cout << ordinal;
  5623.                 cout << " number.";
  5624.                 cout << endl;
  5625.                 cout << ">> ";
  5626.                 cin  >> entry;
  5627.                 cin_is_good = cin.good();
  5628.                 cin_isnt_good = ! cin_is_good;
  5629.                 if( cin_isnt_good )
  5630.                 {
  5631.                         BadEntry err;
  5632.                         throw( err );
  5633.                 }
  5634.                 outFile << entry;
  5635.                 outFile << ' ';
  5636.         }
  5637.         if( j < number_of_entries )
  5638.         {
  5639.                 ++j;
  5640.                 ones_digit = j % 10;
  5641.                 cout << "Please input the ";
  5642.                 cout << j;
  5643.                 switch( ones_digit )
  5644.                 {
  5645.                 case 1:
  5646.                         ordinal = "st";
  5647.                         break;
  5648.                 case 2:
  5649.                         ordinal = "nd";
  5650.     &n