API tools faq
paste
Advertisement
Guest User

prog1B.cpp

a guest
Jan 21st, 2014
19,740
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 244.27 KB | None | 0 0
raw download clone embed print report
  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.             break;
  5651.         case 3:
  5652.             ordinal = "rd";
  5653.             break;
  5654.         case 4:
  5655.             ordinal = "th";
  5656.             break;
  5657.         case 5:
  5658.             ordinal = "th";
  5659.             break;
  5660.         case 6:
  5661.             ordinal = "th";
  5662.             break;
  5663.         case 7:
  5664.             ordinal = "th";
  5665.             break;
  5666.         case 8:
  5667.             ordinal = "th";
  5668.             break;
  5669.         case 9:
  5670.             ordinal = "th";
  5671.             break;
  5672.         case 0:
  5673.             ordinal = "th";
  5674.             break;
  5675.         }
  5676.         cout << ordinal;
  5677.         cout << " number.";
  5678.         cout << endl;
  5679.         cout << ">> ";
  5680.         cin  >> entry;
  5681.         cin_is_good = cin.good();
  5682.         cin_isnt_good = ! cin_is_good;
  5683.         if( cin_isnt_good )
  5684.         {
  5685.             BadEntry err;
  5686.             throw( err );
  5687.         }
  5688.         outFile << entry;
  5689.         outFile << ' ';
  5690.     }
  5691.     if( j < number_of_entries )
  5692.     {
  5693.         ++j;
  5694.         ones_digit = j % 10;
  5695.         cout << "Please input the ";
  5696.         cout << j;
  5697.         switch( ones_digit )
  5698.         {
  5699.         case 1:
  5700.             ordinal = "st";
  5701.             break;
  5702.         case 2:
  5703.             ordinal = "nd";
  5704.             break;
  5705.         case 3:
  5706.             ordinal = "rd";
  5707.             break;
  5708.         case 4:
  5709.             ordinal = "th";
  5710.             break;
  5711.         case 5:
  5712.             ordinal = "th";
  5713.             break;
  5714.         case 6:
  5715.             ordinal = "th";
  5716.             break;
  5717.         case 7:
  5718.             ordinal = "th";
  5719.             break;
  5720.         case 8:
  5721.             ordinal = "th";
  5722.             break;
  5723.         case 9:
  5724.             ordinal = "th";
  5725.             break;
  5726.         case 0:
  5727.             ordinal = "th";
  5728.             break;
  5729.         }
  5730.         cout << ordinal;
  5731.         cout << " number.";
  5732.         cout << endl;
  5733.         cout << ">> ";
  5734.         cin  >> entry;
  5735.         cin_is_good = cin.good();
  5736.         cin_isnt_good = ! cin_is_good;
  5737.         if( cin_isnt_good )
  5738.         {
  5739.             BadEntry err;
  5740.             throw( err );
  5741.         }
  5742.         outFile << entry;
  5743.         outFile << ' ';
  5744.     }
  5745.     if( j < number_of_entries )
  5746.     {
  5747.         ++j;
  5748.         ones_digit = j % 10;
  5749.         cout << "Please input the ";
  5750.         cout << j;
  5751.         switch( ones_digit )
  5752.         {
  5753.         case 1:
  5754.             ordinal = "st";
  5755.             break;
  5756.         case 2:
  5757.             ordinal = "nd";
  5758.             break;
  5759.         case 3:
  5760.             ordinal = "rd";
  5761.             break;
  5762.         case 4:
  5763.             ordinal = "th";
  5764.             break;
  5765.         case 5:
  5766.             ordinal = "th";
  5767.             break;
  5768.         case 6:
  5769.             ordinal = "th";
  5770.             break;
  5771.         case 7:
  5772.             ordinal = "th";
  5773.             break;
  5774.         case 8:
  5775.             ordinal = "th";
  5776.             break;
  5777.         case 9:
  5778.             ordinal = "th";
  5779.             break;
  5780.         case 0:
  5781.             ordinal = "th";
  5782.             break;
  5783.         }
  5784.         cout << ordinal;
  5785.         cout << " number.";
  5786.         cout << endl;
  5787.         cout << ">> ";
  5788.         cin  >> entry;
  5789.         cin_is_good = cin.good();
  5790.         cin_isnt_good = ! cin_is_good;
  5791.         if( cin_isnt_good )
  5792.         {
  5793.             BadEntry err;
  5794.             throw( err );
  5795.         }
  5796.         outFile << entry;
  5797.         outFile << ' ';
  5798.     }
  5799.     if( j < number_of_entries )
  5800.     {
  5801.         ++j;
  5802.         ones_digit = j % 10;
  5803.         cout << "Please input the ";
  5804.         cout << j;
  5805.         switch( ones_digit )
  5806.         {
  5807.         case 1:
  5808.             ordinal = "st";
  5809.             break;
  5810.         case 2:
  5811.             ordinal = "nd";
  5812.             break;
  5813.         case 3:
  5814.             ordinal = "rd";
  5815.             break;
  5816.         case 4:
  5817.             ordinal = "th";
  5818.             break;
  5819.         case 5:
  5820.             ordinal = "th";
  5821.             break;
  5822.         case 6:
  5823.             ordinal = "th";
  5824.             break;
  5825.         case 7:
  5826.             ordinal = "th";
  5827.             break;
  5828.         case 8:
  5829.             ordinal = "th";
  5830.             break;
  5831.         case 9:
  5832.             ordinal = "th";
  5833.             break;
  5834.         case 0:
  5835.             ordinal = "th";
  5836.             break;
  5837.         }
  5838.         cout << ordinal;
  5839.         cout << " number.";
  5840.         cout << endl;
  5841.         cout << ">> ";
  5842.         cin  >> entry;
  5843.         cin_is_good = cin.good();
  5844.         cin_isnt_good = ! cin_is_good;
  5845.         if( cin_isnt_good )
  5846.         {
  5847.             BadEntry err;
  5848.             throw( err );
  5849.         }
  5850.         outFile << entry;
  5851.         outFile << ' ';
  5852.     }
  5853.     if( j < number_of_entries )
  5854.     {
  5855.         ++j;
  5856.         ones_digit = j % 10;
  5857.         cout << "Please input the ";
  5858.         cout << j;
  5859.         switch( ones_digit )
  5860.         {
  5861.         case 1:
  5862.             ordinal = "st";
  5863.             break;
  5864.         case 2:
  5865.             ordinal = "nd";
  5866.             break;
  5867.         case 3:
  5868.             ordinal = "rd";
  5869.             break;
  5870.         case 4:
  5871.             ordinal = "th";
  5872.             break;
  5873.         case 5:
  5874.             ordinal = "th";
  5875.             break;
  5876.         case 6:
  5877.             ordinal = "th";
  5878.             break;
  5879.         case 7:
  5880.             ordinal = "th";
  5881.             break;
  5882.         case 8:
  5883.             ordinal = "th";
  5884.             break;
  5885.         case 9:
  5886.             ordinal = "th";
  5887.             break;
  5888.         case 0:
  5889.             ordinal = "th";
  5890.             break;
  5891.         }
  5892.         cout << ordinal;
  5893.         cout << " number.";
  5894.         cout << endl;
  5895.         cout << ">> ";
  5896.         cin  >> entry;
  5897.         cin_is_good = cin.good();
  5898.         cin_isnt_good = ! cin_is_good;
  5899.         if( cin_isnt_good )
  5900.         {
  5901.             BadEntry err;
  5902.             throw( err );
  5903.         }
  5904.         outFile << entry;
  5905.         outFile << ' ';
  5906.     }
  5907.     if( j < number_of_entries )
  5908.     {
  5909.         ++j;
  5910.         ones_digit = j % 10;
  5911.         cout << "Please input the ";
  5912.         cout << j;
  5913.         switch( ones_digit )
  5914.         {
  5915.         case 1:
  5916.             ordinal = "st";
  5917.             break;
  5918.         case 2:
  5919.             ordinal = "nd";
  5920.             break;
  5921.         case 3:
  5922.             ordinal = "rd";
  5923.             break;
  5924.         case 4:
  5925.             ordinal = "th";
  5926.             break;
  5927.         case 5:
  5928.             ordinal = "th";
  5929.             break;
  5930.         case 6:
  5931.             ordinal = "th";
  5932.             break;
  5933.         case 7:
  5934.             ordinal = "th";
  5935.             break;
  5936.         case 8:
  5937.             ordinal = "th";
  5938.             break;
  5939.         case 9:
  5940.             ordinal = "th";
  5941.             break;
  5942.         case 0:
  5943.             ordinal = "th";
  5944.             break;
  5945.         }
  5946.         cout << ordinal;
  5947.         cout << " number.";
  5948.         cout << endl;
  5949.         cout << ">> ";
  5950.         cin  >> entry;
  5951.         cin_is_good = cin.good();
  5952.         cin_isnt_good = ! cin_is_good;
  5953.         if( cin_isnt_good )
  5954.         {
  5955.             BadEntry err;
  5956.             throw( err );
  5957.         }
  5958.         outFile << entry;
  5959.         outFile << ' ';
  5960.     }
  5961.     if( j < number_of_entries )
  5962.     {
  5963.         ++j;
  5964.         ones_digit = j % 10;
  5965.         cout << "Please input the ";
  5966.         cout << j;
  5967.         switch( ones_digit )
  5968.         {
  5969.         case 1:
  5970.             ordinal = "st";
  5971.             break;
  5972.         case 2:
  5973.             ordinal = "nd";
  5974.             break;
  5975.         case 3:
  5976.             ordinal = "rd";
  5977.             break;
  5978.         case 4:
  5979.             ordinal = "th";
  5980.             break;
  5981.         case 5:
  5982.             ordinal = "th";
  5983.             break;
  5984.         case 6:
  5985.             ordinal = "th";
  5986.             break;
  5987.         case 7:
  5988.             ordinal = "th";
  5989.             break;
  5990.         case 8:
  5991.             ordinal = "th";
  5992.             break;
  5993.         case 9:
  5994.             ordinal = "th";
  5995.             break;
  5996.         case 0:
  5997.             ordinal = "th";
  5998.             break;
  5999.         }
  6000.         cout << ordinal;
  6001.         cout << " number.";
  6002.         cout << endl;
  6003.         cout << ">> ";
  6004.         cin  >> entry;
  6005.         cin_is_good = cin.good();
  6006.         cin_isnt_good = ! cin_is_good;
  6007.         if( cin_isnt_good )
  6008.         {
  6009.             BadEntry err;
  6010.             throw( err );
  6011.         }
  6012.         outFile << entry;
  6013.         outFile << ' ';
  6014.     }
  6015.     if( j < number_of_entries )
  6016.     {
  6017.         ++j;
  6018.         ones_digit = j % 10;
  6019.         cout << "Please input the ";
  6020.         cout << j;
  6021.         switch( ones_digit )
  6022.         {
  6023.         case 1:
  6024.             ordinal = "st";
  6025.             break;
  6026.         case 2:
  6027.             ordinal = "nd";
  6028.             break;
  6029.         case 3:
  6030.             ordinal = "rd";
  6031.             break;
  6032.         case 4:
  6033.             ordinal = "th";
  6034.             break;
  6035.         case 5:
  6036.             ordinal = "th";
  6037.             break;
  6038.         case 6:
  6039.             ordinal = "th";
  6040.             break;
  6041.         case 7:
  6042.             ordinal = "th";
  6043.             break;
  6044.         case 8:
  6045.             ordinal = "th";
  6046.             break;
  6047.         case 9:
  6048.             ordinal = "th";
  6049.             break;
  6050.         case 0:
  6051.             ordinal = "th";
  6052.             break;
  6053.         }
  6054.         cout << ordinal;
  6055.         cout << " number.";
  6056.         cout << endl;
  6057.         cout << ">> ";
  6058.         cin  >> entry;
  6059.         cin_is_good = cin.good();
  6060.         cin_isnt_good = ! cin_is_good;
  6061.         if( cin_isnt_good )
  6062.         {
  6063.             BadEntry err;
  6064.             throw( err );
  6065.         }
  6066.         outFile << entry;
  6067.         outFile << ' ';
  6068.     }
  6069.     if( j < number_of_entries )
  6070.     {
  6071.         ++j;
  6072.         ones_digit = j % 10;
  6073.         cout << "Please input the ";
  6074.         cout << j;
  6075.         switch( ones_digit )
  6076.         {
  6077.         case 1:
  6078.             ordinal = "st";
  6079.             break;
  6080.         case 2:
  6081.             ordinal = "nd";
  6082.             break;
  6083.         case 3:
  6084.             ordinal = "rd";
  6085.             break;
  6086.         case 4:
  6087.             ordinal = "th";
  6088.             break;
  6089.         case 5:
  6090.             ordinal = "th";
  6091.             break;
  6092.         case 6:
  6093.             ordinal = "th";
  6094.             break;
  6095.         case 7:
  6096.             ordinal = "th";
  6097.             break;
  6098.         case 8:
  6099.             ordinal = "th";
  6100.             break;
  6101.         case 9:
  6102.             ordinal = "th";
  6103.             break;
  6104.         case 0:
  6105.             ordinal = "th";
  6106.             break;
  6107.         }
  6108.         cout << ordinal;
  6109.         cout << " number.";
  6110.         cout << endl;
  6111.         cout << ">> ";
  6112.         cin  >> entry;
  6113.         cin_is_good = cin.good();
  6114.         cin_isnt_good = ! cin_is_good;
  6115.         if( cin_isnt_good )
  6116.         {
  6117.             BadEntry err;
  6118.             throw( err );
  6119.         }
  6120.         outFile << entry;
  6121.         outFile << ' ';
  6122.     }
  6123.     if( j < number_of_entries )
  6124.     {
  6125.         ++j;
  6126.         ones_digit = j % 10;
  6127.         cout << "Please input the ";
  6128.         cout << j;
  6129.         switch( ones_digit )
  6130.         {
  6131.         case 1:
  6132.             ordinal = "st";
  6133.             break;
  6134.         case 2:
  6135.             ordinal = "nd";
  6136.             break;
  6137.         case 3:
  6138.             ordinal = "rd";
  6139.             break;
  6140.         case 4:
  6141.             ordinal = "th";
  6142.             break;
  6143.         case 5:
  6144.             ordinal = "th";
  6145.             break;
  6146.         case 6:
  6147.             ordinal = "th";
  6148.             break;
  6149.         case 7:
  6150.             ordinal = "th";
  6151.             break;
  6152.         case 8:
  6153.             ordinal = "th";
  6154.             break;
  6155.         case 9:
  6156.             ordinal = "th";
  6157.             break;
  6158.         case 0:
  6159.             ordinal = "th";
  6160.             break;
  6161.         }
  6162.         cout << ordinal;
  6163.         cout << " number.";
  6164.         cout << endl;
  6165.         cout << ">> ";
  6166.         cin  >> entry;
  6167.         cin_is_good = cin.good();
  6168.         cin_isnt_good = ! cin_is_good;
  6169.         if( cin_isnt_good )
  6170.         {
  6171.             BadEntry err;
  6172.             throw( err );
  6173.         }
  6174.         outFile << entry;
  6175.         outFile << ' ';
  6176.     }
  6177.     if( j < number_of_entries )
  6178.     {
  6179.         ++j;
  6180.         ones_digit = j % 10;
  6181.         cout << "Please input the ";
  6182.         cout << j;
  6183.         switch( ones_digit )
  6184.         {
  6185.         case 1:
  6186.             ordinal = "st";
  6187.             break;
  6188.         case 2:
  6189.             ordinal = "nd";
  6190.             break;
  6191.         case 3:
  6192.             ordinal = "rd";
  6193.             break;
  6194.         case 4:
  6195.             ordinal = "th";
  6196.             break;
  6197.         case 5:
  6198.             ordinal = "th";
  6199.             break;
  6200.         case 6:
  6201.             ordinal = "th";
  6202.             break;
  6203.         case 7:
  6204.             ordinal = "th";
  6205.             break;
  6206.         case 8:
  6207.             ordinal = "th";
  6208.             break;
  6209.         case 9:
  6210.             ordinal = "th";
  6211.             break;
  6212.         case 0:
  6213.             ordinal = "th";
  6214.             break;
  6215.         }
  6216.         cout << ordinal;
  6217.         cout << " number.";
  6218.         cout << endl;
  6219.         cout << ">> ";
  6220.         cin  >> entry;
  6221.         cin_is_good = cin.good();
  6222.         cin_isnt_good = ! cin_is_good;
  6223.         if( cin_isnt_good )
  6224.         {
  6225.             BadEntry err;
  6226.             throw( err );
  6227.         }
  6228.         outFile << entry;
  6229.         outFile << ' ';
  6230.     }
  6231.     if( j < number_of_entries )
  6232.     {
  6233.         ++j;
  6234.         ones_digit = j % 10;
  6235.         cout << "Please input the ";
  6236.         cout << j;
  6237.         switch( ones_digit )
  6238.         {
  6239.         case 1:
  6240.             ordinal = "st";
  6241.             break;
  6242.         case 2:
  6243.             ordinal = "nd";
  6244.             break;
  6245.         case 3:
  6246.             ordinal = "rd";
  6247.             break;
  6248.         case 4:
  6249.             ordinal = "th";
  6250.             break;
  6251.         case 5:
  6252.             ordinal = "th";
  6253.             break;
  6254.         case 6:
  6255.             ordinal = "th";
  6256.             break;
  6257.         case 7:
  6258.             ordinal = "th";
  6259.             break;
  6260.         case 8:
  6261.             ordinal = "th";
  6262.             break;
  6263.         case 9:
  6264.             ordinal = "th";
  6265.             break;
  6266.         case 0:
  6267.             ordinal = "th";
  6268.             break;
  6269.         }
  6270.         cout << ordinal;
  6271.         cout << " number.";
  6272.         cout << endl;
  6273.         cout << ">> ";
  6274.         cin  >> entry;
  6275.         cin_is_good = cin.good();
  6276.         cin_isnt_good = ! cin_is_good;
  6277.         if( cin_isnt_good )
  6278.         {
  6279.             BadEntry err;
  6280.             throw( err );
  6281.         }
  6282.         outFile << entry;
  6283.         outFile << ' ';
  6284.     }
  6285.     if( j < number_of_entries )
  6286.     {
  6287.         ++j;
  6288.         ones_digit = j % 10;
  6289.         cout << "Please input the ";
  6290.         cout << j;
  6291.         switch( ones_digit )
  6292.         {
  6293.         case 1:
  6294.             ordinal = "st";
  6295.             break;
  6296.         case 2:
  6297.             ordinal = "nd";
  6298.             break;
  6299.         case 3:
  6300.             ordinal = "rd";
  6301.             break;
  6302.         case 4:
  6303.             ordinal = "th";
  6304.             break;
  6305.         case 5:
  6306.             ordinal = "th";
  6307.             break;
  6308.         case 6:
  6309.             ordinal = "th";
  6310.             break;
  6311.         case 7:
  6312.             ordinal = "th";
  6313.             break;
  6314.         case 8:
  6315.             ordinal = "th";
  6316.             break;
  6317.         case 9:
  6318.             ordinal = "th";
  6319.             break;
  6320.         case 0:
  6321.             ordinal = "th";
  6322.             break;
  6323.         }
  6324.         cout << ordinal;
  6325.         cout << " number.";
  6326.         cout << endl;
  6327.         cout << ">> ";
  6328.         cin  >> entry;
  6329.         cin_is_good = cin.good();
  6330.         cin_isnt_good = ! cin_is_good;
  6331.         if( cin_isnt_good )
  6332.         {
  6333.             BadEntry err;
  6334.             throw( err );
  6335.         }
  6336.         outFile << entry;
  6337.         outFile << ' ';
  6338.     }
  6339.     if( j < number_of_entries )
  6340.     {
  6341.         ++j;
  6342.         ones_digit = j % 10;
  6343.         cout << "Please input the ";
  6344.         cout << j;
  6345.         switch( ones_digit )
  6346.         {
  6347.         case 1:
  6348.             ordinal = "st";
  6349.             break;
  6350.         case 2:
  6351.             ordinal = "nd";
  6352.             break;
  6353.         case 3:
  6354.             ordinal = "rd";
  6355.             break;
  6356.         case 4:
  6357.             ordinal = "th";
  6358.             break;
  6359.         case 5:
  6360.             ordinal = "th";
  6361.             break;
  6362.         case 6:
  6363.             ordinal = "th";
  6364.             break;
  6365.         case 7:
  6366.             ordinal = "th";
  6367.             break;
  6368.         case 8:
  6369.             ordinal = "th";
  6370.             break;
  6371.         case 9:
  6372.             ordinal = "th";
  6373.             break;
  6374.         case 0:
  6375.             ordinal = "th";
  6376.             break;
  6377.         }
  6378.         cout << ordinal;
  6379.         cout << " number.";
  6380.         cout << endl;
  6381.         cout << ">> ";
  6382.         cin  >> entry;
  6383.         cin_is_good = cin.good();
  6384.         cin_isnt_good = ! cin_is_good;
  6385.         if( cin_isnt_good )
  6386.         {
  6387.             BadEntry err;
  6388.             throw( err );
  6389.         }
  6390.         outFile << entry;
  6391.         outFile << ' ';
  6392.     }
  6393.     if( j < number_of_entries )
  6394.     {
  6395.         ++j;
  6396.         ones_digit = j % 10;
  6397.         cout << "Please input the ";
  6398.         cout << j;
  6399.         switch( ones_digit )
  6400.         {
  6401.         case 1:
  6402.             ordinal = "st";
  6403.             break;
  6404.         case 2:
  6405.             ordinal = "nd";
  6406.             break;
  6407.         case 3:
  6408.             ordinal = "rd";
  6409.             break;
  6410.         case 4:
  6411.             ordinal = "th";
  6412.             break;
  6413.         case 5:
  6414.             ordinal = "th";
  6415.             break;
  6416.         case 6:
  6417.             ordinal = "th";
  6418.             break;
  6419.         case 7:
  6420.             ordinal = "th";
  6421.             break;
  6422.         case 8:
  6423.             ordinal = "th";
  6424.             break;
  6425.         case 9:
  6426.             ordinal = "th";
  6427.             break;
  6428.         case 0:
  6429.             ordinal = "th";
  6430.             break;
  6431.         }
  6432.         cout << ordinal;
  6433.         cout << " number.";
  6434.         cout << endl;
  6435.         cout << ">> ";
  6436.         cin  >> entry;
  6437.         cin_is_good = cin.good();
  6438.         cin_isnt_good = ! cin_is_good;
  6439.         if( cin_isnt_good )
  6440.         {
  6441.             BadEntry err;
  6442.             throw( err );
  6443.         }
  6444.         outFile << entry;
  6445.         outFile << ' ';
  6446.     }
  6447.     if( j < number_of_entries )
  6448.     {
  6449.         ++j;
  6450.         ones_digit = j % 10;
  6451.         cout << "Please input the ";
  6452.         cout << j;
  6453.         switch( ones_digit )
  6454.         {
  6455.         case 1:
  6456.             ordinal = "st";
  6457.             break;
  6458.         case 2:
  6459.             ordinal = "nd";
  6460.             break;
  6461.         case 3:
  6462.             ordinal = "rd";
  6463.             break;
  6464.         case 4:
  6465.             ordinal = "th";
  6466.             break;
  6467.         case 5:
  6468.             ordinal = "th";
  6469.             break;
  6470.         case 6:
  6471.             ordinal = "th";
  6472.             break;
  6473.         case 7:
  6474.             ordinal = "th";
  6475.             break;
  6476.         case 8:
  6477.             ordinal = "th";
  6478.             break;
  6479.         case 9:
  6480.             ordinal = "th";
  6481.             break;
  6482.         case 0:
  6483.             ordinal = "th";
  6484.             break;
  6485.         }
  6486.         cout << ordinal;
  6487.         cout << " number.";
  6488.         cout << endl;
  6489.         cout << ">> ";
  6490.         cin  >> entry;
  6491.         cin_is_good = cin.good();
  6492.         cin_isnt_good = ! cin_is_good;
  6493.         if( cin_isnt_good )
  6494.         {
  6495.             BadEntry err;
  6496.             throw( err );
  6497.         }
  6498.         outFile << entry;
  6499.         outFile << ' ';
  6500.     }
  6501.     if( j < number_of_entries )
  6502.     {
  6503.         ++j;
  6504.         ones_digit = j % 10;
  6505.         cout << "Please input the ";
  6506.         cout << j;
  6507.         switch( ones_digit )
  6508.         {
  6509.         case 1:
  6510.             ordinal = "st";
  6511.             break;
  6512.         case 2:
  6513.             ordinal = "nd";
  6514.             break;
  6515.         case 3:
  6516.             ordinal = "rd";
  6517.             break;
  6518.         case 4:
  6519.             ordinal = "th";
  6520.             break;
  6521.         case 5:
  6522.             ordinal = "th";
  6523.             break;
  6524.         case 6:
  6525.             ordinal = "th";
  6526.             break;
  6527.         case 7:
  6528.             ordinal = "th";
  6529.             break;
  6530.         case 8:
  6531.             ordinal = "th";
  6532.             break;
  6533.         case 9:
  6534.             ordinal = "th";
  6535.             break;
  6536.         case 0:
  6537.             ordinal = "th";
  6538.             break;
  6539.         }
  6540.         cout << ordinal;
  6541.         cout << " number.";
  6542.         cout << endl;
  6543.         cout << ">> ";
  6544.         cin  >> entry;
  6545.         cin_is_good = cin.good();
  6546.         cin_isnt_good = ! cin_is_good;
  6547.         if( cin_isnt_good )
  6548.         {
  6549.             BadEntry err;
  6550.             throw( err );
  6551.         }
  6552.         outFile << entry;
  6553.         outFile << ' ';
  6554.     }
  6555.     if( j < number_of_entries )
  6556.     {
  6557.         ++j;
  6558.         ones_digit = j % 10;
  6559.         cout << "Please input the ";
  6560.         cout << j;
  6561.         switch( ones_digit )
  6562.         {
  6563.         case 1:
  6564.             ordinal = "st";
  6565.             break;
  6566.         case 2:
  6567.             ordinal = "nd";
  6568.             break;
  6569.         case 3:
  6570.             ordinal = "rd";
  6571.             break;
  6572.         case 4:
  6573.             ordinal = "th";
  6574.             break;
  6575.         case 5:
  6576.             ordinal = "th";
  6577.             break;
  6578.         case 6:
  6579.             ordinal = "th";
  6580.             break;
  6581.         case 7:
  6582.             ordinal = "th";
  6583.             break;
  6584.         case 8:
  6585.             ordinal = "th";
  6586.             break;
  6587.         case 9:
  6588.             ordinal = "th";
  6589.             break;
  6590.         case 0:
  6591.             ordinal = "th";
  6592.             break;
  6593.         }
  6594.         cout << ordinal;
  6595.         cout << " number.";
  6596.         cout << endl;
  6597.         cout << ">> ";
  6598.         cin  >> entry;
  6599.         cin_is_good = cin.good();
  6600.         cin_isnt_good = ! cin_is_good;
  6601.         if( cin_isnt_good )
  6602.         {
  6603.             BadEntry err;
  6604.             throw( err );
  6605.         }
  6606.         outFile << entry;
  6607.         outFile << ' ';
  6608.     }
  6609.     if( j < number_of_entries )
  6610.     {
  6611.         ++j;
  6612.         ones_digit = j % 10;
  6613.         cout << "Please input the ";
  6614.         cout << j;
  6615.         switch( ones_digit )
  6616.         {
  6617.         case 1:
  6618.             ordinal = "st";
  6619.             break;
  6620.         case 2:
  6621.             ordinal = "nd";
  6622.             break;
  6623.         case 3:
  6624.             ordinal = "rd";
  6625.             break;
  6626.         case 4:
  6627.             ordinal = "th";
  6628.             break;
  6629.         case 5:
  6630.             ordinal = "th";
  6631.             break;
  6632.         case 6:
  6633.             ordinal = "th";
  6634.             break;
  6635.         case 7:
  6636.             ordinal = "th";
  6637.             break;
  6638.         case 8:
  6639.             ordinal = "th";
  6640.             break;
  6641.         case 9:
  6642.             ordinal = "th";
  6643.             break;
  6644.         case 0:
  6645.             ordinal = "th";
  6646.             break;
  6647.         }
  6648.         cout << ordinal;
  6649.         cout << " number.";
  6650.         cout << endl;
  6651.         cout << ">> ";
  6652.         cin  >> entry;
  6653.         cin_is_good = cin.good();
  6654.         cin_isnt_good = ! cin_is_good;
  6655.         if( cin_isnt_good )
  6656.         {
  6657.             BadEntry err;
  6658.             throw( err );
  6659.         }
  6660.         outFile << entry;
  6661.         outFile << ' ';
  6662.     }
  6663.     if( j < number_of_entries )
  6664.     {
  6665.         ++j;
  6666.         ones_digit = j % 10;
  6667.         cout << "Please input the ";
  6668.         cout << j;
  6669.         switch( ones_digit )
  6670.         {
  6671.         case 1:
  6672.             ordinal = "st";
  6673.             break;
  6674.         case 2:
  6675.             ordinal = "nd";
  6676.             break;
  6677.         case 3:
  6678.             ordinal = "rd";
  6679.             break;
  6680.         case 4:
  6681.             ordinal = "th";
  6682.             break;
  6683.         case 5:
  6684.             ordinal = "th";
  6685.             break;
  6686.         case 6:
  6687.             ordinal = "th";
  6688.             break;
  6689.         case 7:
  6690.             ordinal = "th";
  6691.             break;
  6692.         case 8:
  6693.             ordinal = "th";
  6694.             break;
  6695.         case 9:
  6696.             ordinal = "th";
  6697.             break;
  6698.         case 0:
  6699.             ordinal = "th";
  6700.             break;
  6701.         }
  6702.         cout << ordinal;
  6703.         cout << " number.";
  6704.         cout << endl;
  6705.         cout << ">> ";
  6706.         cin  >> entry;
  6707.         cin_is_good = cin.good();
  6708.         cin_isnt_good = ! cin_is_good;
  6709.         if( cin_isnt_good )
  6710.         {
  6711.             BadEntry err;
  6712.             throw( err );
  6713.         }
  6714.         outFile << entry;
  6715.         outFile << ' ';
  6716.     }
  6717.     if( j < number_of_entries )
  6718.     {
  6719.         ++j;
  6720.         ones_digit = j % 10;
  6721.         cout << "Please input the ";
  6722.         cout << j;
  6723.         switch( ones_digit )
  6724.         {
  6725.         case 1:
  6726.             ordinal = "st";
  6727.             break;
  6728.         case 2:
  6729.             ordinal = "nd";
  6730.             break;
  6731.         case 3:
  6732.             ordinal = "rd";
  6733.             break;
  6734.         case 4:
  6735.             ordinal = "th";
  6736.             break;
  6737.         case 5:
  6738.             ordinal = "th";
  6739.             break;
  6740.         case 6:
  6741.             ordinal = "th";
  6742.             break;
  6743.         case 7:
  6744.             ordinal = "th";
  6745.             break;
  6746.         case 8:
  6747.             ordinal = "th";
  6748.             break;
  6749.         case 9:
  6750.             ordinal = "th";
  6751.             break;
  6752.         case 0:
  6753.             ordinal = "th";
  6754.             break;
  6755.         }
  6756.         cout << ordinal;
  6757.         cout << " number.";
  6758.         cout << endl;
  6759.         cout << ">> ";
  6760.         cin  >> entry;
  6761.         cin_is_good = cin.good();
  6762.         cin_isnt_good = ! cin_is_good;
  6763.         if( cin_isnt_good )
  6764.         {
  6765.             BadEntry err;
  6766.             throw( err );
  6767.         }
  6768.         outFile << entry;
  6769.         outFile << ' ';
  6770.     }
  6771.     if( j < number_of_entries )
  6772.     {
  6773.         ++j;
  6774.         ones_digit = j % 10;
  6775.         cout << "Please input the ";
  6776.         cout << j;
  6777.         switch( ones_digit )
  6778.         {
  6779.         case 1:
  6780.             ordinal = "st";
  6781.             break;
  6782.         case 2:
  6783.             ordinal = "nd";
  6784.             break;
  6785.         case 3:
  6786.             ordinal = "rd";
  6787.             break;
  6788.         case 4:
  6789.             ordinal = "th";
  6790.             break;
  6791.         case 5:
  6792.             ordinal = "th";
  6793.             break;
  6794.         case 6:
  6795.             ordinal = "th";
  6796.             break;
  6797.         case 7:
  6798.             ordinal = "th";
  6799.             break;
  6800.         case 8:
  6801.             ordinal = "th";
  6802.             break;
  6803.         case 9:
  6804.             ordinal = "th";
  6805.             break;
  6806.         case 0:
  6807.             ordinal = "th";
  6808.             break;
  6809.         }
  6810.         cout << ordinal;
  6811.         cout << " number.";
  6812.         cout << endl;
  6813.         cout << ">> ";
  6814.         cin  >> entry;
  6815.         cin_is_good = cin.good();
  6816.         cin_isnt_good = ! cin_is_good;
  6817.         if( cin_isnt_good )
  6818.         {
  6819.             BadEntry err;
  6820.             throw( err );
  6821.         }
  6822.         outFile << entry;
  6823.         outFile << ' ';
  6824.     }
  6825.     if( j < number_of_entries )
  6826.     {
  6827.         ++j;
  6828.         ones_digit = j % 10;
  6829.         cout << "Please input the ";
  6830.         cout << j;
  6831.         switch( ones_digit )
  6832.         {
  6833.         case 1:
  6834.             ordinal = "st";
  6835.             break;
  6836.         case 2:
  6837.             ordinal = "nd";
  6838.             break;
  6839.         case 3:
  6840.             ordinal = "rd";
  6841.             break;
  6842.         case 4:
  6843.             ordinal = "th";
  6844.             break;
  6845.         case 5:
  6846.             ordinal = "th";
  6847.             break;
  6848.         case 6:
  6849.             ordinal = "th";
  6850.             break;
  6851.         case 7:
  6852.             ordinal = "th";
  6853.             break;
  6854.         case 8:
  6855.             ordinal = "th";
  6856.             break;
  6857.         case 9:
  6858.             ordinal = "th";
  6859.             break;
  6860.         case 0:
  6861.             ordinal = "th";
  6862.             break;
  6863.         }
  6864.         cout << ordinal;
  6865.         cout << " number.";
  6866.         cout << endl;
  6867.         cout << ">> ";
  6868.         cin  >> entry;
  6869.         cin_is_good = cin.good();
  6870.         cin_isnt_good = ! cin_is_good;
  6871.         if( cin_isnt_good )
  6872.         {
  6873.             BadEntry err;
  6874.             throw( err );
  6875.         }
  6876.         outFile << entry;
  6877.         outFile << ' ';
  6878.     }
  6879.     if( j < number_of_entries )
  6880.     {
  6881.         ++j;
  6882.         ones_digit = j % 10;
  6883.         cout << "Please input the ";
  6884.         cout << j;
  6885.         switch( ones_digit )
  6886.         {
  6887.         case 1:
  6888.             ordinal = "st";
  6889.             break;
  6890.         case 2:
  6891.             ordinal = "nd";
  6892.             break;
  6893.         case 3:
  6894.             ordinal = "rd";
  6895.             break;
  6896.         case 4:
  6897.             ordinal = "th";
  6898.             break;
  6899.         case 5:
  6900.             ordinal = "th";
  6901.             break;
  6902.         case 6:
  6903.             ordinal = "th";
  6904.             break;
  6905.         case 7:
  6906.             ordinal = "th";
  6907.             break;
  6908.         case 8:
  6909.             ordinal = "th";
  6910.             break;
  6911.         case 9:
  6912.             ordinal = "th";
  6913.             break;
  6914.         case 0:
  6915.             ordinal = "th";
  6916.             break;
  6917.         }
  6918.         cout << ordinal;
  6919.         cout << " number.";
  6920.         cout << endl;
  6921.         cout << ">> ";
  6922.         cin  >> entry;
  6923.         cin_is_good = cin.good();
  6924.         cin_isnt_good = ! cin_is_good;
  6925.         if( cin_isnt_good )
  6926.         {
  6927.             BadEntry err;
  6928.             throw( err );
  6929.         }
  6930.         outFile << entry;
  6931.         outFile << ' ';
  6932.     }
  6933.     if( j < number_of_entries )
  6934.     {
  6935.         ++j;
  6936.         ones_digit = j % 10;
  6937.         cout << "Please input the ";
  6938.         cout << j;
  6939.         switch( ones_digit )
  6940.         {
  6941.         case 1:
  6942.             ordinal = "st";
  6943.             break;
  6944.         case 2:
  6945.             ordinal = "nd";
  6946.             break;
  6947.         case 3:
  6948.             ordinal = "rd";
  6949.             break;
  6950.         case 4:
  6951.             ordinal = "th";
  6952.             break;
  6953.         case 5:
  6954.             ordinal = "th";
  6955.             break;
  6956.         case 6:
  6957.             ordinal = "th";
  6958.             break;
  6959.         case 7:
  6960.             ordinal = "th";
  6961.             break;
  6962.         case 8:
  6963.             ordinal = "th";
  6964.             break;
  6965.         case 9:
  6966.             ordinal = "th";
  6967.             break;
  6968.         case 0:
  6969.             ordinal = "th";
  6970.             break;
  6971.         }
  6972.         cout << ordinal;
  6973.         cout << " number.";
  6974.         cout << endl;
  6975.         cout << ">> ";
  6976.         cin  >> entry;
  6977.         cin_is_good = cin.good();
  6978.         cin_isnt_good = ! cin_is_good;
  6979.         if( cin_isnt_good )
  6980.         {
  6981.             BadEntry err;
  6982.             throw( err );
  6983.         }
  6984.         outFile << entry;
  6985.         outFile << ' ';
  6986.     }
  6987.     if( j < number_of_entries )
  6988.     {
  6989.         ++j;
  6990.         ones_digit = j % 10;
  6991.         cout << "Please input the ";
  6992.         cout << j;
  6993.         switch( ones_digit )
  6994.         {
  6995.         case 1:
  6996.             ordinal = "st";
  6997.             break;
  6998.         case 2:
  6999.             ordinal = "nd";
  7000.             break;
  7001.         case 3:
  7002.             ordinal = "rd";
  7003.             break;
  7004.         case 4:
  7005.             ordinal = "th";
  7006.             break;
  7007.         case 5:
  7008.             ordinal = "th";
  7009.             break;
  7010.         case 6:
  7011.             ordinal = "th";
  7012.             break;
  7013.         case 7:
  7014.             ordinal = "th";
  7015.             break;
  7016.         case 8:
  7017.             ordinal = "th";
  7018.             break;
  7019.         case 9:
  7020.             ordinal = "th";
  7021.             break;
  7022.         case 0:
  7023.             ordinal = "th";
  7024.             break;
  7025.         }
  7026.         cout << ordinal;
  7027.         cout << " number.";
  7028.         cout << endl;
  7029.         cout << ">> ";
  7030.         cin  >> entry;
  7031.         cin_is_good = cin.good();
  7032.         cin_isnt_good = ! cin_is_good;
  7033.         if( cin_isnt_good )
  7034.         {
  7035.             BadEntry err;
  7036.             throw( err );
  7037.         }
  7038.         outFile << entry;
  7039.         outFile << ' ';
  7040.     }
  7041.     if( j < number_of_entries )
  7042.     {
  7043.         ++j;
  7044.         ones_digit = j % 10;
  7045.         cout << "Please input the ";
  7046.         cout << j;
  7047.         switch( ones_digit )
  7048.         {
  7049.         case 1:
  7050.             ordinal = "st";
  7051.             break;
  7052.         case 2:
  7053.             ordinal = "nd";
  7054.             break;
  7055.         case 3:
  7056.             ordinal = "rd";
  7057.             break;
  7058.         case 4:
  7059.             ordinal = "th";
  7060.             break;
  7061.         case 5:
  7062.             ordinal = "th";
  7063.             break;
  7064.         case 6:
  7065.             ordinal = "th";
  7066.             break;
  7067.         case 7:
  7068.             ordinal = "th";
  7069.             break;
  7070.         case 8:
  7071.             ordinal = "th";
  7072.             break;
  7073.         case 9:
  7074.             ordinal = "th";
  7075.             break;
  7076.         case 0:
  7077.             ordinal = "th";
  7078.             break;
  7079.         }
  7080.         cout << ordinal;
  7081.         cout << " number.";
  7082.         cout << endl;
  7083.         cout << ">> ";
  7084.         cin  >> entry;
  7085.         cin_is_good = cin.good();
  7086.         cin_isnt_good = ! cin_is_good;
  7087.         if( cin_isnt_good )
  7088.         {
  7089.             BadEntry err;
  7090.             throw( err );
  7091.         }
  7092.         outFile << entry;
  7093.         outFile << ' ';
  7094.     }
  7095.     if( j < number_of_entries )
  7096.     {
  7097.         ++j;
  7098.         ones_digit = j % 10;
  7099.         cout << "Please input the ";
  7100.         cout << j;
  7101.         switch( ones_digit )
  7102.         {
  7103.         case 1:
  7104.             ordinal = "st";
  7105.             break;
  7106.         case 2:
  7107.             ordinal = "nd";
  7108.             break;
  7109.         case 3:
  7110.             ordinal = "rd";
  7111.             break;
  7112.         case 4:
  7113.             ordinal = "th";
  7114.             break;
  7115.         case 5:
  7116.             ordinal = "th";
  7117.             break;
  7118.         case 6:
  7119.             ordinal = "th";
  7120.             break;
  7121.         case 7:
  7122.             ordinal = "th";
  7123.             break;
  7124.         case 8:
  7125.             ordinal = "th";
  7126.             break;
  7127.         case 9:
  7128.             ordinal = "th";
  7129.             break;
  7130.         case 0:
  7131.             ordinal = "th";
  7132.             break;
  7133.         }
  7134.         cout << ordinal;
  7135.         cout << " number.";
  7136.         cout << endl;
  7137.         cout << ">> ";
  7138.         cin  >> entry;
  7139.         cin_is_good = cin.good();
  7140.         cin_isnt_good = ! cin_is_good;
  7141.         if( cin_isnt_good )
  7142.         {
  7143.             BadEntry err;
  7144.             throw( err );
  7145.         }
  7146.         outFile << entry;
  7147.         outFile << ' ';
  7148.     }
  7149.     if( j < number_of_entries )
  7150.     {
  7151.         ++j;
  7152.         ones_digit = j % 10;
  7153.         cout << "Please input the ";
  7154.         cout << j;
  7155.         switch( ones_digit )
  7156.         {
  7157.         case 1:
  7158.             ordinal = "st";
  7159.             break;
  7160.         case 2:
  7161.             ordinal = "nd";
  7162.             break;
  7163.         case 3:
  7164.             ordinal = "rd";
  7165.             break;
  7166.         case 4:
  7167.             ordinal = "th";
  7168.             break;
  7169.         case 5:
  7170.             ordinal = "th";
  7171.             break;
  7172.         case 6:
  7173.             ordinal = "th";
  7174.             break;
  7175.         case 7:
  7176.             ordinal = "th";
  7177.             break;
  7178.         case 8:
  7179.             ordinal = "th";
  7180.             break;
  7181.         case 9:
  7182.             ordinal = "th";
  7183.             break;
  7184.         case 0:
  7185.             ordinal = "th";
  7186.             break;
  7187.         }
  7188.         cout << ordinal;
  7189.         cout << " number.";
  7190.         cout << endl;
  7191.         cout << ">> ";
  7192.         cin  >> entry;
  7193.         cin_is_good = cin.good();
  7194.         cin_isnt_good = ! cin_is_good;
  7195.         if( cin_isnt_good )
  7196.         {
  7197.             BadEntry err;
  7198.             throw( err );
  7199.         }
  7200.         outFile << entry;
  7201.         outFile << ' ';
  7202.     }
  7203.     if( j < number_of_entries )
  7204.     {
  7205.         ++j;
  7206.         ones_digit = j % 10;
  7207.         cout << "Please input the ";
  7208.         cout << j;
  7209.         switch( ones_digit )
  7210.         {
  7211.         case 1:
  7212.             ordinal = "st";
  7213.             break;
  7214.         case 2:
  7215.             ordinal = "nd";
  7216.             break;
  7217.         case 3:
  7218.             ordinal = "rd";
  7219.             break;
  7220.         case 4:
  7221.             ordinal = "th";
  7222.             break;
  7223.         case 5:
  7224.             ordinal = "th";
  7225.             break;
  7226.         case 6:
  7227.             ordinal = "th";
  7228.             break;
  7229.         case 7:
  7230.             ordinal = "th";
  7231.             break;
  7232.         case 8:
  7233.             ordinal = "th";
  7234.             break;
  7235.         case 9:
  7236.             ordinal = "th";
  7237.             break;
  7238.         case 0:
  7239.             ordinal = "th";
  7240.             break;
  7241.         }
  7242.         cout << ordinal;
  7243.         cout << " number.";
  7244.         cout << endl;
  7245.         cout << ">> ";
  7246.         cin  >> entry;
  7247.         cin_is_good = cin.good();
  7248.         cin_isnt_good = ! cin_is_good;
  7249.         if( cin_isnt_good )
  7250.         {
  7251.             BadEntry err;
  7252.             throw( err );
  7253.         }
  7254.         outFile << entry;
  7255.         outFile << ' ';
  7256.     }
  7257.     if( j < number_of_entries )
  7258.     {
  7259.         ++j;
  7260.         ones_digit = j % 10;
  7261.         cout << "Please input the ";
  7262.         cout << j;
  7263.         switch( ones_digit )
  7264.         {
  7265.         case 1:
  7266.             ordinal = "st";
  7267.             break;
  7268.         case 2:
  7269.             ordinal = "nd";
  7270.             break;
  7271.         case 3:
  7272.             ordinal = "rd";
  7273.             break;
  7274.         case 4:
  7275.             ordinal = "th";
  7276.             break;
  7277.         case 5:
  7278.             ordinal = "th";
  7279.             break;
  7280.         case 6:
  7281.             ordinal = "th";
  7282.             break;
  7283.         case 7:
  7284.             ordinal = "th";
  7285.             break;
  7286.         case 8:
  7287.             ordinal = "th";
  7288.             break;
  7289.         case 9:
  7290.             ordinal = "th";
  7291.             break;
  7292.         case 0:
  7293.             ordinal = "th";
  7294.             break;
  7295.         }
  7296.         cout << ordinal;
  7297.         cout << " number.";
  7298.         cout << endl;
  7299.         cout << ">> ";
  7300.         cin  >> entry;
  7301.         cin_is_good = cin.good();
  7302.         cin_isnt_good = ! cin_is_good;
  7303.         if( cin_isnt_good )
  7304.         {
  7305.             BadEntry err;
  7306.             throw( err );
  7307.         }
  7308.         outFile << entry;
  7309.         outFile << ' ';
  7310.     }
  7311.     if( j < number_of_entries )
  7312.     {
  7313.         ++j;
  7314.         ones_digit = j % 10;
  7315.         cout << "Please input the ";
  7316.         cout << j;
  7317.         switch( ones_digit )
  7318.         {
  7319.         case 1:
  7320.             ordinal = "st";
  7321.             break;
  7322.         case 2:
  7323.             ordinal = "nd";
  7324.             break;
  7325.         case 3:
  7326.             ordinal = "rd";
  7327.             break;
  7328.         case 4:
  7329.             ordinal = "th";
  7330.             break;
  7331.         case 5:
  7332.             ordinal = "th";
  7333.             break;
  7334.         case 6:
  7335.             ordinal = "th";
  7336.             break;
  7337.         case 7:
  7338.             ordinal = "th";
  7339.             break;
  7340.         case 8:
  7341.             ordinal = "th";
  7342.             break;
  7343.         case 9:
  7344.             ordinal = "th";
  7345.             break;
  7346.         case 0:
  7347.             ordinal = "th";
  7348.             break;
  7349.         }
  7350.         cout << ordinal;
  7351.         cout << " number.";
  7352.         cout << endl;
  7353.         cout << ">> ";
  7354.         cin  >> entry;
  7355.         cin_is_good = cin.good();
  7356.         cin_isnt_good = ! cin_is_good;
  7357.         if( cin_isnt_good )
  7358.         {
  7359.             BadEntry err;
  7360.             throw( err );
  7361.         }
  7362.         outFile << entry;
  7363.         outFile << ' ';
  7364.     }
  7365.     if( j < number_of_entries )
  7366.     {
  7367.         ++j;
  7368.         ones_digit = j % 10;
  7369.         cout << "Please input the ";
  7370.         cout << j;
  7371.         switch( ones_digit )
  7372.         {
  7373.         case 1:
  7374.             ordinal = "st";
  7375.             break;
  7376.         case 2:
  7377.             ordinal = "nd";
  7378.             break;
  7379.         case 3:
  7380.             ordinal = "rd";
  7381.             break;
  7382.         case 4:
  7383.             ordinal = "th";
  7384.             break;
  7385.         case 5:
  7386.             ordinal = "th";
  7387.             break;
  7388.         case 6:
  7389.             ordinal = "th";
  7390.             break;
  7391.         case 7:
  7392.             ordinal = "th";
  7393.             break;
  7394.         case 8:
  7395.             ordinal = "th";
  7396.             break;
  7397.         case 9:
  7398.             ordinal = "th";
  7399.             break;
  7400.         case 0:
  7401.             ordinal = "th";
  7402.             break;
  7403.         }
  7404.         cout << ordinal;
  7405.         cout << " number.";
  7406.         cout << endl;
  7407.         cout << ">> ";
  7408.         cin  >> entry;
  7409.         cin_is_good = cin.good();
  7410.         cin_isnt_good = ! cin_is_good;
  7411.         if( cin_isnt_good )
  7412.         {
  7413.             BadEntry err;
  7414.             throw( err );
  7415.         }
  7416.         outFile << entry;
  7417.         outFile << ' ';
  7418.     }
  7419.     if( j < number_of_entries )
  7420.     {
  7421.         ++j;
  7422.         ones_digit = j % 10;
  7423.         cout << "Please input the ";
  7424.         cout << j;
  7425.         switch( ones_digit )
  7426.         {
  7427.         case 1:
  7428.             ordinal = "st";
  7429.             break;
  7430.         case 2:
  7431.             ordinal = "nd";
  7432.             break;
  7433.         case 3:
  7434.             ordinal = "rd";
  7435.             break;
  7436.         case 4:
  7437.             ordinal = "th";
  7438.             break;
  7439.         case 5:
  7440.             ordinal = "th";
  7441.             break;
  7442.         case 6:
  7443.             ordinal = "th";
  7444.             break;
  7445.         case 7:
  7446.             ordinal = "th";
  7447.             break;
  7448.         case 8:
  7449.             ordinal = "th";
  7450.             break;
  7451.         case 9:
  7452.             ordinal = "th";
  7453.             break;
  7454.         case 0:
  7455.             ordinal = "th";
  7456.             break;
  7457.         }
  7458.         cout << ordinal;
  7459.         cout << " number.";
  7460.         cout << endl;
  7461.         cout << ">> ";
  7462.         cin  >> entry;
  7463.         cin_is_good = cin.good();
  7464.         cin_isnt_good = ! cin_is_good;
  7465.         if( cin_isnt_good )
  7466.         {
  7467.             BadEntry err;
  7468.             throw( err );
  7469.         }
  7470.         outFile << entry;
  7471.         outFile << ' ';
  7472.     }
  7473.     if( j < number_of_entries )
  7474.     {
  7475.         ++j;
  7476.         ones_digit = j % 10;
  7477.         cout << "Please input the ";
  7478.         cout << j;
  7479.         switch( ones_digit )
  7480.         {
  7481.         case 1:
  7482.             ordinal = "st";
  7483.             break;
  7484.         case 2:
  7485.             ordinal = "nd";
  7486.             break;
  7487.         case 3:
  7488.             ordinal = "rd";
  7489.             break;
  7490.         case 4:
  7491.             ordinal = "th";
  7492.             break;
  7493.         case 5:
  7494.             ordinal = "th";
  7495.             break;
  7496.         case 6:
  7497.             ordinal = "th";
  7498.             break;
  7499.         case 7:
  7500.             ordinal = "th";
  7501.             break;
  7502.         case 8:
  7503.             ordinal = "th";
  7504.             break;
  7505.         case 9:
  7506.             ordinal = "th";
  7507.             break;
  7508.         case 0:
  7509.             ordinal = "th";
  7510.             break;
  7511.         }
  7512.         cout << ordinal;
  7513.         cout << " number.";
  7514.         cout << endl;
  7515.         cout << ">> ";
  7516.         cin  >> entry;
  7517.         cin_is_good = cin.good();
  7518.         cin_isnt_good = ! cin_is_good;
  7519.         if( cin_isnt_good )
  7520.         {
  7521.             BadEntry err;
  7522.             throw( err );
  7523.         }
  7524.         outFile << entry;
  7525.         outFile << ' ';
  7526.     }
  7527.     if( j < number_of_entries )
  7528.     {
  7529.         ++j;
  7530.         ones_digit = j % 10;
  7531.         cout << "Please input the ";
  7532.         cout << j;
  7533.         switch( ones_digit )
  7534.         {
  7535.         case 1:
  7536.             ordinal = "st";
  7537.             break;
  7538.         case 2:
  7539.             ordinal = "nd";
  7540.             break;
  7541.         case 3:
  7542.             ordinal = "rd";
  7543.             break;
  7544.         case 4:
  7545.             ordinal = "th";
  7546.             break;
  7547.         case 5:
  7548.             ordinal = "th";
  7549.             break;
  7550.         case 6:
  7551.             ordinal = "th";
  7552.             break;
  7553.         case 7:
  7554.             ordinal = "th";
  7555.             break;
  7556.         case 8:
  7557.             ordinal = "th";
  7558.             break;
  7559.         case 9:
  7560.             ordinal = "th";
  7561.             break;
  7562.         case 0:
  7563.             ordinal = "th";
  7564.             break;
  7565.         }
  7566.         cout << ordinal;
  7567.         cout << " number.";
  7568.         cout << endl;
  7569.         cout << ">> ";
  7570.         cin  >> entry;
  7571.         cin_is_good = cin.good();
  7572.         cin_isnt_good = ! cin_is_good;
  7573.         if( cin_isnt_good )
  7574.         {
  7575.             BadEntry err;
  7576.             throw( err );
  7577.         }
  7578.         outFile << entry;
  7579.         outFile << ' ';
  7580.     }
  7581.     if( j < number_of_entries )
  7582.     {
  7583.         ++j;
  7584.         ones_digit = j % 10;
  7585.         cout << "Please input the ";
  7586.         cout << j;
  7587.         switch( ones_digit )
  7588.         {
  7589.         case 1:
  7590.             ordinal = "st";
  7591.             break;
  7592.         case 2:
  7593.             ordinal = "nd";
  7594.             break;
  7595.         case 3:
  7596.             ordinal = "rd";
  7597.             break;
  7598.         case 4:
  7599.             ordinal = "th";
  7600.             break;
  7601.         case 5:
  7602.             ordinal = "th";
  7603.             break;
  7604.         case 6:
  7605.             ordinal = "th";
  7606.             break;
  7607.         case 7:
  7608.             ordinal = "th";
  7609.             break;
  7610.         case 8:
  7611.             ordinal = "th";
  7612.             break;
  7613.         case 9:
  7614.             ordinal = "th";
  7615.             break;
  7616.         case 0:
  7617.             ordinal = "th";
  7618.             break;
  7619.         }
  7620.         cout << ordinal;
  7621.         cout << " number.";
  7622.         cout << endl;
  7623.         cout << ">> ";
  7624.         cin  >> entry;
  7625.         cin_is_good = cin.good();
  7626.         cin_isnt_good = ! cin_is_good;
  7627.         if( cin_isnt_good )
  7628.         {
  7629.             BadEntry err;
  7630.             throw( err );
  7631.         }
  7632.         outFile << entry;
  7633.         outFile << ' ';
  7634.     }
  7635.     if( j < number_of_entries )
  7636.     {
  7637.         ++j;
  7638.         ones_digit = j % 10;
  7639.         cout << "Please input the ";
  7640.         cout << j;
  7641.         switch( ones_digit )
  7642.         {
  7643.         case 1:
  7644.             ordinal = "st";
  7645.             break;
  7646.         case 2:
  7647.             ordinal = "nd";
  7648.             break;
  7649.         case 3:
  7650.             ordinal = "rd";
  7651.             break;
  7652.         case 4:
  7653.             ordinal = "th";
  7654.             break;
  7655.         case 5:
  7656.             ordinal = "th";
  7657.             break;
  7658.         case 6:
  7659.             ordinal = "th";
  7660.             break;
  7661.         case 7:
  7662.             ordinal = "th";
  7663.             break;
  7664.         case 8:
  7665.             ordinal = "th";
  7666.             break;
  7667.         case 9:
  7668.             ordinal = "th";
  7669.             break;
  7670.         case 0:
  7671.             ordinal = "th";
  7672.             break;
  7673.         }
  7674.         cout << ordinal;
  7675.         cout << " number.";
  7676.         cout << endl;
  7677.         cout << ">> ";
  7678.         cin  >> entry;
  7679.         cin_is_good = cin.good();
  7680.         cin_isnt_good = ! cin_is_good;
  7681.         if( cin_isnt_good )
  7682.         {
  7683.             BadEntry err;
  7684.             throw( err );
  7685.         }
  7686.         outFile << entry;
  7687.         outFile << ' ';
  7688.     }
  7689.     if( j < number_of_entries )
  7690.     {
  7691.         ++j;
  7692.         ones_digit = j % 10;
  7693.         cout << "Please input the ";
  7694.         cout << j;
  7695.         switch( ones_digit )
  7696.         {
  7697.         case 1:
  7698.             ordinal = "st";
  7699.             break;
  7700.         case 2:
  7701.             ordinal = "nd";
  7702.             break;
  7703.         case 3:
  7704.             ordinal = "rd";
  7705.             break;
  7706.         case 4:
  7707.             ordinal = "th";
  7708.             break;
  7709.         case 5:
  7710.             ordinal = "th";
  7711.             break;
  7712.         case 6:
  7713.             ordinal = "th";
  7714.             break;
  7715.         case 7:
  7716.             ordinal = "th";
  7717.             break;
  7718.         case 8:
  7719.             ordinal = "th";
  7720.             break;
  7721.         case 9:
  7722.             ordinal = "th";
  7723.             break;
  7724.         case 0:
  7725.             ordinal = "th";
  7726.             break;
  7727.         }
  7728.         cout << ordinal;
  7729.         cout << " number.";
  7730.         cout << endl;
  7731.         cout << ">> ";
  7732.         cin  >> entry;
  7733.         cin_is_good = cin.good();
  7734.         cin_isnt_good = ! cin_is_good;
  7735.         if( cin_isnt_good )
  7736.         {
  7737.             BadEntry err;
  7738.             throw( err );
  7739.         }
  7740.         outFile << entry;
  7741.         outFile << ' ';
  7742.     }
  7743.     if( j < number_of_entries )
  7744.     {
  7745.         ++j;
  7746.         ones_digit = j % 10;
  7747.         cout << "Please input the ";
  7748.         cout << j;
  7749.         switch( ones_digit )
  7750.         {
  7751.         case 1:
  7752.             ordinal = "st";
  7753.             break;
  7754.         case 2:
  7755.             ordinal = "nd";
  7756.             break;
  7757.         case 3:
  7758.             ordinal = "rd";
  7759.             break;
  7760.         case 4:
  7761.             ordinal = "th";
  7762.             break;
  7763.         case 5:
  7764.             ordinal = "th";
  7765.             break;
  7766.         case 6:
  7767.             ordinal = "th";
  7768.             break;
  7769.         case 7:
  7770.             ordinal = "th";
  7771.             break;
  7772.         case 8:
  7773.             ordinal = "th";
  7774.             break;
  7775.         case 9:
  7776.             ordinal = "th";
  7777.             break;
  7778.         case 0:
  7779.             ordinal = "th";
  7780.             break;
  7781.         }
  7782.         cout << ordinal;
  7783.         cout << " number.";
  7784.         cout << endl;
  7785.         cout << ">> ";
  7786.         cin  >> entry;
  7787.         cin_is_good = cin.good();
  7788.         cin_isnt_good = ! cin_is_good;
  7789.         if( cin_isnt_good )
  7790.         {
  7791.             BadEntry err;
  7792.             throw( err );
  7793.         }
  7794.         outFile << entry;
  7795.         outFile << ' ';
  7796.     }
  7797.     if( j < number_of_entries )
  7798.     {
  7799.         ++j;
  7800.         ones_digit = j % 10;
  7801.         cout << "Please input the ";
  7802.         cout << j;
  7803.         switch( ones_digit )
  7804.         {
  7805.         case 1:
  7806.             ordinal = "st";
  7807.             break;
  7808.         case 2:
  7809.             ordinal = "nd";
  7810.             break;
  7811.         case 3:
  7812.             ordinal = "rd";
  7813.             break;
  7814.         case 4:
  7815.             ordinal = "th";
  7816.             break;
  7817.         case 5:
  7818.             ordinal = "th";
  7819.             break;
  7820.         case 6:
  7821.             ordinal = "th";
  7822.             break;
  7823.         case 7:
  7824.             ordinal = "th";
  7825.             break;
  7826.         case 8:
  7827.             ordinal = "th";
  7828.             break;
  7829.         case 9:
  7830.             ordinal = "th";
  7831.             break;
  7832.         case 0:
  7833.             ordinal = "th";
  7834.             break;
  7835.         }
  7836.         cout << ordinal;
  7837.         cout << " number.";
  7838.         cout << endl;
  7839.         cout << ">> ";
  7840.         cin  >> entry;
  7841.         cin_is_good = cin.good();
  7842.         cin_isnt_good = ! cin_is_good;
  7843.         if( cin_isnt_good )
  7844.         {
  7845.             BadEntry err;
  7846.             throw( err );
  7847.         }
  7848.         outFile << entry;
  7849.         outFile << ' ';
  7850.     }
  7851.     if( j < number_of_entries )
  7852.     {
  7853.         ++j;
  7854.         ones_digit = j % 10;
  7855.         cout << "Please input the ";
  7856.         cout << j;
  7857.         switch( ones_digit )
  7858.         {
  7859.         case 1:
  7860.             ordinal = "st";
  7861.             break;
  7862.         case 2:
  7863.             ordinal = "nd";
  7864.             break;
  7865.         case 3:
  7866.             ordinal = "rd";
  7867.             break;
  7868.         case 4:
  7869.             ordinal = "th";
  7870.             break;
  7871.         case 5:
  7872.             ordinal = "th";
  7873.             break;
  7874.         case 6:
  7875.             ordinal = "th";
  7876.             break;
  7877.         case 7:
  7878.             ordinal = "th";
  7879.             break;
  7880.         case 8:
  7881.             ordinal = "th";
  7882.             break;
  7883.         case 9:
  7884.             ordinal = "th";
  7885.             break;
  7886.         case 0:
  7887.             ordinal = "th";
  7888.             break;
  7889.         }
  7890.         cout << ordinal;
  7891.         cout << " number.";
  7892.         cout << endl;
  7893.         cout << ">> ";
  7894.         cin  >> entry;
  7895.         cin_is_good = cin.good();
  7896.         cin_isnt_good = ! cin_is_good;
  7897.         if( cin_isnt_good )
  7898.         {
  7899.             BadEntry err;
  7900.             throw( err );
  7901.         }
  7902.         outFile << entry;
  7903.         outFile << ' ';
  7904.     }
  7905.     if( j < number_of_entries )
  7906.     {
  7907.         ++j;
  7908.         ones_digit = j % 10;
  7909.         cout << "Please input the ";
  7910.         cout << j;
  7911.         switch( ones_digit )
  7912.         {
  7913.         case 1:
  7914.             ordinal = "st";
  7915.             break;
  7916.         case 2:
  7917.             ordinal = "nd";
  7918.             break;
  7919.         case 3:
  7920.             ordinal = "rd";
  7921.             break;
  7922.         case 4:
  7923.             ordinal = "th";
  7924.             break;
  7925.         case 5:
  7926.             ordinal = "th";
  7927.             break;
  7928.         case 6:
  7929.             ordinal = "th";
  7930.             break;
  7931.         case 7:
  7932.             ordinal = "th";
  7933.             break;
  7934.         case 8:
  7935.             ordinal = "th";
  7936.             break;
  7937.         case 9:
  7938.             ordinal = "th";
  7939.             break;
  7940.         case 0:
  7941.             ordinal = "th";
  7942.             break;
  7943.         }
  7944.         cout << ordinal;
  7945.         cout << " number.";
  7946.         cout << endl;
  7947.         cout << ">> ";
  7948.         cin  >> entry;
  7949.         cin_is_good = cin.good();
  7950.         cin_isnt_good = ! cin_is_good;
  7951.         if( cin_isnt_good )
  7952.         {
  7953.             BadEntry err;
  7954.             throw( err );
  7955.         }
  7956.         outFile << entry;
  7957.         outFile << ' ';
  7958.     }
  7959.     if( j < number_of_entries )
  7960.     {
  7961.         ++j;
  7962.         ones_digit = j % 10;
  7963.         cout << "Please input the ";
  7964.         cout << j;
  7965.         switch( ones_digit )
  7966.         {
  7967.         case 1:
  7968.             ordinal = "st";
  7969.             break;
  7970.         case 2:
  7971.             ordinal = "nd";
  7972.             break;
  7973.         case 3:
  7974.             ordinal = "rd";
  7975.             break;
  7976.         case 4:
  7977.             ordinal = "th";
  7978.             break;
  7979.         case 5:
  7980.             ordinal = "th";
  7981.             break;
  7982.         case 6:
  7983.             ordinal = "th";
  7984.             break;
  7985.         case 7:
  7986.             ordinal = "th";
  7987.             break;
  7988.         case 8:
  7989.             ordinal = "th";
  7990.             break;
  7991.         case 9:
  7992.             ordinal = "th";
  7993.             break;
  7994.         case 0:
  7995.             ordinal = "th";
  7996.             break;
  7997.         }
  7998.         cout << ordinal;
  7999.         cout << " number.";
  8000.         cout << endl;
  8001.         cout << ">> ";
  8002.         cin  >> entry;
  8003.         cin_is_good = cin.good();
  8004.         cin_isnt_good = ! cin_is_good;
  8005.         if( cin_isnt_good )
  8006.         {
  8007.             BadEntry err;
  8008.             throw( err );
  8009.         }
  8010.         outFile << entry;
  8011.         outFile << ' ';
  8012.     }
  8013.     if( j < number_of_entries )
  8014.     {
  8015.         ++j;
  8016.         ones_digit = j % 10;
  8017.         cout << "Please input the ";
  8018.         cout << j;
  8019.         switch( ones_digit )
  8020.         {
  8021.         case 1:
  8022.             ordinal = "st";
  8023.             break;
  8024.         case 2:
  8025.             ordinal = "nd";
  8026.             break;
  8027.         case 3:
  8028.             ordinal = "rd";
  8029.             break;
  8030.         case 4:
  8031.             ordinal = "th";
  8032.             break;
  8033.         case 5:
  8034.             ordinal = "th";
  8035.             break;
  8036.         case 6:
  8037.             ordinal = "th";
  8038.             break;
  8039.         case 7:
  8040.             ordinal = "th";
  8041.             break;
  8042.         case 8:
  8043.             ordinal = "th";
  8044.             break;
  8045.         case 9:
  8046.             ordinal = "th";
  8047.             break;
  8048.         case 0:
  8049.             ordinal = "th";
  8050.             break;
  8051.         }
  8052.         cout << ordinal;
  8053.         cout << " number.";
  8054.         cout << endl;
  8055.         cout << ">> ";
  8056.         cin  >> entry;
  8057.         cin_is_good = cin.good();
  8058.         cin_isnt_good = ! cin_is_good;
  8059.         if( cin_isnt_good )
  8060.         {
  8061.             BadEntry err;
  8062.             throw( err );
  8063.         }
  8064.         outFile << entry;
  8065.         outFile << ' ';
  8066.     }
  8067.     if( j < number_of_entries )
  8068.     {
  8069.         ++j;
  8070.         ones_digit = j % 10;
  8071.         cout << "Please input the ";
  8072.         cout << j;
  8073.         switch( ones_digit )
  8074.         {
  8075.         case 1:
  8076.             ordinal = "st";
  8077.             break;
  8078.         case 2:
  8079.             ordinal = "nd";
  8080.             break;
  8081.         case 3:
  8082.             ordinal = "rd";
  8083.             break;
  8084.         case 4:
  8085.             ordinal = "th";
  8086.             break;
  8087.         case 5:
  8088.             ordinal = "th";
  8089.             break;
  8090.         case 6:
  8091.             ordinal = "th";
  8092.             break;
  8093.         case 7:
  8094.             ordinal = "th";
  8095.             break;
  8096.         case 8:
  8097.             ordinal = "th";
  8098.             break;
  8099.         case 9:
  8100.             ordinal = "th";
  8101.             break;
  8102.         case 0:
  8103.             ordinal = "th";
  8104.             break;
  8105.         }
  8106.         cout << ordinal;
  8107.         cout << " number.";
  8108.         cout << endl;
  8109.         cout << ">> ";
  8110.         cin  >> entry;
  8111.         cin_is_good = cin.good();
  8112.         cin_isnt_good = ! cin_is_good;
  8113.         if( cin_isnt_good )
  8114.         {
  8115.             BadEntry err;
  8116.             throw( err );
  8117.         }
  8118.         outFile << entry;
  8119.         outFile << ' ';
  8120.     }
  8121.     if( j < number_of_entries )
  8122.     {
  8123.         ++j;
  8124.         ones_digit = j % 10;
  8125.         cout << "Please input the ";
  8126.         cout << j;
  8127.         switch( ones_digit )
  8128.         {
  8129.         case 1:
  8130.             ordinal = "st";
  8131.             break;
  8132.         case 2:
  8133.             ordinal = "nd";
  8134.             break;
  8135.         case 3:
  8136.             ordinal = "rd";
  8137.             break;
  8138.         case 4:
  8139.             ordinal = "th";
  8140.             break;
  8141.         case 5:
  8142.             ordinal = "th";
  8143.             break;
  8144.         case 6:
  8145.             ordinal = "th";
  8146.             break;
  8147.         case 7:
  8148.             ordinal = "th";
  8149.             break;
  8150.         case 8:
  8151.             ordinal = "th";
  8152.             break;
  8153.         case 9:
  8154.             ordinal = "th";
  8155.             break;
  8156.         case 0:
  8157.             ordinal = "th";
  8158.             break;
  8159.         }
  8160.         cout << ordinal;
  8161.         cout << " number.";
  8162.         cout << endl;
  8163.         cout << ">> ";
  8164.         cin  >> entry;
  8165.         cin_is_good = cin.good();
  8166.         cin_isnt_good = ! cin_is_good;
  8167.         if( cin_isnt_good )
  8168.         {
  8169.             BadEntry err;
  8170.             throw( err );
  8171.         }
  8172.         outFile << entry;
  8173.         outFile << ' ';
  8174.     }
  8175.     if( j < number_of_entries )
  8176.     {
  8177.         ++j;
  8178.         ones_digit = j % 10;
  8179.         cout << "Please input the ";
  8180.         cout << j;
  8181.         switch( ones_digit )
  8182.         {
  8183.         case 1:
  8184.             ordinal = "st";
  8185.             break;
  8186.         case 2:
  8187.             ordinal = "nd";
  8188.             break;
  8189.         case 3:
  8190.             ordinal = "rd";
  8191.             break;
  8192.         case 4:
  8193.             ordinal = "th";
  8194.             break;
  8195.         case 5:
  8196.             ordinal = "th";
  8197.             break;
  8198.         case 6:
  8199.             ordinal = "th";
  8200.             break;
  8201.         case 7:
  8202.             ordinal = "th";
  8203.             break;
  8204.         case 8:
  8205.             ordinal = "th";
  8206.             break;
  8207.         case 9:
  8208.             ordinal = "th";
  8209.             break;
  8210.         case 0:
  8211.             ordinal = "th";
  8212.             break;
  8213.         }
  8214.         cout << ordinal;
  8215.         cout << " number.";
  8216.         cout << endl;
  8217.         cout << ">> ";
  8218.         cin  >> entry;
  8219.         cin_is_good = cin.good();
  8220.         cin_isnt_good = ! cin_is_good;
  8221.         if( cin_isnt_good )
  8222.         {
  8223.             BadEntry err;
  8224.             throw( err );
  8225.         }
  8226.         outFile << entry;
  8227.         outFile << ' ';
  8228.     }
  8229.     if( j < number_of_entries )
  8230.     {
  8231.         ++j;
  8232.         ones_digit = j % 10;
  8233.         cout << "Please input the ";
  8234.         cout << j;
  8235.         switch( ones_digit )
  8236.         {
  8237.         case 1:
  8238.             ordinal = "st";
  8239.             break;
  8240.         case 2:
  8241.             ordinal = "nd";
  8242.             break;
  8243.         case 3:
  8244.             ordinal = "rd";
  8245.             break;
  8246.         case 4:
  8247.             ordinal = "th";
  8248.             break;
  8249.         case 5:
  8250.             ordinal = "th";
  8251.             break;
  8252.         case 6:
  8253.             ordinal = "th";
  8254.             break;
  8255.         case 7:
  8256.             ordinal = "th";
  8257.             break;
  8258.         case 8:
  8259.             ordinal = "th";
  8260.             break;
  8261.         case 9:
  8262.             ordinal = "th";
  8263.             break;
  8264.         case 0:
  8265.             ordinal = "th";
  8266.             break;
  8267.         }
  8268.         cout << ordinal;
  8269.         cout << " number.";
  8270.         cout << endl;
  8271.         cout << ">> ";
  8272.         cin  >> entry;
  8273.         cin_is_good = cin.good();
  8274.         cin_isnt_good = ! cin_is_good;
  8275.         if( cin_isnt_good )
  8276.         {
  8277.             BadEntry err;
  8278.             throw( err );
  8279.         }
  8280.         outFile << entry;
  8281.         outFile << ' ';
  8282.     }
  8283.     if( j < number_of_entries )
  8284.     {
  8285.         ++j;
  8286.         ones_digit = j % 10;
  8287.         cout << "Please input the ";
  8288.         cout << j;
  8289.         switch( ones_digit )
  8290.         {
  8291.         case 1:
  8292.             ordinal = "st";
  8293.             break;
  8294.         case 2:
  8295.             ordinal = "nd";
  8296.             break;
  8297.         case 3:
  8298.             ordinal = "rd";
  8299.             break;
  8300.         case 4:
  8301.             ordinal = "th";
  8302.             break;
  8303.         case 5:
  8304.             ordinal = "th";
  8305.             break;
  8306.         case 6:
  8307.             ordinal = "th";
  8308.             break;
  8309.         case 7:
  8310.             ordinal = "th";
  8311.             break;
  8312.         case 8:
  8313.             ordinal = "th";
  8314.             break;
  8315.         case 9:
  8316.             ordinal = "th";
  8317.             break;
  8318.         case 0:
  8319.             ordinal = "th";
  8320.             break;
  8321.         }
  8322.         cout << ordinal;
  8323.         cout << " number.";
  8324.         cout << endl;
  8325.         cout << ">> ";
  8326.         cin  >> entry;
  8327.         cin_is_good = cin.good();
  8328.         cin_isnt_good = ! cin_is_good;
  8329.         if( cin_isnt_good )
  8330.         {
  8331.             BadEntry err;
  8332.             throw( err );
  8333.         }
  8334.         outFile << entry;
  8335.         outFile << ' ';
  8336.     }
  8337.     if( j < number_of_entries )
  8338.     {
  8339.         ++j;
  8340.         ones_digit = j % 10;
  8341.         cout << "Please input the ";
  8342.         cout << j;
  8343.         switch( ones_digit )
  8344.         {
  8345.         case 1:
  8346.             ordinal = "st";
  8347.             break;
  8348.         case 2:
  8349.             ordinal = "nd";
  8350.             break;
  8351.         case 3:
  8352.             ordinal = "rd";
  8353.             break;
  8354.         case 4:
  8355.             ordinal = "th";
  8356.             break;
  8357.         case 5:
  8358.             ordinal = "th";
  8359.             break;
  8360.         case 6:
  8361.             ordinal = "th";
  8362.             break;
  8363.         case 7:
  8364.             ordinal = "th";
  8365.             break;
  8366.         case 8:
  8367.             ordinal = "th";
  8368.             break;
  8369.         case 9:
  8370.             ordinal = "th";
  8371.             break;
  8372.         case 0:
  8373.             ordinal = "th";
  8374.             break;
  8375.         }
  8376.         cout << ordinal;
  8377.         cout << " number.";
  8378.         cout << endl;
  8379.         cout << ">> ";
  8380.         cin  >> entry;
  8381.         cin_is_good = cin.good();
  8382.         cin_isnt_good = ! cin_is_good;
  8383.         if( cin_isnt_good )
  8384.         {
  8385.             BadEntry err;
  8386.             throw( err );
  8387.         }
  8388.         outFile << entry;
  8389.         outFile << ' ';
  8390.     }
  8391.     if( j < number_of_entries )
  8392.     {
  8393.         ++j;
  8394.         ones_digit = j % 10;
  8395.         cout << "Please input the ";
  8396.         cout << j;
  8397.         switch( ones_digit )
  8398.         {
  8399.         case 1:
  8400.             ordinal = "st";
  8401.             break;
  8402.         case 2:
  8403.             ordinal = "nd";
  8404.             break;
  8405.         case 3:
  8406.             ordinal = "rd";
  8407.             break;
  8408.         case 4:
  8409.             ordinal = "th";
  8410.             break;
  8411.         case 5:
  8412.             ordinal = "th";
  8413.             break;
  8414.         case 6:
  8415.             ordinal = "th";
  8416.             break;
  8417.         case 7:
  8418.             ordinal = "th";
  8419.             break;
  8420.         case 8:
  8421.             ordinal = "th";
  8422.             break;
  8423.         case 9:
  8424.             ordinal = "th";
  8425.             break;
  8426.         case 0:
  8427.             ordinal = "th";
  8428.             break;
  8429.         }
  8430.         cout << ordinal;
  8431.         cout << " number.";
  8432.         cout << endl;
  8433.         cout << ">> ";
  8434.         cin  >> entry;
  8435.         cin_is_good = cin.good();
  8436.         cin_isnt_good = ! cin_is_good;
  8437.         if( cin_isnt_good )
  8438.         {
  8439.             BadEntry err;
  8440.             throw( err );
  8441.         }
  8442.         outFile << entry;
  8443.         outFile << ' ';
  8444.     }
  8445.     if( j < number_of_entries )
  8446.     {
  8447.         ++j;
  8448.         ones_digit = j % 10;
  8449.         cout << "Please input the ";
  8450.         cout << j;
  8451.         switch( ones_digit )
  8452.         {
  8453.         case 1:
  8454.             ordinal = "st";
  8455.             break;
  8456.         case 2:
  8457.             ordinal = "nd";
  8458.             break;
  8459.         case 3:
  8460.             ordinal = "rd";
  8461.             break;
  8462.         case 4:
  8463.             ordinal = "th";
  8464.             break;
  8465.         case 5:
  8466.             ordinal = "th";
  8467.             break;
  8468.         case 6:
  8469.             ordinal = "th";
  8470.             break;
  8471.         case 7:
  8472.             ordinal = "th";
  8473.             break;
  8474.         case 8:
  8475.             ordinal = "th";
  8476.             break;
  8477.         case 9:
  8478.             ordinal = "th";
  8479.             break;
  8480.         case 0:
  8481.             ordinal = "th";
  8482.             break;
  8483.         }
  8484.         cout << ordinal;
  8485.         cout << " number.";
  8486.         cout << endl;
  8487.         cout << ">> ";
  8488.         cin  >> entry;
  8489.         cin_is_good = cin.good();
  8490.         cin_isnt_good = ! cin_is_good;
  8491.         if( cin_isnt_good )
  8492.         {
  8493.             BadEntry err;
  8494.             throw( err );
  8495.         }
  8496.         outFile << entry;
  8497.         outFile << ' ';
  8498.     }
  8499.     if( j < number_of_entries )
  8500.     {
  8501.         ++j;
  8502.         ones_digit = j % 10;
  8503.         cout << "Please input the ";
  8504.         cout << j;
  8505.         switch( ones_digit )
  8506.         {
  8507.         case 1:
  8508.             ordinal = "st";
  8509.             break;
  8510.         case 2:
  8511.             ordinal = "nd";
  8512.             break;
  8513.         case 3:
  8514.             ordinal = "rd";
  8515.             break;
  8516.         case 4:
  8517.             ordinal = "th";
  8518.             break;
  8519.         case 5:
  8520.             ordinal = "th";
  8521.             break;
  8522.         case 6:
  8523.             ordinal = "th";
  8524.             break;
  8525.         case 7:
  8526.             ordinal = "th";
  8527.             break;
  8528.         case 8:
  8529.             ordinal = "th";
  8530.             break;
  8531.         case 9:
  8532.             ordinal = "th";
  8533.             break;
  8534.         case 0:
  8535.             ordinal = "th";
  8536.             break;
  8537.         }
  8538.         cout << ordinal;
  8539.         cout << " number.";
  8540.         cout << endl;
  8541.         cout << ">> ";
  8542.         cin  >> entry;
  8543.         cin_is_good = cin.good();
  8544.         cin_isnt_good = ! cin_is_good;
  8545.         if( cin_isnt_good )
  8546.         {
  8547.             BadEntry err;
  8548.             throw( err );
  8549.         }
  8550.         outFile << entry;
  8551.         outFile << ' ';
  8552.     }
  8553.     if( j < number_of_entries )
  8554.     {
  8555.         ++j;
  8556.         ones_digit = j % 10;
  8557.         cout << "Please input the ";
  8558.         cout << j;
  8559.         switch( ones_digit )
  8560.         {
  8561.         case 1:
  8562.             ordinal = "st";
  8563.             break;
  8564.         case 2:
  8565.             ordinal = "nd";
  8566.             break;
  8567.         case 3:
  8568.             ordinal = "rd";
  8569.             break;
  8570.         case 4:
  8571.             ordinal = "th";
  8572.             break;
  8573.         case 5:
  8574.             ordinal = "th";
  8575.             break;
  8576.         case 6:
  8577.             ordinal = "th";
  8578.             break;
  8579.         case 7:
  8580.             ordinal = "th";
  8581.             break;
  8582.         case 8:
  8583.             ordinal = "th";
  8584.             break;
  8585.         case 9:
  8586.             ordinal = "th";
  8587.             break;
  8588.         case 0:
  8589.             ordinal = "th";
  8590.             break;
  8591.         }
  8592.         cout << ordinal;
  8593.         cout << " number.";
  8594.         cout << endl;
  8595.         cout << ">> ";
  8596.         cin  >> entry;
  8597.         cin_is_good = cin.good();
  8598.         cin_isnt_good = ! cin_is_good;
  8599.         if( cin_isnt_good )
  8600.         {
  8601.             BadEntry err;
  8602.             throw( err );
  8603.         }
  8604.         outFile << entry;
  8605.         outFile << ' ';
  8606.     }
  8607.     if( j < number_of_entries )
  8608.     {
  8609.         ++j;
  8610.         ones_digit = j % 10;
  8611.         cout << "Please input the ";
  8612.         cout << j;
  8613.         switch( ones_digit )
  8614.         {
  8615.         case 1:
  8616.             ordinal = "st";
  8617.             break;
  8618.         case 2:
  8619.             ordinal = "nd";
  8620.             break;
  8621.         case 3:
  8622.             ordinal = "rd";
  8623.             break;
  8624.         case 4:
  8625.             ordinal = "th";
  8626.             break;
  8627.         case 5:
  8628.             ordinal = "th";
  8629.             break;
  8630.         case 6:
  8631.             ordinal = "th";
  8632.             break;
  8633.         case 7:
  8634.             ordinal = "th";
  8635.             break;
  8636.         case 8:
  8637.             ordinal = "th";
  8638.             break;
  8639.         case 9:
  8640.             ordinal = "th";
  8641.             break;
  8642.         case 0:
  8643.             ordinal = "th";
  8644.             break;
  8645.         }
  8646.         cout << ordinal;
  8647.         cout << " number.";
  8648.         cout << endl;
  8649.         cout << ">> ";
  8650.         cin  >> entry;
  8651.         cin_is_good = cin.good();
  8652.         cin_isnt_good = ! cin_is_good;
  8653.         if( cin_isnt_good )
  8654.         {
  8655.             BadEntry err;
  8656.             throw( err );
  8657.         }
  8658.         outFile << entry;
  8659.         outFile << ' ';
  8660.     }
  8661.     if( j < number_of_entries )
  8662.     {
  8663.         ++j;
  8664.         ones_digit = j % 10;
  8665.         cout << "Please input the ";
  8666.         cout << j;
  8667.         switch( ones_digit )
  8668.         {
  8669.         case 1:
  8670.             ordinal = "st";
  8671.             break;
  8672.         case 2:
  8673.             ordinal = "nd";
  8674.             break;
  8675.         case 3:
  8676.             ordinal = "rd";
  8677.             break;
  8678.         case 4:
  8679.             ordinal = "th";
  8680.             break;
  8681.         case 5:
  8682.             ordinal = "th";
  8683.             break;
  8684.         case 6:
  8685.             ordinal = "th";
  8686.             break;
  8687.         case 7:
  8688.             ordinal = "th";
  8689.             break;
  8690.         case 8:
  8691.             ordinal = "th";
  8692.             break;
  8693.         case 9:
  8694.             ordinal = "th";
  8695.             break;
  8696.         case 0:
  8697.             ordinal = "th";
  8698.             break;
  8699.         }
  8700.         cout << ordinal;
  8701.         cout << " number.";
  8702.         cout << endl;
  8703.         cout << ">> ";
  8704.         cin  >> entry;
  8705.         cin_is_good = cin.good();
  8706.         cin_isnt_good = ! cin_is_good;
  8707.         if( cin_isnt_good )
  8708.         {
  8709.             BadEntry err;
  8710.             throw( err );
  8711.         }
  8712.         outFile << entry;
  8713.         outFile << ' ';
  8714.     }
  8715.     if( j < number_of_entries )
  8716.     {
  8717.         ++j;
  8718.         ones_digit = j % 10;
  8719.         cout << "Please input the ";
  8720.         cout << j;
  8721.         switch( ones_digit )
  8722.         {
  8723.         case 1:
  8724.             ordinal = "st";
  8725.             break;
  8726.         case 2:
  8727.             ordinal = "nd";
  8728.             break;
  8729.         case 3:
  8730.             ordinal = "rd";
  8731.             break;
  8732.         case 4:
  8733.             ordinal = "th";
  8734.             break;
  8735.         case 5:
  8736.             ordinal = "th";
  8737.             break;
  8738.         case 6:
  8739.             ordinal = "th";
  8740.             break;
  8741.         case 7:
  8742.             ordinal = "th";
  8743.             break;
  8744.         case 8:
  8745.             ordinal = "th";
  8746.             break;
  8747.         case 9:
  8748.             ordinal = "th";
  8749.             break;
  8750.         case 0:
  8751.             ordinal = "th";
  8752.             break;
  8753.         }
  8754.         cout << ordinal;
  8755.         cout << " number.";
  8756.         cout << endl;
  8757.         cout << ">> ";
  8758.         cin  >> entry;
  8759.         cin_is_good = cin.good();
  8760.         cin_isnt_good = ! cin_is_good;
  8761.         if( cin_isnt_good )
  8762.         {
  8763.             BadEntry err;
  8764.             throw( err );
  8765.         }
  8766.         outFile << entry;
  8767.         outFile << ' ';
  8768.     }
  8769.     if( j < number_of_entries )
  8770.     {
  8771.         ++j;
  8772.         ones_digit = j % 10;
  8773.         cout << "Please input the ";
  8774.         cout << j;
  8775.         switch( ones_digit )
  8776.         {
  8777.         case 1:
  8778.             ordinal = "st";
  8779.             break;
  8780.         case 2:
  8781.             ordinal = "nd";
  8782.             break;
  8783.         case 3:
  8784.             ordinal = "rd";
  8785.             break;
  8786.         case 4:
  8787.             ordinal = "th";
  8788.             break;
  8789.         case 5:
  8790.             ordinal = "th";
  8791.             break;
  8792.         case 6:
  8793.             ordinal = "th";
  8794.             break;
  8795.         case 7:
  8796.             ordinal = "th";
  8797.             break;
  8798.         case 8:
  8799.             ordinal = "th";
  8800.             break;
  8801.         case 9:
  8802.             ordinal = "th";
  8803.             break;
  8804.         case 0:
  8805.             ordinal = "th";
  8806.             break;
  8807.         }
  8808.         cout << ordinal;
  8809.         cout << " number.";
  8810.         cout << endl;
  8811.         cout << ">> ";
  8812.         cin  >> entry;
  8813.         cin_is_good = cin.good();
  8814.         cin_isnt_good = ! cin_is_good;
  8815.         if( cin_isnt_good )
  8816.         {
  8817.             BadEntry err;
  8818.             throw( err );
  8819.         }
  8820.         outFile << entry;
  8821.         outFile << ' ';
  8822.     }
  8823.     if( j < number_of_entries )
  8824.     {
  8825.         ++j;
  8826.         ones_digit = j % 10;
  8827.         cout << "Please input the ";
  8828.         cout << j;
  8829.         switch( ones_digit )
  8830.         {
  8831.         case 1:
  8832.             ordinal = "st";
  8833.             break;
  8834.         case 2:
  8835.             ordinal = "nd";
  8836.             break;
  8837.         case 3:
  8838.             ordinal = "rd";
  8839.             break;
  8840.         case 4:
  8841.             ordinal = "th";
  8842.             break;
  8843.         case 5:
  8844.             ordinal = "th";
  8845.             break;
  8846.         case 6:
  8847.             ordinal = "th";
  8848.             break;
  8849.         case 7:
  8850.             ordinal = "th";
  8851.             break;
  8852.         case 8:
  8853.             ordinal = "th";
  8854.             break;
  8855.         case 9:
  8856.             ordinal = "th";
  8857.             break;
  8858.         case 0:
  8859.             ordinal = "th";
  8860.             break;
  8861.         }
  8862.         cout << ordinal;
  8863.         cout << " number.";
  8864.         cout << endl;
  8865.         cout << ">> ";
  8866.         cin  >> entry;
  8867.         cin_is_good = cin.good();
  8868.         cin_isnt_good = ! cin_is_good;
  8869.         if( cin_isnt_good )
  8870.         {
  8871.             BadEntry err;
  8872.             throw( err );
  8873.         }
  8874.         outFile << entry;
  8875.         outFile << ' ';
  8876.     }
  8877.     if( j < number_of_entries )
  8878.     {
  8879.         ++j;
  8880.         ones_digit = j % 10;
  8881.         cout << "Please input the ";
  8882.         cout << j;
  8883.         switch( ones_digit )
  8884.         {
  8885.         case 1:
  8886.             ordinal = "st";
  8887.             break;
  8888.         case 2:
  8889.             ordinal = "nd";
  8890.             break;
  8891.         case 3:
  8892.             ordinal = "rd";
  8893.             break;
  8894.         case 4:
  8895.             ordinal = "th";
  8896.             break;
  8897.         case 5:
  8898.             ordinal = "th";
  8899.             break;
  8900.         case 6:
  8901.             ordinal = "th";
  8902.             break;
  8903.         case 7:
  8904.             ordinal = "th";
  8905.             break;
  8906.         case 8:
  8907.             ordinal = "th";
  8908.             break;
  8909.         case 9:
  8910.             ordinal = "th";
  8911.             break;
  8912.         case 0:
  8913.             ordinal = "th";
  8914.             break;
  8915.         }
  8916.         cout << ordinal;
  8917.         cout << " number.";
  8918.         cout << endl;
  8919.         cout << ">> ";
  8920.         cin  >> entry;
  8921.         cin_is_good = cin.good();
  8922.         cin_isnt_good = ! cin_is_good;
  8923.         if( cin_isnt_good )
  8924.         {
  8925.             BadEntry err;
  8926.             throw( err );
  8927.         }
  8928.         outFile << entry;
  8929.         outFile << ' ';
  8930.     }
  8931.     if( j < number_of_entries )
  8932.     {
  8933.         ++j;
  8934.         ones_digit = j % 10;
  8935.         cout << "Please input the ";
  8936.         cout << j;
  8937.         switch( ones_digit )
  8938.         {
  8939.         case 1:
  8940.             ordinal = "st";
  8941.             break;
  8942.         case 2:
  8943.             ordinal = "nd";
  8944.             break;
  8945.         case 3:
  8946.             ordinal = "rd";
  8947.             break;
  8948.         case 4:
  8949.             ordinal = "th";
  8950.             break;
  8951.         case 5:
  8952.             ordinal = "th";
  8953.             break;
  8954.         case 6:
  8955.             ordinal = "th";
  8956.             break;
  8957.         case 7:
  8958.             ordinal = "th";
  8959.             break;
  8960.         case 8:
  8961.             ordinal = "th";
  8962.             break;
  8963.         case 9:
  8964.             ordinal = "th";
  8965.             break;
  8966.         case 0:
  8967.             ordinal = "th";
  8968.             break;
  8969.         }
  8970.         cout << ordinal;
  8971.         cout << " number.";
  8972.         cout << endl;
  8973.         cout << ">> ";
  8974.         cin  >> entry;
  8975.         cin_is_good = cin.good();
  8976.         cin_isnt_good = ! cin_is_good;
  8977.         if( cin_isnt_good )
  8978.         {
  8979.             BadEntry err;
  8980.             throw( err );
  8981.         }
  8982.         outFile << entry;
  8983.         outFile << ' ';
  8984.     }
  8985.     if( j < number_of_entries )
  8986.     {
  8987.         ++j;
  8988.         ones_digit = j % 10;
  8989.         cout << "Please input the ";
  8990.         cout << j;
  8991.         switch( ones_digit )
  8992.         {
  8993.         case 1:
  8994.             ordinal = "st";
  8995.             break;
  8996.         case 2:
  8997.             ordinal = "nd";
  8998.             break;
  8999.         case 3:
  9000.             ordinal = "rd";
  9001.             break;
  9002.         case 4:
  9003.             ordinal = "th";
  9004.             break;
  9005.         case 5:
  9006.             ordinal = "th";
  9007.             break;
  9008.         case 6:
  9009.             ordinal = "th";
  9010.             break;
  9011.         case 7:
  9012.             ordinal = "th";
  9013.             break;
  9014.         case 8:
  9015.             ordinal = "th";
  9016.             break;
  9017.         case 9:
  9018.             ordinal = "th";
  9019.             break;
  9020.         case 0:
  9021.             ordinal = "th";
  9022.             break;
  9023.         }
  9024.         cout << ordinal;
  9025.         cout << " number.";
  9026.         cout << endl;
  9027.         cout << ">> ";
  9028.         cin  >> entry;
  9029.         cin_is_good = cin.good();
  9030.         cin_isnt_good = ! cin_is_good;
  9031.         if( cin_isnt_good )
  9032.         {
  9033.             BadEntry err;
  9034.             throw( err );
  9035.         }
  9036.         outFile << entry;
  9037.         outFile << ' ';
  9038.     }
  9039.     if( j < number_of_entries )
  9040.     {
  9041.         ++j;
  9042.         ones_digit = j % 10;
  9043.         cout << "Please input the ";
  9044.         cout << j;
  9045.         switch( ones_digit )
  9046.         {
  9047.         case 1:
  9048.             ordinal = "st";
  9049.             break;
  9050.         case 2:
  9051.             ordinal = "nd";
  9052.             break;
  9053.         case 3:
  9054.             ordinal = "rd";
  9055.             break;
  9056.         case 4:
  9057.             ordinal = "th";
  9058.             break;
  9059.         case 5:
  9060.             ordinal = "th";
  9061.             break;
  9062.         case 6:
  9063.             ordinal = "th";
  9064.             break;
  9065.         case 7:
  9066.             ordinal = "th";
  9067.             break;
  9068.         case 8:
  9069.             ordinal = "th";
  9070.             break;
  9071.         case 9:
  9072.             ordinal = "th";
  9073.             break;
  9074.         case 0:
  9075.             ordinal = "th";
  9076.             break;
  9077.         }
  9078.         cout << ordinal;
  9079.         cout << " number.";
  9080.         cout << endl;
  9081.         cout << ">> ";
  9082.         cin  >> entry;
  9083.         cin_is_good = cin.good();
  9084.         cin_isnt_good = ! cin_is_good;
  9085.         if( cin_isnt_good )
  9086.         {
  9087.             BadEntry err;
  9088.             throw( err );
  9089.         }
  9090.         outFile << entry;
  9091.         outFile << ' ';
  9092.     }
  9093.     if( j < number_of_entries )
  9094.     {
  9095.         ++j;
  9096.         ones_digit = j % 10;
  9097.         cout << "Please input the ";
  9098.         cout << j;
  9099.         switch( ones_digit )
  9100.         {
  9101.         case 1:
  9102.             ordinal = "st";
  9103.             break;
  9104.         case 2:
  9105.             ordinal = "nd";
  9106.             break;
  9107.         case 3:
  9108.             ordinal = "rd";
  9109.             break;
  9110.         case 4:
  9111.             ordinal = "th";
  9112.             break;
  9113.         case 5:
  9114.             ordinal = "th";
  9115.             break;
  9116.         case 6:
  9117.             ordinal = "th";
  9118.             break;
  9119.         case 7:
  9120.             ordinal = "th";
  9121.             break;
  9122.         case 8:
  9123.             ordinal = "th";
  9124.             break;
  9125.         case 9:
  9126.             ordinal = "th";
  9127.             break;
  9128.         case 0:
  9129.             ordinal = "th";
  9130.             break;
  9131.         }
  9132.         cout << ordinal;
  9133.         cout << " number.";
  9134.         cout << endl;
  9135.         cout << ">> ";
  9136.         cin  >> entry;
  9137.         cin_is_good = cin.good();
  9138.         cin_isnt_good = ! cin_is_good;
  9139.         if( cin_isnt_good )
  9140.         {
  9141.             BadEntry err;
  9142.             throw( err );
  9143.         }
  9144.         outFile << entry;
  9145.         outFile << ' ';
  9146.     }
  9147.     if( j < number_of_entries )
  9148.     {
  9149.         ++j;
  9150.         ones_digit = j % 10;
  9151.         cout << "Please input the ";
  9152.         cout << j;
  9153.         switch( ones_digit )
  9154.         {
  9155.         case 1:
  9156.             ordinal = "st";
  9157.             break;
  9158.         case 2:
  9159.             ordinal = "nd";
  9160.             break;
  9161.         case 3:
  9162.             ordinal = "rd";
  9163.             break;
  9164.         case 4:
  9165.             ordinal = "th";
  9166.             break;
  9167.         case 5:
  9168.             ordinal = "th";
  9169.             break;
  9170.         case 6:
  9171.             ordinal = "th";
  9172.             break;
  9173.         case 7:
  9174.             ordinal = "th";
  9175.             break;
  9176.         case 8:
  9177.             ordinal = "th";
  9178.             break;
  9179.         case 9:
  9180.             ordinal = "th";
  9181.             break;
  9182.         case 0:
  9183.             ordinal = "th";
  9184.             break;
  9185.         }
  9186.         cout << ordinal;
  9187.         cout << " number.";
  9188.         cout << endl;
  9189.         cout << ">> ";
  9190.         cin  >> entry;
  9191.         cin_is_good = cin.good();
  9192.         cin_isnt_good = ! cin_is_good;
  9193.         if( cin_isnt_good )
  9194.         {
  9195.             BadEntry err;
  9196.             throw( err );
  9197.         }
  9198.         outFile << entry;
  9199.         outFile << ' ';
  9200.     }
  9201.     if( j < number_of_entries )
  9202.     {
  9203.         ++j;
  9204.         ones_digit = j % 10;
  9205.         cout << "Please input the ";
  9206.         cout << j;
  9207.         switch( ones_digit )
  9208.         {
  9209.         case 1:
  9210.             ordinal = "st";
  9211.             break;
  9212.         case 2:
  9213.             ordinal = "nd";
  9214.             break;
  9215.         case 3:
  9216.             ordinal = "rd";
  9217.             break;
  9218.         case 4:
  9219.             ordinal = "th";
  9220.             break;
  9221.         case 5:
  9222.             ordinal = "th";
  9223.             break;
  9224.         case 6:
  9225.             ordinal = "th";
  9226.             break;
  9227.         case 7:
  9228.             ordinal = "th";
  9229.             break;
  9230.         case 8:
  9231.             ordinal = "th";
  9232.             break;
  9233.         case 9:
  9234.             ordinal = "th";
  9235.             break;
  9236.         case 0:
  9237.             ordinal = "th";
  9238.             break;
  9239.         }
  9240.         cout << ordinal;
  9241.         cout << " number.";
  9242.         cout << endl;
  9243.         cout << ">> ";
  9244.         cin  >> entry;
  9245.         cin_is_good = cin.good();
  9246.         cin_isnt_good = ! cin_is_good;
  9247.         if( cin_isnt_good )
  9248.         {
  9249.             BadEntry err;
  9250.             throw( err );
  9251.         }
  9252.         outFile << entry;
  9253.         outFile << ' ';
  9254.     }
  9255.     if( j < number_of_entries )
  9256.     {
  9257.         ++j;
  9258.         ones_digit = j % 10;
  9259.         cout << "Please input the ";
  9260.         cout << j;
  9261.         switch( ones_digit )
  9262.         {
  9263.         case 1:
  9264.             ordinal = "st";
  9265.             break;
  9266.         case 2:
  9267.             ordinal = "nd";
  9268.             break;
  9269.         case 3:
  9270.             ordinal = "rd";
  9271.             break;
  9272.         case 4:
  9273.             ordinal = "th";
  9274.             break;
  9275.         case 5:
  9276.             ordinal = "th";
  9277.             break;
  9278.         case 6:
  9279.             ordinal = "th";
  9280.             break;
  9281.         case 7:
  9282.             ordinal = "th";
  9283.             break;
  9284.         case 8:
  9285.             ordinal = "th";
  9286.             break;
  9287.         case 9:
  9288.             ordinal = "th";
  9289.             break;
  9290.         case 0:
  9291.             ordinal = "th";
  9292.             break;
  9293.         }
  9294.         cout << ordinal;
  9295.         cout << " number.";
  9296.         cout << endl;
  9297.         cout << ">> ";
  9298.         cin  >> entry;
  9299.         cin_is_good = cin.good();
  9300.         cin_isnt_good = ! cin_is_good;
  9301.         if( cin_isnt_good )
  9302.         {
  9303.             BadEntry err;
  9304.             throw( err );
  9305.         }
  9306.         outFile << entry;
  9307.         outFile << ' ';
  9308.     }
  9309.     if( j < number_of_entries )
  9310.     {
  9311.         ++j;
  9312.         ones_digit = j % 10;
  9313.         cout << "Please input the ";
  9314.         cout << j;
  9315.         switch( ones_digit )
  9316.         {
  9317.         case 1:
  9318.             ordinal = "st";
  9319.             break;
  9320.         case 2:
  9321.             ordinal = "nd";
  9322.             break;
  9323.         case 3:
  9324.             ordinal = "rd";
  9325.             break;
  9326.         case 4:
  9327.             ordinal = "th";
  9328.             break;
  9329.         case 5:
  9330.             ordinal = "th";
  9331.             break;
  9332.         case 6:
  9333.             ordinal = "th";
  9334.             break;
  9335.         case 7:
  9336.             ordinal = "th";
  9337.             break;
  9338.         case 8:
  9339.             ordinal = "th";
  9340.             break;
  9341.         case 9:
  9342.             ordinal = "th";
  9343.             break;
  9344.         case 0:
  9345.             ordinal = "th";
  9346.             break;
  9347.         }
  9348.         cout << ordinal;
  9349.         cout << " number.";
  9350.         cout << endl;
  9351.         cout << ">> ";
  9352.         cin  >> entry;
  9353.         cin_is_good = cin.good();
  9354.         cin_isnt_good = ! cin_is_good;
  9355.         if( cin_isnt_good )
  9356.         {
  9357.             BadEntry err;
  9358.             throw( err );
  9359.         }
  9360.         outFile << entry;
  9361.         outFile << ' ';
  9362.     }
  9363.     if( j < number_of_entries )
  9364.     {
  9365.         ++j;
  9366.         ones_digit = j % 10;
  9367.         cout << "Please input the ";
  9368.         cout << j;
  9369.         switch( ones_digit )
  9370.         {
  9371.         case 1:
  9372.             ordinal = "st";
  9373.             break;
  9374.         case 2:
  9375.             ordinal = "nd";
  9376.             break;
  9377.         case 3:
  9378.             ordinal = "rd";
  9379.             break;
  9380.         case 4:
  9381.             ordinal = "th";
  9382.             break;
  9383.         case 5:
  9384.             ordinal = "th";
  9385.             break;
  9386.         case 6:
  9387.             ordinal = "th";
  9388.             break;
  9389.         case 7:
  9390.             ordinal = "th";
  9391.             break;
  9392.         case 8:
  9393.             ordinal = "th";
  9394.             break;
  9395.         case 9:
  9396.             ordinal = "th";
  9397.             break;
  9398.         case 0:
  9399.             ordinal = "th";
  9400.             break;
  9401.         }
  9402.         cout << ordinal;
  9403.         cout << " number.";
  9404.         cout << endl;
  9405.         cout << ">> ";
  9406.         cin  >> entry;
  9407.         cin_is_good = cin.good();
  9408.         cin_isnt_good = ! cin_is_good;
  9409.         if( cin_isnt_good )
  9410.         {
  9411.             BadEntry err;
  9412.             throw( err );
  9413.         }
  9414.         outFile << entry;
  9415.         outFile << ' ';
  9416.     }
  9417.     if( j < number_of_entries )
  9418.     {
  9419.         ++j;
  9420.         ones_digit = j % 10;
  9421.         cout << "Please input the ";
  9422.         cout << j;
  9423.         switch( ones_digit )
  9424.         {
  9425.         case 1:
  9426.             ordinal = "st";
  9427.             break;
  9428.         case 2:
  9429.             ordinal = "nd";
  9430.             break;
  9431.         case 3:
  9432.             ordinal = "rd";
  9433.             break;
  9434.         case 4:
  9435.             ordinal = "th";
  9436.             break;
  9437.         case 5:
  9438.             ordinal = "th";
  9439.             break;
  9440.         case 6:
  9441.             ordinal = "th";
  9442.             break;
  9443.         case 7:
  9444.             ordinal = "th";
  9445.             break;
  9446.         case 8:
  9447.             ordinal = "th";
  9448.             break;
  9449.         case 9:
  9450.             ordinal = "th";
  9451.             break;
  9452.         case 0:
  9453.             ordinal = "th";
  9454.             break;
  9455.         }
  9456.         cout << ordinal;
  9457.         cout << " number.";
  9458.         cout << endl;
  9459.         cout << ">> ";
  9460.         cin  >> entry;
  9461.         cin_is_good = cin.good();
  9462.         cin_isnt_good = ! cin_is_good;
  9463.         if( cin_isnt_good )
  9464.         {
  9465.             BadEntry err;
  9466.             throw( err );
  9467.         }
  9468.         outFile << entry;
  9469.         outFile << ' ';
  9470.     }
  9471.     if( j < number_of_entries )
  9472.     {
  9473.         ++j;
  9474.         ones_digit = j % 10;
  9475.         cout << "Please input the ";
  9476.         cout << j;
  9477.         switch( ones_digit )
  9478.         {
  9479.         case 1:
  9480.             ordinal = "st";
  9481.             break;
  9482.         case 2:
  9483.             ordinal = "nd";
  9484.             break;
  9485.         case 3:
  9486.             ordinal = "rd";
  9487.             break;
  9488.         case 4:
  9489.             ordinal = "th";
  9490.             break;
  9491.         case 5:
  9492.             ordinal = "th";
  9493.             break;
  9494.         case 6:
  9495.             ordinal = "th";
  9496.             break;
  9497.         case 7:
  9498.             ordinal = "th";
  9499.             break;
  9500.         case 8:
  9501.             ordinal = "th";
  9502.             break;
  9503.         case 9:
  9504.             ordinal = "th";
  9505.             break;
  9506.         case 0:
  9507.             ordinal = "th";
  9508.             break;
  9509.         }
  9510.         cout << ordinal;
  9511.         cout << " number.";
  9512.         cout << endl;
  9513.         cout << ">> ";
  9514.         cin  >> entry;
  9515.         cin_is_good = cin.good();
  9516.         cin_isnt_good = ! cin_is_good;
  9517.         if( cin_isnt_good )
  9518.         {
  9519.             BadEntry err;
  9520.             throw( err );
  9521.         }
  9522.         outFile << entry;
  9523.         outFile << ' ';
  9524.     }
  9525.     if( j < number_of_entries )
  9526.     {
  9527.         ++j;
  9528.         ones_digit = j % 10;
  9529.         cout << "Please input the ";
  9530.         cout << j;
  9531.         switch( ones_digit )
  9532.         {
  9533.         case 1:
  9534.             ordinal = "st";
  9535.             break;
  9536.         case 2:
  9537.             ordinal = "nd";
  9538.             break;
  9539.         case 3:
  9540.             ordinal = "rd";
  9541.             break;
  9542.         case 4:
  9543.             ordinal = "th";
  9544.             break;
  9545.         case 5:
  9546.             ordinal = "th";
  9547.             break;
  9548.         case 6:
  9549.             ordinal = "th";
  9550.             break;
  9551.         case 7:
  9552.             ordinal = "th";
  9553.             break;
  9554.         case 8:
  9555.             ordinal = "th";
  9556.             break;
  9557.         case 9:
  9558.             ordinal = "th";
  9559.             break;
  9560.         case 0:
  9561.             ordinal = "th";
  9562.             break;
  9563.         }
  9564.         cout << ordinal;
  9565.         cout << " number.";
  9566.         cout << endl;
  9567.         cout << ">> ";
  9568.         cin  >> entry;
  9569.         cin_is_good = cin.good();
  9570.         cin_isnt_good = ! cin_is_good;
  9571.         if( cin_isnt_good )
  9572.         {
  9573.             BadEntry err;
  9574.             throw( err );
  9575.         }
  9576.         outFile << entry;
  9577.         outFile << ' ';
  9578.     }
  9579.     if( j < number_of_entries )
  9580.     {
  9581.         ++j;
  9582.         ones_digit = j % 10;
  9583.         cout << "Please input the ";
  9584.         cout << j;
  9585.         switch( ones_digit )
  9586.         {
  9587.         case 1:
  9588.             ordinal = "st";
  9589.             break;
  9590.         case 2:
  9591.             ordinal = "nd";
  9592.             break;
  9593.         case 3:
  9594.             ordinal = "rd";
  9595.             break;
  9596.         case 4:
  9597.             ordinal = "th";
  9598.             break;
  9599.         case 5:
  9600.             ordinal = "th";
  9601.             break;
  9602.         case 6:
  9603.             ordinal = "th";
  9604.             break;
  9605.         case 7:
  9606.             ordinal = "th";
  9607.             break;
  9608.         case 8:
  9609.             ordinal = "th";
  9610.             break;
  9611.         case 9:
  9612.             ordinal = "th";
  9613.             break;
  9614.         case 0:
  9615.             ordinal = "th";
  9616.             break;
  9617.         }
  9618.         cout << ordinal;
  9619.         cout << " number.";
  9620.         cout << endl;
  9621.         cout << ">> ";
  9622.         cin  >> entry;
  9623.         cin_is_good = cin.good();
  9624.         cin_isnt_good = ! cin_is_good;
  9625.         if( cin_isnt_good )
  9626.         {
  9627.             BadEntry err;
  9628.             throw( err );
  9629.         }
  9630.         outFile << entry;
  9631.         outFile << ' ';
  9632.     }
  9633.     if( j < number_of_entries )
  9634.     {
  9635.         ++j;
  9636.         ones_digit = j % 10;
  9637.         cout << "Please input the ";
  9638.         cout << j;
  9639.         switch( ones_digit )
  9640.         {
  9641.         case 1:
  9642.             ordinal = "st";
  9643.             break;
  9644.         case 2:
  9645.             ordinal = "nd";
  9646.             break;
  9647.         case 3:
  9648.             ordinal = "rd";
  9649.             break;
  9650.         case 4:
  9651.             ordinal = "th";
  9652.             break;
  9653.         case 5:
  9654.             ordinal = "th";
  9655.             break;
  9656.         case 6:
  9657.             ordinal = "th";
  9658.             break;
  9659.         case 7:
  9660.             ordinal = "th";
  9661.             break;
  9662.         case 8:
  9663.             ordinal = "th";
  9664.             break;
  9665.         case 9:
  9666.             ordinal = "th";
  9667.             break;
  9668.         case 0:
  9669.             ordinal = "th";
  9670.             break;
  9671.         }
  9672.         cout << ordinal;
  9673.         cout << " number.";
  9674.         cout << endl;
  9675.         cout << ">> ";
  9676.         cin  >> entry;
  9677.         cin_is_good = cin.good();
  9678.         cin_isnt_good = ! cin_is_good;
  9679.         if( cin_isnt_good )
  9680.         {
  9681.             BadEntry err;
  9682.             throw( err );
  9683.         }
  9684.         outFile << entry;
  9685.         outFile << ' ';
  9686.     }
  9687.     if( j < number_of_entries )
  9688.     {
  9689.         ++j;
  9690.         ones_digit = j % 10;
  9691.         cout << "Please input the ";
  9692.         cout << j;
  9693.         switch( ones_digit )
  9694.         {
  9695.         case 1:
  9696.             ordinal = "st";
  9697.             break;
  9698.         case 2:
  9699.             ordinal = "nd";
  9700.             break;
  9701.         case 3:
  9702.             ordinal = "rd";
  9703.             break;
  9704.         case 4:
  9705.             ordinal = "th";
  9706.             break;
  9707.         case 5:
  9708.             ordinal = "th";
  9709.             break;
  9710.         case 6:
  9711.             ordinal = "th";
  9712.             break;
  9713.         case 7:
  9714.             ordinal = "th";
  9715.             break;
  9716.         case 8:
  9717.             ordinal = "th";
  9718.             break;
  9719.         case 9:
  9720.             ordinal = "th";
  9721.             break;
  9722.         case 0:
  9723.             ordinal = "th";
  9724.             break;
  9725.         }
  9726.         cout << ordinal;
  9727.         cout << " number.";
  9728.         cout << endl;
  9729.         cout << ">> ";
  9730.         cin  >> entry;
  9731.         cin_is_good = cin.good();
  9732.         cin_isnt_good = ! cin_is_good;
  9733.         if( cin_isnt_good )
  9734.         {
  9735.             BadEntry err;
  9736.             throw( err );
  9737.         }
  9738.         outFile << entry;
  9739.         outFile << ' ';
  9740.     }
  9741.     if( j < number_of_entries )
  9742.     {
  9743.         ++j;
  9744.         ones_digit = j % 10;
  9745.         cout << "Please input the ";
  9746.         cout << j;
  9747.         switch( ones_digit )
  9748.         {
  9749.         case 1:
  9750.             ordinal = "st";
  9751.             break;
  9752.         case 2:
  9753.             ordinal = "nd";
  9754.             break;
  9755.         case 3:
  9756.             ordinal = "rd";
  9757.             break;
  9758.         case 4:
  9759.             ordinal = "th";
  9760.             break;
  9761.         case 5:
  9762.             ordinal = "th";
  9763.             break;
  9764.         case 6:
  9765.             ordinal = "th";
  9766.             break;
  9767.         case 7:
  9768.             ordinal = "th";
  9769.             break;
  9770.         case 8:
  9771.             ordinal = "th";
  9772.             break;
  9773.         case 9:
  9774.             ordinal = "th";
  9775.             break;
  9776.         case 0:
  9777.             ordinal = "th";
  9778.             break;
  9779.         }
  9780.         cout << ordinal;
  9781.         cout << " number.";
  9782.         cout << endl;
  9783.         cout << ">> ";
  9784.         cin  >> entry;
  9785.         cin_is_good = cin.good();
  9786.         cin_isnt_good = ! cin_is_good;
  9787.         if( cin_isnt_good )
  9788.         {
  9789.             BadEntry err;
  9790.             throw( err );
  9791.         }
  9792.         outFile << entry;
  9793.         outFile << ' ';
  9794.     }
  9795.     if( j < number_of_entries )
  9796.     {
  9797.         ++j;
  9798.         ones_digit = j % 10;
  9799.         cout << "Please input the ";
  9800.         cout << j;
  9801.         switch( ones_digit )
  9802.         {
  9803.         case 1:
  9804.             ordinal = "st";
  9805.             break;
  9806.         case 2:
  9807.             ordinal = "nd";
  9808.             break;
  9809.         case 3:
  9810.             ordinal = "rd";
  9811.             break;
  9812.         case 4:
  9813.             ordinal = "th";
  9814.             break;
  9815.         case 5:
  9816.             ordinal = "th";
  9817.             break;
  9818.         case 6:
  9819.             ordinal = "th";
  9820.             break;
  9821.         case 7:
  9822.             ordinal = "th";
  9823.             break;
  9824.         case 8:
  9825.             ordinal = "th";
  9826.             break;
  9827.         case 9:
  9828.             ordinal = "th";
  9829.             break;
  9830.         case 0:
  9831.             ordinal = "th";
  9832.             break;
  9833.         }
  9834.         cout << ordinal;
  9835.         cout << " number.";
  9836.         cout << endl;
  9837.         cout << ">> ";
  9838.         cin  >> entry;
  9839.         cin_is_good = cin.good();
  9840.         cin_isnt_good = ! cin_is_good;
  9841.         if( cin_isnt_good )
  9842.         {
  9843.             BadEntry err;
  9844.             throw( err );
  9845.         }
  9846.         outFile << entry;
  9847.         outFile << ' ';
  9848.     }
  9849.     if( j < number_of_entries )
  9850.     {
  9851.         ++j;
  9852.         ones_digit = j % 10;
  9853.         cout << "Please input the ";
  9854.         cout << j;
  9855.         switch( ones_digit )
  9856.         {
  9857.         case 1:
  9858.             ordinal = "st";
  9859.             break;
  9860.         case 2:
  9861.             ordinal = "nd";
  9862.             break;
  9863.         case 3:
  9864.             ordinal = "rd";
  9865.             break;
  9866.         case 4:
  9867.             ordinal = "th";
  9868.             break;
  9869.         case 5:
  9870.             ordinal = "th";
  9871.             break;
  9872.         case 6:
  9873.             ordinal = "th";
  9874.             break;
  9875.         case 7:
  9876.             ordinal = "th";
  9877.             break;
  9878.         case 8:
  9879.             ordinal = "th";
  9880.             break;
  9881.         case 9:
  9882.             ordinal = "th";
  9883.             break;
  9884.         case 0:
  9885.             ordinal = "th";
  9886.             break;
  9887.         }
  9888.         cout << ordinal;
  9889.         cout << " number.";
  9890.         cout << endl;
  9891.         cout << ">> ";
  9892.         cin  >> entry;
  9893.         cin_is_good = cin.good();
  9894.         cin_isnt_good = ! cin_is_good;
  9895.         if( cin_isnt_good )
  9896.         {
  9897.             BadEntry err;
  9898.             throw( err );
  9899.         }
  9900.         outFile << entry;
  9901.         outFile << ' ';
  9902.     }
  9903.     if( j < number_of_entries )
  9904.     {
  9905.         ++j;
  9906.         ones_digit = j % 10;
  9907.         cout << "Please input the ";
  9908.         cout << j;
  9909.         switch( ones_digit )
  9910.         {
  9911.         case 1:
  9912.             ordinal = "st";
  9913.             break;
  9914.         case 2:
  9915.             ordinal = "nd";
  9916.             break;
  9917.         case 3:
  9918.             ordinal = "rd";
  9919.             break;
  9920.         case 4:
  9921.             ordinal = "th";
  9922.             break;
  9923.         case 5:
  9924.             ordinal = "th";
  9925.             break;
  9926.         case 6:
  9927.             ordinal = "th";
  9928.             break;
  9929.         case 7:
  9930.             ordinal = "th";
  9931.             break;
  9932.         case 8:
  9933.             ordinal = "th";
  9934.             break;
  9935.         case 9:
  9936.             ordinal = "th";
  9937.             break;
  9938.         case 0:
  9939.             ordinal = "th";
  9940.             break;
  9941.         }
  9942.         cout << ordinal;
  9943.         cout << " number.";
  9944.         cout << endl;
  9945.         cout << ">> ";
  9946.         cin  >> entry;
  9947.         cin_is_good = cin.good();
  9948.         cin_isnt_good = ! cin_is_good;
  9949.         if( cin_isnt_good )
  9950.         {
  9951.             BadEntry err;
  9952.             throw( err );
  9953.         }
  9954.         outFile << entry;
  9955.         outFile << ' ';
  9956.     }
  9957.     if( j < number_of_entries )
  9958.     {
  9959.         ++j;
  9960.         ones_digit = j % 10;
  9961.         cout << "Please input the ";
  9962.         cout << j;
  9963.         switch( ones_digit )
  9964.         {
  9965.         case 1:
  9966.             ordinal = "st";
  9967.             break;
  9968.         case 2:
  9969.             ordinal = "nd";
  9970.             break;
  9971.         case 3:
  9972.             ordinal = "rd";
  9973.             break;
  9974.         case 4:
  9975.             ordinal = "th";
  9976.             break;
  9977.         case 5:
  9978.             ordinal = "th";
  9979.             break;
  9980.         case 6:
  9981.             ordinal = "th";
  9982.             break;
  9983.         case 7:
  9984.             ordinal = "th";
  9985.             break;
  9986.         case 8:
  9987.             ordinal = "th";
  9988.             break;
  9989.         case 9:
  9990.             ordinal = "th";
  9991.             break;
  9992.         case 0:
  9993.             ordinal = "th";
  9994.             break;
  9995.         }
  9996.         cout << ordinal;
  9997.         cout << " number.";
  9998.         cout << endl;
  9999.         cout << ">> ";
  10000.         cin  >> entry;
  10001.         cin_is_good = cin.good();
  10002.         cin_isnt_good = ! cin_is_good;
  10003.         if( cin_isnt_good )
  10004.         {
  10005.             BadEntry err;
  10006.             throw( err );
  10007.         }
  10008.         outFile << entry;
  10009.         outFile << ' ';
  10010.     }
  10011.     if( j < number_of_entries )
  10012.     {
  10013.         ++j;
  10014.         ones_digit = j % 10;
  10015.         cout << "Please input the ";
  10016.         cout << j;
  10017.         switch( ones_digit )
  10018.         {
  10019.         case 1:
  10020.             ordinal = "st";
  10021.             break;
  10022.         case 2:
  10023.             ordinal = "nd";
  10024.             break;
  10025.         case 3:
  10026.             ordinal = "rd";
  10027.             break;
  10028.         case 4:
  10029.             ordinal = "th";
  10030.             break;
  10031.         case 5:
  10032.             ordinal = "th";
  10033.             break;
  10034.         case 6:
  10035.             ordinal = "th";
  10036.             break;
  10037.         case 7:
  10038.             ordinal = "th";
  10039.             break;
  10040.         case 8:
  10041.             ordinal = "th";
  10042.             break;
  10043.         case 9:
  10044.             ordinal = "th";
  10045.             break;
  10046.         case 0:
  10047.             ordinal = "th";
  10048.             break;
  10049.         }
  10050.         cout << ordinal;
  10051.         cout << " number.";
  10052.         cout << endl;
  10053.         cout << ">> ";
  10054.         cin  >> entry;
  10055.         cin_is_good = cin.good();
  10056.         cin_isnt_good = ! cin_is_good;
  10057.         if( cin_isnt_good )
  10058.         {
  10059.             BadEntry err;
  10060.             throw( err );
  10061.         }
  10062.         outFile << entry;
  10063.         outFile << ' ';
  10064.     }
  10065.     if( j < number_of_entries )
  10066.     {
  10067.         ++j;
  10068.         ones_digit = j % 10;
  10069.         cout << "Please input the ";
  10070.         cout << j;
  10071.         switch( ones_digit )
  10072.         {
  10073.         case 1:
  10074.             ordinal = "st";
  10075.             break;
  10076.         case 2:
  10077.             ordinal = "nd";
  10078.             break;
  10079.         case 3:
  10080.             ordinal = "rd";
  10081.             break;
  10082.         case 4:
  10083.             ordinal = "th";
  10084.             break;
  10085.         case 5:
  10086.             ordinal = "th";
  10087.             break;
  10088.         case 6:
  10089.             ordinal = "th";
  10090.             break;
  10091.         case 7:
  10092.             ordinal = "th";
  10093.             break;
  10094.         case 8:
  10095.             ordinal = "th";
  10096.             break;
  10097.         case 9:
  10098.             ordinal = "th";
  10099.             break;
  10100.         case 0:
  10101.             ordinal = "th";
  10102.             break;
  10103.         }
  10104.         cout << ordinal;
  10105.         cout << " number.";
  10106.         cout << endl;
  10107.         cout << ">> ";
  10108.         cin  >> entry;
  10109.         cin_is_good = cin.good();
  10110.         cin_isnt_good = ! cin_is_good;
  10111.         if( cin_isnt_good )
  10112.         {
  10113.             BadEntry err;
  10114.             throw( err );
  10115.         }
  10116.         outFile << entry;
  10117.         outFile << ' ';
  10118.     }
  10119.     if( j < number_of_entries )
  10120.     {
  10121.         ++j;
  10122.         ones_digit = j % 10;
  10123.         cout << "Please input the ";
  10124.         cout << j;
  10125.         switch( ones_digit )
  10126.         {
  10127.         case 1:
  10128.             ordinal = "st";
  10129.             break;
  10130.         case 2:
  10131.             ordinal = "nd";
  10132.             break;
  10133.         case 3:
  10134.             ordinal = "rd";
  10135.             break;
  10136.         case 4:
  10137.             ordinal = "th";
  10138.             break;
  10139.         case 5:
  10140.             ordinal = "th";
  10141.             break;
  10142.         case 6:
  10143.             ordinal = "th";
  10144.             break;
  10145.         case 7:
  10146.             ordinal = "th";
  10147.             break;
  10148.         case 8:
  10149.             ordinal = "th";
  10150.             break;
  10151.         case 9:
  10152.             ordinal = "th";
  10153.             break;
  10154.         case 0:
  10155.             ordinal = "th";
  10156.             break;
  10157.         }
  10158.         cout << ordinal;
  10159.         cout << " number.";
  10160.         cout << endl;
  10161.         cout << ">> ";
  10162.         cin  >> entry;
  10163.         cin_is_good = cin.good();
  10164.         cin_isnt_good = ! cin_is_good;
  10165.         if( cin_isnt_good )
  10166.         {
  10167.             BadEntry err;
  10168.             throw( err );
  10169.         }
  10170.         outFile << entry;
  10171.         outFile << ' ';
  10172.     }
  10173.     if( j < number_of_entries )
  10174.     {
  10175.         ++j;
  10176.         ones_digit = j % 10;
  10177.         cout << "Please input the ";
  10178.         cout << j;
  10179.         switch( ones_digit )
  10180.         {
  10181.         case 1:
  10182.             ordinal = "st";
  10183.             break;
  10184.         case 2:
  10185.             ordinal = "nd";
  10186.             break;
  10187.         case 3:
  10188.             ordinal = "rd";
  10189.             break;
  10190.         case 4:
  10191.             ordinal = "th";
  10192.             break;
  10193.         case 5:
  10194.             ordinal = "th";
  10195.             break;
  10196.         case 6:
  10197.             ordinal = "th";
  10198.             break;
  10199.         case 7:
  10200.             ordinal = "th";
  10201.             break;
  10202.         case 8:
  10203.             ordinal = "th";
  10204.             break;
  10205.         case 9:
  10206.             ordinal = "th";
  10207.             break;
  10208.         case 0:
  10209.             ordinal = "th";
  10210.             break;
  10211.         }
  10212.         cout << ordinal;
  10213.         cout << " number.";
  10214.         cout << endl;
  10215.         cout << ">> ";
  10216.         cin  >> entry;
  10217.         cin_is_good = cin.good();
  10218.         cin_isnt_good = ! cin_is_good;
  10219.         if( cin_isnt_good )
  10220.         {
  10221.             BadEntry err;
  10222.             throw( err );
  10223.         }
  10224.         outFile << entry;
  10225.         outFile << ' ';
  10226.     }
  10227.     if( j < number_of_entries )
  10228.     {
  10229.         ++j;
  10230.         ones_digit = j % 10;
  10231.         cout << "Please input the ";
  10232.         cout << j;
  10233.         switch( ones_digit )
  10234.         {
  10235.         case 1:
  10236.             ordinal = "st";
  10237.             break;
  10238.         case 2:
  10239.             ordinal = "nd";
  10240.             break;
  10241.         case 3:
  10242.             ordinal = "rd";
  10243.             break;
  10244.         case 4:
  10245.             ordinal = "th";
  10246.             break;
  10247.         case 5:
  10248.             ordinal = "th";
  10249.             break;
  10250.         case 6:
  10251.             ordinal = "th";
  10252.             break;
  10253.         case 7:
  10254.             ordinal = "th";
  10255.             break;
  10256.         case 8:
  10257.             ordinal = "th";
  10258.             break;
  10259.         case 9:
  10260.             ordinal = "th";
  10261.             break;
  10262.         case 0:
  10263.             ordinal = "th";
  10264.             break;
  10265.         }
  10266.         cout << ordinal;
  10267.         cout << " number.";
  10268.         cout << endl;
  10269.         cout << ">> ";
  10270.         cin  >> entry;
  10271.         cin_is_good = cin.good();
  10272.         cin_isnt_good = ! cin_is_good;
  10273.         if( cin_isnt_good )
  10274.         {
  10275.             BadEntry err;
  10276.             throw( err );
  10277.         }
  10278.         outFile << entry;
  10279.         outFile << ' ';
  10280.     }
  10281.     if( j < number_of_entries )
  10282.     {
  10283.         ++j;
  10284.         ones_digit = j % 10;
  10285.         cout << "Please input the ";
  10286.         cout << j;
  10287.         switch( ones_digit )
  10288.         {
  10289.         case 1:
  10290.             ordinal = "st";
  10291.             break;
  10292.         case 2:
  10293.             ordinal = "nd";
  10294.             break;
  10295.         case 3:
  10296.             ordinal = "rd";
  10297.             break;
  10298.         case 4:
  10299.             ordinal = "th";
  10300.             break;
  10301.         case 5:
  10302.             ordinal = "th";
  10303.             break;
  10304.         case 6:
  10305.             ordinal = "th";
  10306.             break;
  10307.         case 7:
  10308.             ordinal = "th";
  10309.             break;
  10310.         case 8:
  10311.             ordinal = "th";
  10312.             break;
  10313.         case 9:
  10314.             ordinal = "th";
  10315.             break;
  10316.         case 0:
  10317.             ordinal = "th";
  10318.             break;
  10319.         }
  10320.         cout << ordinal;
  10321.         cout << " number.";
  10322.         cout << endl;
  10323.         cout << ">> ";
  10324.         cin  >> entry;
  10325.         cin_is_good = cin.good();
  10326.         cin_isnt_good = ! cin_is_good;
  10327.         if( cin_isnt_good )
  10328.         {
  10329.             BadEntry err;
  10330.             throw( err );
  10331.         }
  10332.         outFile << entry;
  10333.         outFile << ' ';
  10334.     }
  10335.     if( j < number_of_entries )
  10336.     {
  10337.         ++j;
  10338.         ones_digit = j % 10;
  10339.         cout << "Please input the ";
  10340.         cout << j;
  10341.         switch( ones_digit )
  10342.         {
  10343.         case 1:
  10344.             ordinal = "st";
  10345.             break;
  10346.         case 2:
  10347.             ordinal = "nd";
  10348.             break;
  10349.         case 3:
  10350.             ordinal = "rd";
  10351.             break;
  10352.         case 4:
  10353.             ordinal = "th";
  10354.             break;
  10355.         case 5:
  10356.             ordinal = "th";
  10357.             break;
  10358.         case 6:
  10359.             ordinal = "th";
  10360.             break;
  10361.         case 7:
  10362.             ordinal = "th";
  10363.             break;
  10364.         case 8:
  10365.             ordinal = "th";
  10366.             break;
  10367.         case 9:
  10368.             ordinal = "th";
  10369.             break;
  10370.         case 0:
  10371.             ordinal = "th";
  10372.             break;
  10373.         }
  10374.         cout << ordinal;
  10375.         cout << " number.";
  10376.         cout << endl;
  10377.         cout << ">> ";
  10378.         cin  >> entry;
  10379.         cin_is_good = cin.good();
  10380.         cin_isnt_good = ! cin_is_good;
  10381.         if( cin_isnt_good )
  10382.         {
  10383.             BadEntry err;
  10384.             throw( err );
  10385.         }
  10386.         outFile << entry;
  10387.         outFile << ' ';
  10388.     }
  10389.     if( j < number_of_entries )
  10390.     {
  10391.         ++j;
  10392.         ones_digit = j % 10;
  10393.         cout << "Please input the ";
  10394.         cout << j;
  10395.         switch( ones_digit )
  10396.         {
  10397.         case 1:
  10398.             ordinal = "st";
  10399.             break;
  10400.         case 2:
  10401.             ordinal = "nd";
  10402.             break;
  10403.         case 3:
  10404.             ordinal = "rd";
  10405.             break;
  10406.         case 4:
  10407.             ordinal = "th";
  10408.             break;
  10409.         case 5:
  10410.             ordinal = "th";
  10411.             break;
  10412.         case 6:
  10413.             ordinal = "th";
  10414.             break;
  10415.         case 7:
  10416.             ordinal = "th";
  10417.             break;
  10418.         case 8:
  10419.             ordinal = "th";
  10420.             break;
  10421.         case 9:
  10422.             ordinal = "th";
  10423.             break;
  10424.         case 0:
  10425.             ordinal = "th";
  10426.             break;
  10427.         }
  10428.         cout << ordinal;
  10429.         cout << " number.";
  10430.         cout << endl;
  10431.         cout << ">> ";
  10432.         cin  >> entry;
  10433.         cin_is_good = cin.good();
  10434.         cin_isnt_good = ! cin_is_good;
  10435.         if( cin_isnt_good )
  10436.         {
  10437.             BadEntry err;
  10438.             throw( err );
  10439.         }
  10440.         outFile << entry;
  10441.         outFile << ' ';
  10442.     }
  10443.     if( j < number_of_entries )
  10444.     {
  10445.         ++j;
  10446.         ones_digit = j % 10;
  10447.         cout << "Please input the ";
  10448.         cout << j;
  10449.         switch( ones_digit )
  10450.         {
  10451.         case 1:
  10452.             ordinal = "st";
  10453.             break;
  10454.         case 2:
  10455.             ordinal = "nd";
  10456.             break;
  10457.         case 3:
  10458.             ordinal = "rd";
  10459.             break;
  10460.         case 4:
  10461.             ordinal = "th";
  10462.             break;
  10463.         case 5:
  10464.             ordinal = "th";
  10465.             break;
  10466.         case 6:
  10467.             ordinal = "th";
  10468.             break;
  10469.         case 7:
  10470.             ordinal = "th";
  10471.             break;
  10472.         case 8:
  10473.             ordinal = "th";
  10474.             break;
  10475.         case 9:
  10476.             ordinal = "th";
  10477.             break;
  10478.         case 0:
  10479.             ordinal = "th";
  10480.             break;
  10481.         }
  10482.         cout << ordinal;
  10483.         cout << " number.";
  10484.         cout << endl;
  10485.         cout << ">> ";
  10486.         cin  >> entry;
  10487.         cin_is_good = cin.good();
  10488.         cin_isnt_good = ! cin_is_good;
  10489.         if( cin_isnt_good )
  10490.         {
  10491.             BadEntry err;
  10492.             throw( err );
  10493.         }
  10494.         outFile << entry;
  10495.         outFile << ' ';
  10496.     }
  10497.     if( j < number_of_entries )
  10498.     {
  10499.         ++j;
  10500.         ones_digit = j % 10;
  10501.         cout << "Please input the ";
  10502.         cout << j;
  10503.         switch( ones_digit )
  10504.         {
  10505.         case 1:
  10506.             ordinal = "st";
  10507.             break;
  10508.         case 2:
  10509.             ordinal = "nd";
  10510.             break;
  10511.         case 3:
  10512.             ordinal = "rd";
  10513.             break;
  10514.         case 4:
  10515.             ordinal = "th";
  10516.             break;
  10517.         case 5:
  10518.             ordinal = "th";
  10519.             break;
  10520.         case 6:
  10521.             ordinal = "th";
  10522.             break;
  10523.         case 7:
  10524.             ordinal = "th";
  10525.             break;
  10526.         case 8:
  10527.             ordinal = "th";
  10528.             break;
  10529.         case 9:
  10530.             ordinal = "th";
  10531.             break;
  10532.         case 0:
  10533.             ordinal = "th";
  10534.             break;
  10535.         }
  10536.         cout << ordinal;
  10537.         cout << " number.";
  10538.         cout << endl;
  10539.         cout << ">> ";
  10540.         cin  >> entry;
  10541.         cin_is_good = cin.good();
  10542.         cin_isnt_good = ! cin_is_good;
  10543.         if( cin_isnt_good )
  10544.         {
  10545.             BadEntry err;
  10546.             throw( err );
  10547.         }
  10548.         outFile << entry;
  10549.         outFile << ' ';
  10550.     }
  10551.     if( j < number_of_entries )
  10552.     {
  10553.         ++j;
  10554.         ones_digit = j % 10;
  10555.         cout << "Please input the ";
  10556.         cout << j;
  10557.         switch( ones_digit )
  10558.         {
  10559.         case 1:
  10560.             ordinal = "st";
  10561.             break;
  10562.         case 2:
  10563.             ordinal = "nd";
  10564.             break;
  10565.         case 3:
  10566.             ordinal = "rd";
  10567.             break;
  10568.         case 4:
  10569.             ordinal = "th";
  10570.             break;
  10571.         case 5:
  10572.             ordinal = "th";
  10573.             break;
  10574.         case 6:
  10575.             ordinal = "th";
  10576.             break;
  10577.         case 7:
  10578.             ordinal = "th";
  10579.             break;
  10580.         case 8:
  10581.             ordinal = "th";
  10582.             break;
  10583.         case 9:
  10584.             ordinal = "th";
  10585.             break;
  10586.         case 0:
  10587.             ordinal = "th";
  10588.             break;
  10589.         }
  10590.         cout << ordinal;
  10591.         cout << " number.";
  10592.         cout << endl;
  10593.         cout << ">> ";
  10594.         cin  >> entry;
  10595.         cin_is_good = cin.good();
  10596.         cin_isnt_good = ! cin_is_good;
  10597.         if( cin_isnt_good )
  10598.         {
  10599.             BadEntry err;
  10600.             throw( err );
  10601.         }
  10602.         outFile << entry;
  10603.         outFile << ' ';
  10604.     }
  10605.     if( j < number_of_entries )
  10606.     {
  10607.         ++j;
  10608.         ones_digit = j % 10;
  10609.         cout << "Please input the ";
  10610.         cout << j;
  10611.         switch( ones_digit )
  10612.         {
  10613.         case 1:
  10614.             ordinal = "st";
  10615.             break;
  10616.         case 2:
  10617.             ordinal = "nd";
  10618.             break;
  10619.         case 3:
  10620.             ordinal = "rd";
  10621.             break;
  10622.         case 4:
  10623.             ordinal = "th";
  10624.             break;
  10625.         case 5:
  10626.             ordinal = "th";
  10627.             break;
  10628.         case 6:
  10629.             ordinal = "th";
  10630.             break;
  10631.         case 7:
  10632.             ordinal = "th";
  10633.             break;
  10634.         case 8:
  10635.             ordinal = "th";
  10636.             break;
  10637.         case 9:
  10638.             ordinal = "th";
  10639.             break;
  10640.         case 0:
  10641.             ordinal = "th";
  10642.             break;
  10643.         }
  10644.         cout << ordinal;
  10645.         cout << " number.";
  10646.         cout << endl;
  10647.         cout << ">> ";
  10648.         cin  >> entry;
  10649.         cin_is_good = cin.good();
  10650.         cin_isnt_good = ! cin_is_good;
  10651.         if( cin_isnt_good )
  10652.         {
  10653.             BadEntry err;
  10654.             throw( err );
  10655.         }
  10656.         outFile << entry;
  10657.         outFile << ' ';
  10658.     }
  10659.     if( j < number_of_entries )
  10660.     {
  10661.         ++j;
  10662.         ones_digit = j % 10;
  10663.         cout << "Please input the ";
  10664.         cout << j;
  10665.         switch( ones_digit )
  10666.         {
  10667.         case 1:
  10668.             ordinal = "st";
  10669.             break;
  10670.         case 2:
  10671.             ordinal = "nd";
  10672.             break;
  10673.         case 3:
  10674.             ordinal = "rd";
  10675.             break;
  10676.         case 4:
  10677.             ordinal = "th";
  10678.             break;
  10679.         case 5:
  10680.             ordinal = "th";
  10681.             break;
  10682.         case 6:
  10683.             ordinal = "th";
  10684.             break;
  10685.         case 7:
  10686.             ordinal = "th";
  10687.             break;
  10688.         case 8:
  10689.             ordinal = "th";
  10690.             break;
  10691.         case 9:
  10692.             ordinal = "th";
  10693.             break;
  10694.         case 0:
  10695.             ordinal = "th";
  10696.             break;
  10697.         }
  10698.         cout << ordinal;
  10699.         cout << " number.";
  10700.         cout << endl;
  10701.         cout << ">> ";
  10702.         cin  >> entry;
  10703.         cin_is_good = cin.good();
  10704.         cin_isnt_good = ! cin_is_good;
  10705.         if( cin_isnt_good )
  10706.         {
  10707.             BadEntry err;
  10708.             throw( err );
  10709.         }
  10710.         outFile << entry;
  10711.         outFile << ' ';
  10712.     }
  10713.     if( j < number_of_entries )
  10714.     {
  10715.         ++j;
  10716.         ones_digit = j % 10;
  10717.         cout << "Please input the ";
  10718.         cout << j;
  10719.         switch( ones_digit )
  10720.         {
  10721.         case 1:
  10722.             ordinal = "st";
  10723.             break;
  10724.         case 2:
  10725.             ordinal = "nd";
  10726.             break;
  10727.         case 3:
  10728.             ordinal = "rd";
  10729.             break;
  10730.         case 4:
  10731.             ordinal = "th";
  10732.             break;
  10733.         case 5:
  10734.             ordinal = "th";
  10735.             break;
  10736.         case 6:
  10737.             ordinal = "th";
  10738.             break;
  10739.         case 7:
  10740.             ordinal = "th";
  10741.             break;
  10742.         case 8:
  10743.             ordinal = "th";
  10744.             break;
  10745.         case 9:
  10746.             ordinal = "th";
  10747.             break;
  10748.         case 0:
  10749.             ordinal = "th";
  10750.             break;
  10751.         }
  10752.         cout << ordinal;
  10753.         cout << " number.";
  10754.         cout << endl;
  10755.         cout << ">> ";
  10756.         cin  >> entry;
  10757.         cin_is_good = cin.good();
  10758.         cin_isnt_good = ! cin_is_good;
  10759.         if( cin_isnt_good )
  10760.         {
  10761.             BadEntry err;
  10762.             throw( err );
  10763.         }
  10764.         outFile << entry;
  10765.         outFile << ' ';
  10766.     }
  10767.     if( j < number_of_entries )
  10768.     {
  10769.         ++j;
  10770.         ones_digit = j % 10;
  10771.         cout << "Please input the ";
  10772.         cout << j;
  10773.         switch( ones_digit )
  10774.         {
  10775.         case 1:
  10776.             ordinal = "st";
  10777.             break;
  10778.         case 2:
  10779.             ordinal = "nd";
  10780.             break;
  10781.         case 3:
  10782.             ordinal = "rd";
  10783.             break;
  10784.         case 4:
  10785.             ordinal = "th";
  10786.             break;
  10787.         case 5:
  10788.             ordinal = "th";
  10789.             break;
  10790.         case 6:
  10791.             ordinal = "th";
  10792.             break;
  10793.         case 7:
  10794.             ordinal = "th";
  10795.             break;
  10796.         case 8:
  10797.             ordinal = "th";
  10798.             break;
  10799.         case 9:
  10800.             ordinal = "th";
  10801.             break;
  10802.         case 0:
  10803.             ordinal = "th";
  10804.             break;
  10805.         }
  10806.         cout << ordinal;
  10807.         cout << " number.";
  10808.         cout << endl;
  10809.         cout << ">> ";
  10810.         cin  >> entry;
  10811.         cin_is_good = cin.good();
  10812.         cin_isnt_good = ! cin_is_good;
  10813.         if( cin_isnt_good )
  10814.         {
  10815.             BadEntry err;
  10816.             throw( err );
  10817.         }
  10818.         outFile << entry;
  10819.         outFile << ' ';
  10820.     }
  10821.     if( j < number_of_entries )
  10822.     {
  10823.         ++j;
  10824.         ones_digit = j % 10;
  10825.         cout << "Please input the ";
  10826.         cout << j;
  10827.         switch( ones_digit )
  10828.         {
  10829.         case 1:
  10830.             ordinal = "st";
  10831.             break;
  10832.         case 2:
  10833.             ordinal = "nd";
  10834.             break;
  10835.         case 3:
  10836.             ordinal = "rd";
  10837.             break;
  10838.         case 4:
  10839.             ordinal = "th";
  10840.             break;
  10841.         case 5:
  10842.             ordinal = "th";
  10843.             break;
  10844.         case 6:
  10845.             ordinal = "th";
  10846.             break;
  10847.         case 7:
  10848.             ordinal = "th";
  10849.             break;
  10850.         case 8:
  10851.             ordinal = "th";
  10852.             break;
  10853.         case 9:
  10854.             ordinal = "th";
  10855.             break;
  10856.         case 0:
  10857.             ordinal = "th";
  10858.             break;
  10859.         }
  10860.         cout << ordinal;
  10861.         cout << " number.";
  10862.         cout << endl;
  10863.         cout << ">> ";
  10864.         cin  >> entry;
  10865.         cin_is_good = cin.good();
  10866.         cin_isnt_good = ! cin_is_good;
  10867.         if( cin_isnt_good )
  10868.         {
  10869.             BadEntry err;
  10870.             throw( err );
  10871.         }
  10872.         outFile << entry;
  10873.         outFile << ' ';
  10874.     }
  10875.     if( j < number_of_entries )
  10876.     {
  10877.         ++j;
  10878.         ones_digit = j % 10;
  10879.         cout << "Please input the ";
  10880.         cout << j;
  10881.         switch( ones_digit )
  10882.         {
  10883.         case 1:
  10884.             ordinal = "st";
  10885.             break;
  10886.         case 2:
  10887.             ordinal = "nd";
  10888.             break;
  10889.         case 3:
  10890.             ordinal = "rd";
  10891.             break;
  10892.         case 4:
  10893.             ordinal = "th";
  10894.             break;
  10895.         case 5:
  10896.             ordinal = "th";
  10897.             break;
  10898.         case 6:
  10899.             ordinal = "th";
  10900.             break;
  10901.         case 7:
  10902.             ordinal = "th";
  10903.             break;
  10904.         case 8:
  10905.             ordinal = "th";
  10906.             break;
  10907.         case 9:
  10908.             ordinal = "th";
  10909.             break;
  10910.         case 0:
  10911.             ordinal = "th";
  10912.             break;
  10913.         }
  10914.         cout << ordinal;
  10915.         cout << " number.";
  10916.         cout << endl;
  10917.         cout << ">> ";
  10918.         cin  >> entry;
  10919.         cin_is_good = cin.good();
  10920.         cin_isnt_good = ! cin_is_good;
  10921.         if( cin_isnt_good )
  10922.         {
  10923.             BadEntry err;
  10924.             throw( err );
  10925.         }
  10926.         outFile << entry;
  10927.         outFile << ' ';
  10928.     }
  10929.     if( j < number_of_entries )
  10930.     {
  10931.         ++j;
  10932.         ones_digit = j % 10;
  10933.         cout << "Please input the ";
  10934.         cout << j;
  10935.         switch( ones_digit )
  10936.         {
  10937.         case 1:
  10938.             ordinal = "st";
  10939.             break;
  10940.         case 2:
  10941.             ordinal = "nd";
  10942.             break;
  10943.         case 3:
  10944.             ordinal = "rd";
  10945.             break;
  10946.         case 4:
  10947.             ordinal = "th";
  10948.             break;
  10949.         case 5:
  10950.             ordinal = "th";
  10951.             break;
  10952.         case 6:
  10953.             ordinal = "th";
  10954.             break;
  10955.         case 7:
  10956.             ordinal = "th";
  10957.             break;
  10958.         case 8:
  10959.             ordinal = "th";
  10960.             break;
  10961.         case 9:
  10962.             ordinal = "th";
  10963.             break;
  10964.         case 0:
  10965.             ordinal = "th";
  10966.             break;
  10967.         }
  10968.         cout << ordinal;
  10969.         cout << " number.";
  10970.         cout << endl;
  10971.         cout << ">> ";
  10972.         cin  >> entry;
  10973.         cin_is_good = cin.good();
  10974.         cin_isnt_good = ! cin_is_good;
  10975.         if( cin_isnt_good )
  10976.         {
  10977.             BadEntry err;
  10978.             throw( err );
  10979.         }
  10980.         outFile << entry;
  10981.         outFile << ' ';
  10982.     }
  10983.     if( j < number_of_entries )
  10984.     {
  10985.         ++j;
  10986.         ones_digit = j % 10;
  10987.         cout << "Please input the ";
  10988.         cout << j;
  10989.         switch( ones_digit )
  10990.         {
  10991.         case 1:
  10992.             ordinal = "st";
  10993.             break;
  10994.         case 2:
  10995.             ordinal = "nd";
  10996.             break;
  10997.         case 3:
  10998.             ordinal = "rd";
  10999.             break;
  11000.         case 4:
  11001.             ordinal = "th";
  11002.             break;
  11003.         case 5:
  11004.             ordinal = "th";
  11005.             break;
  11006.         case 6:
  11007.             ordinal = "th";
  11008.             break;
  11009.         case 7:
  11010.             ordinal = "th";
  11011.             break;
  11012.         case 8:
  11013.             ordinal = "th";
  11014.             break;
  11015.         case 9:
  11016.             ordinal = "th";
  11017.             break;
  11018.         case 0:
  11019.             ordinal = "th";
  11020.             break;
  11021.         }
  11022.         cout << ordinal;
  11023.         cout << " number.";
  11024.         cout << endl;
  11025.         cout << ">> ";
  11026.         cin  >> entry;
  11027.         cin_is_good = cin.good();
  11028.         cin_isnt_good = ! cin_is_good;
  11029.         if( cin_isnt_good )
  11030.         {
  11031.             BadEntry err;
  11032.             throw( err );
  11033.         }
  11034.         outFile << entry;
  11035.         outFile << ' ';
  11036.     }
  11037.     if( j < number_of_entries )
  11038.     {
  11039.         ++j;
  11040.         ones_digit = j % 10;
  11041.         cout << "Please input the ";
  11042.         cout << j;
  11043.         switch( ones_digit )
  11044.         {
  11045.         case 1:
  11046.             ordinal = "st";
  11047.             break;
  11048.         case 2:
  11049.             ordinal = "nd";
  11050.             break;
  11051.         case 3:
  11052.             ordinal = "rd";
  11053.             break;
  11054.         case 4:
  11055.             ordinal = "th";
  11056.             break;
  11057.         case 5:
  11058.             ordinal = "th";
  11059.             break;
  11060.         case 6:
  11061.             ordinal = "th";
  11062.             break;
  11063.         case 7:
  11064.             ordinal = "th";
  11065.             break;
  11066.         case 8:
  11067.             ordinal = "th";
  11068.             break;
  11069.         case 9:
  11070.             ordinal = "th";
  11071.             break;
  11072.         case 0:
  11073.             ordinal = "th";
  11074.             break;
  11075.         }
  11076.         cout << ordinal;
  11077.         cout << " number.";
  11078.         cout << endl;
  11079.         cout << ">> ";
  11080.         cin  >> entry;
  11081.         cin_is_good = cin.good();
  11082.         cin_isnt_good = ! cin_is_good;
  11083.         if( cin_isnt_good )
  11084.         {
  11085.             BadEntry err;
  11086.             throw( err );
  11087.         }
  11088.         outFile << entry;
  11089.         outFile << ' ';
  11090.     }
  11091.     if( j < number_of_entries )
  11092.     {
  11093.         ++j;
  11094.         ones_digit = j % 10;
  11095.         cout << "Please input the ";
  11096.         cout << j;
  11097.         switch( ones_digit )
  11098.         {
  11099.         case 1:
  11100.             ordinal = "st";
  11101.             break;
  11102.         case 2:
  11103.             ordinal = "nd";
  11104.             break;
  11105.         case 3:
  11106.             ordinal = "rd";
  11107.             break;
  11108.         case 4:
  11109.             ordinal = "th";
  11110.             break;
  11111.         case 5:
  11112.             ordinal = "th";
  11113.             break;
  11114.         case 6:
  11115.             ordinal = "th";
  11116.             break;
  11117.         case 7:
  11118.             ordinal = "th";
  11119.             break;
  11120.         case 8:
  11121.             ordinal = "th";
  11122.             break;
  11123.         case 9:
  11124.             ordinal = "th";
  11125.             break;
  11126.         case 0:
  11127.             ordinal = "th";
  11128.             break;
  11129.         }
  11130.         cout << ordinal;
  11131.         cout << " number.";
  11132.         cout << endl;
  11133.         cout << ">> ";
  11134.         cin  >> entry;
  11135.         cin_is_good = cin.good();
  11136.         cin_isnt_good = ! cin_is_good;
  11137.         if( cin_isnt_good )
  11138.         {
  11139.             BadEntry err;
  11140.             throw( err );
  11141.         }
  11142.         outFile << entry;
  11143.         outFile << ' ';
  11144.     }
  11145.     if( j < number_of_entries )
  11146.     {
  11147.         ++j;
  11148.         ones_digit = j % 10;
  11149.         cout << "Please input the ";
  11150.         cout << j;
  11151.         switch( ones_digit )
  11152.         {
  11153.         case 1:
  11154.             ordinal = "st";
  11155.             break;
  11156.         case 2:
  11157.             ordinal = "nd";
  11158.             break;
  11159.         case 3:
  11160.             ordinal = "rd";
  11161.             break;
  11162.         case 4:
  11163.             ordinal = "th";
  11164.             break;
  11165.         case 5:
  11166.             ordinal = "th";
  11167.             break;
  11168.         case 6:
  11169.             ordinal = "th";
  11170.             break;
  11171.         case 7:
  11172.             ordinal = "th";
  11173.             break;
  11174.         case 8:
  11175.             ordinal = "th";
  11176.             break;
  11177.         case 9:
  11178.             ordinal = "th";
  11179.             break;
  11180.         case 0:
  11181.             ordinal = "th";
  11182.             break;
  11183.         }
  11184.         cout << ordinal;
  11185.         cout << " number.";
  11186.         cout << endl;
  11187.         cout << ">> ";
  11188.         cin  >> entry;
  11189.         cin_is_good = cin.good();
  11190.         cin_isnt_good = ! cin_is_good;
  11191.         if( cin_isnt_good )
  11192.         {
  11193.             BadEntry err;
  11194.             throw( err );
  11195.         }
  11196.         outFile << entry;
  11197.         outFile << ' ';
  11198.     }
  11199.     if( j < number_of_entries )
  11200.     {
  11201.         ++j;
  11202.         ones_digit = j % 10;
  11203.         cout << "Please input the ";
  11204.         cout << j;
  11205.         switch( ones_digit )
  11206.         {
  11207.         case 1:
  11208.             ordinal = "st";
  11209.             break;
  11210.         case 2:
  11211.             ordinal = "nd";
  11212.             break;
  11213.         case 3:
  11214.             ordinal = "rd";
  11215.             break;
  11216.         case 4:
  11217.             ordinal = "th";
  11218.             break;
  11219.         case 5:
  11220.             ordinal = "th";
  11221.             break;
  11222.         case 6:
  11223.             ordinal = "th";
  11224.             break;
  11225.         case 7:
  11226.             ordinal = "th";
  11227.             break;
  11228.         case 8:
  11229.             ordinal = "th";
  11230.             break;
  11231.         case 9:
  11232.             ordinal = "th";
  11233.             break;
  11234.         case 0:
  11235.             ordinal = "th";
  11236.             break;
  11237.         }
  11238.         cout << ordinal;
  11239.         cout << " number.";
  11240.         cout << endl;
  11241.         cout << ">> ";
  11242.         cin  >> entry;
  11243.         cin_is_good = cin.good();
  11244.         cin_isnt_good = ! cin_is_good;
  11245.         if( cin_isnt_good )
  11246.         {
  11247.             BadEntry err;
  11248.             throw( err );
  11249.         }
  11250.         outFile << entry;
  11251.         outFile << ' ';
  11252.     }
  11253.     if( j < number_of_entries )
  11254.     {
  11255.         ++j;
  11256.         ones_digit = j % 10;
  11257.         cout << "Please input the ";
  11258.         cout << j;
  11259.         switch( ones_digit )
  11260.         {
  11261.         case 1:
  11262.             ordinal = "st";
  11263.             break;
  11264.         case 2:
  11265.             ordinal = "nd";
  11266.             break;
  11267.         case 3:
  11268.             ordinal = "rd";
  11269.             break;
  11270.         case 4:
  11271.             ordinal = "th";
  11272.             break;
  11273.         case 5:
  11274.             ordinal = "th";
  11275.             break;
  11276.         case 6:
  11277.             ordinal = "th";
  11278.             break;
  11279.         case 7:
  11280.             ordinal = "th";
  11281.             break;
  11282.         case 8:
  11283.             ordinal = "th";
  11284.             break;
  11285.         case 9:
  11286.             ordinal = "th";
  11287.             break;
  11288.         case 0:
  11289.             ordinal = "th";
  11290.             break;
  11291.         }
  11292.         cout << ordinal;
  11293.         cout << " number.";
  11294.         cout << endl;
  11295.         cout << ">> ";
  11296.         cin  >> entry;
  11297.         cin_is_good = cin.good();
  11298.         cin_isnt_good = ! cin_is_good;
  11299.         if( cin_isnt_good )
  11300.         {
  11301.             BadEntry err;
  11302.             throw( err );
  11303.         }
  11304.         outFile << entry;
  11305.         outFile << ' ';
  11306.     }
  11307.     if( j < number_of_entries )
  11308.     {
  11309.         ++j;
  11310.         ones_digit = j % 10;
  11311.         cout << "Please input the ";
  11312.         cout << j;
  11313.         switch( ones_digit )
  11314.         {
  11315.         case 1:
  11316.             ordinal = "st";
  11317.             break;
  11318.         case 2:
  11319.             ordinal = "nd";
  11320.             break;
  11321.         case 3:
  11322.             ordinal = "rd";
  11323.             break;
  11324.         case 4:
  11325.             ordinal = "th";
  11326.             break;
  11327.         case 5:
  11328.             ordinal = "th";
  11329.             break;
  11330.         case 6:
  11331.             ordinal = "th";
  11332.             break;
  11333.         case 7:
  11334.             ordinal = "th";
  11335.             break;
  11336.         case 8:
  11337.             ordinal = "th";
  11338.             break;
  11339.         case 9:
  11340.             ordinal = "th";
  11341.             break;
  11342.         case 0:
  11343.             ordinal = "th";
  11344.             break;
  11345.         }
  11346.         cout << ordinal;
  11347.         cout << " number.";
  11348.         cout << endl;
  11349.         cout << ">> ";
  11350.         cin  >> entry;
  11351.         cin_is_good = cin.good();
  11352.         cin_isnt_good = ! cin_is_good;
  11353.         if( cin_isnt_good )
  11354.         {
  11355.             BadEntry err;
  11356.             throw( err );
  11357.         }
  11358.         outFile << entry;
  11359.         outFile << ' ';
  11360.     }
  11361.     if( j < number_of_entries )
  11362.     {
  11363.         ++j;
  11364.         ones_digit = j % 10;
  11365.         cout << "Please input the ";
  11366.         cout << j;
  11367.         switch( ones_digit )
  11368.         {
  11369.         case 1:
  11370.             ordinal = "st";
  11371.             break;
  11372.         case 2:
  11373.             ordinal = "nd";
  11374.             break;
  11375.         case 3:
  11376.             ordinal = "rd";
  11377.             break;
  11378.         case 4:
  11379.             ordinal = "th";
  11380.             break;
  11381.         case 5:
  11382.             ordinal = "th";
  11383.             break;
  11384.         case 6:
  11385.             ordinal = "th";
  11386.             break;
  11387.         case 7:
  11388.             ordinal = "th";
  11389.             break;
  11390.         case 8:
  11391.             ordinal = "th";
  11392.             break;
  11393.         case 9:
  11394.             ordinal = "th";
  11395.             break;
  11396.         case 0:
  11397.             ordinal = "th";
  11398.             break;
  11399.         }
  11400.         cout << ordinal;
  11401.         cout << " number.";
  11402.         cout << endl;
  11403.         cout << ">> ";
  11404.         cin  >> entry;
  11405.         cin_is_good = cin.good();
  11406.         cin_isnt_good = ! cin_is_good;
  11407.         if( cin_isnt_good )
  11408.         {
  11409.             BadEntry err;
  11410.             throw( err );
  11411.         }
  11412.         outFile << entry;
  11413.         outFile << ' ';
  11414.     }
  11415.     if( j < number_of_entries )
  11416.     {
  11417.         ++j;
  11418.         ones_digit = j % 10;
  11419.         cout << "Please input the ";
  11420.         cout << j;
  11421.         switch( ones_digit )
  11422.         {
  11423.         case 1:
  11424.             ordinal = "st";
  11425.             break;
  11426.         case 2:
  11427.             ordinal = "nd";
  11428.             break;
  11429.         case 3:
  11430.             ordinal = "rd";
  11431.             break;
  11432.         case 4:
  11433.             ordinal = "th";
  11434.             break;
  11435.         case 5:
  11436.             ordinal = "th";
  11437.             break;
  11438.         case 6:
  11439.             ordinal = "th";
  11440.             break;
  11441.         case 7:
  11442.             ordinal = "th";
  11443.             break;
  11444.         case 8:
  11445.             ordinal = "th";
  11446.             break;
  11447.         case 9:
  11448.             ordinal = "th";
  11449.             break;
  11450.         case 0:
  11451.             ordinal = "th";
  11452.             break;
  11453.         }
  11454.         cout << ordinal;
  11455.         cout << " number.";
  11456.         cout << endl;
  11457.         cout << ">> ";
  11458.         cin  >> entry;
  11459.         cin_is_good = cin.good();
  11460.         cin_isnt_good = ! cin_is_good;
  11461.         if( cin_isnt_good )
  11462.         {
  11463.             BadEntry err;
  11464.             throw( err );
  11465.         }
  11466.         outFile << entry;
  11467.         outFile << ' ';
  11468.     }
  11469.     if( j < number_of_entries )
  11470.     {
  11471.         ++j;
  11472.         ones_digit = j % 10;
  11473.         cout << "Please input the ";
  11474.         cout << j;
  11475.         switch( ones_digit )
  11476.         {
  11477.         case 1:
  11478.             ordinal = "st";
  11479.             break;
  11480.         case 2:
  11481.             ordinal = "nd";
  11482.             break;
  11483.         case 3:
  11484.             ordinal = "rd";
  11485.             break;
  11486.         case 4:
  11487.             ordinal = "th";
  11488.             break;
  11489.         case 5:
  11490.             ordinal = "th";
  11491.             break;
  11492.         case 6:
  11493.             ordinal = "th";
  11494.             break;
  11495.         case 7:
  11496.             ordinal = "th";
  11497.             break;
  11498.         case 8:
  11499.             ordinal = "th";
  11500.             break;
  11501.         case 9:
  11502.             ordinal = "th";
  11503.             break;
  11504.         case 0:
  11505.             ordinal = "th";
  11506.             break;
  11507.         }
  11508.         cout << ordinal;
  11509.         cout << " number.";
  11510.         cout << endl;
  11511.         cout << ">> ";
  11512.         cin  >> entry;
  11513.         cin_is_good = cin.good();
  11514.         cin_isnt_good = ! cin_is_good;
  11515.         if( cin_isnt_good )
  11516.         {
  11517.             BadEntry err;
  11518.             throw( err );
  11519.         }
  11520.         outFile << entry;
  11521.         outFile << ' ';
  11522.     }
  11523.     if( j < number_of_entries )
  11524.     {
  11525.         ++j;
  11526.         ones_digit = j % 10;
  11527.         cout << "Please input the ";
  11528.         cout << j;
  11529.         switch( ones_digit )
  11530.         {
  11531.         case 1:
  11532.             ordinal = "st";
  11533.             break;
  11534.         case 2:
  11535.             ordinal = "nd";
  11536.             break;
  11537.         case 3:
  11538.             ordinal = "rd";
  11539.             break;
  11540.         case 4:
  11541.             ordinal = "th";
  11542.             break;
  11543.         case 5:
  11544.             ordinal = "th";
  11545.             break;
  11546.         case 6:
  11547.             ordinal = "th";
  11548.             break;
  11549.         case 7:
  11550.             ordinal = "th";
  11551.             break;
  11552.         case 8:
  11553.             ordinal = "th";
  11554.             break;
  11555.         case 9:
  11556.             ordinal = "th";
  11557.             break;
  11558.         case 0:
  11559.             ordinal = "th";
  11560.             break;
  11561.         }
  11562.         cout << ordinal;
  11563.         cout << " number.";
  11564.         cout << endl;
  11565.         cout << ">> ";
  11566.         cin  >> entry;
  11567.         cin_is_good = cin.good();
  11568.         cin_isnt_good = ! cin_is_good;
  11569.         if( cin_isnt_good )
  11570.         {
  11571.             BadEntry err;
  11572.             throw( err );
  11573.         }
  11574.         outFile << entry;
  11575.         outFile << ' ';
  11576.     }
  11577.     if( j < number_of_entries )
  11578.     {
  11579.         ++j;
  11580.         ones_digit = j % 10;
  11581.         cout << "Please input the ";
  11582.         cout << j;
  11583.         switch( ones_digit )
  11584.         {
  11585.         case 1:
  11586.             ordinal = "st";
  11587.             break;
  11588.         case 2:
  11589.             ordinal = "nd";
  11590.             break;
  11591.         case 3:
  11592.             ordinal = "rd";
  11593.             break;
  11594.         case 4:
  11595.             ordinal = "th";
  11596.             break;
  11597.         case 5:
  11598.             ordinal = "th";
  11599.             break;
  11600.         case 6:
  11601.             ordinal = "th";
  11602.             break;
  11603.         case 7:
  11604.             ordinal = "th";
  11605.             break;
  11606.         case 8:
  11607.             ordinal = "th";
  11608.             break;
  11609.         case 9:
  11610.             ordinal = "th";
  11611.             break;
  11612.         case 0:
  11613.             ordinal = "th";
  11614.             break;
  11615.         }
  11616.         cout << ordinal;
  11617.         cout << " number.";
  11618.         cout << endl;
  11619.         cout << ">> ";
  11620.         cin  >> entry;
  11621.         cin_is_good = cin.good();
  11622.         cin_isnt_good = ! cin_is_good;
  11623.         if( cin_isnt_good )
  11624.         {
  11625.             BadEntry err;
  11626.             throw( err );
  11627.         }
  11628.         outFile << entry;
  11629.         outFile << ' ';
  11630.     }
  11631.     if( j < number_of_entries )
  11632.     {
  11633.         ++j;
  11634.         ones_digit = j % 10;
  11635.         cout << "Please input the ";
  11636.         cout << j;
  11637.         switch( ones_digit )
  11638.         {
  11639.         case 1:
  11640.             ordinal = "st";
  11641.             break;
  11642.         case 2:
  11643.             ordinal = "nd";
  11644.             break;
  11645.         case 3:
  11646.             ordinal = "rd";
  11647.             break;
  11648.         case 4:
  11649.             ordinal = "th";
  11650.             break;
  11651.         case 5:
  11652.             ordinal = "th";
  11653.             break;
  11654.         case 6:
  11655.             ordinal = "th";
  11656.             break;
  11657.         case 7:
  11658.             ordinal = "th";
  11659.             break;
  11660.         case 8:
  11661.             ordinal = "th";
  11662.             break;
  11663.         case 9:
  11664.             ordinal = "th";
  11665.             break;
  11666.         case 0:
  11667.             ordinal = "th";
  11668.             break;
  11669.         }
  11670.         cout << ordinal;
  11671.         cout << " number.";
  11672.         cout << endl;
  11673.         cout << ">> ";
  11674.         cin  >> entry;
  11675.         cin_is_good = cin.good();
  11676.         cin_isnt_good = ! cin_is_good;
  11677.         if( cin_isnt_good )
  11678.         {
  11679.             BadEntry err;
  11680.             throw( err );
  11681.         }
  11682.         outFile << entry;
  11683.         outFile << ' ';
  11684.     }
  11685.     if( j < number_of_entries )
  11686.     {
  11687.         ++j;
  11688.         ones_digit = j % 10;
  11689.         cout << "Please input the ";
  11690.         cout << j;
  11691.         switch( ones_digit )
  11692.         {
  11693.         case 1:
  11694.             ordinal = "st";
  11695.             break;
  11696.         case 2:
  11697.             ordinal = "nd";
  11698.             break;
  11699.         case 3:
  11700.             ordinal = "rd";
  11701.             break;
  11702.         case 4:
  11703.             ordinal = "th";
  11704.             break;
  11705.         case 5:
  11706.             ordinal = "th";
  11707.             break;
  11708.         case 6:
  11709.             ordinal = "th";
  11710.             break;
  11711.         case 7:
  11712.             ordinal = "th";
  11713.             break;
  11714.         case 8:
  11715.             ordinal = "th";
  11716.             break;
  11717.         case 9:
  11718.             ordinal = "th";
  11719.             break;
  11720.         case 0:
  11721.             ordinal = "th";
  11722.             break;
  11723.         }
  11724.         cout << ordinal;
  11725.         cout << " number.";
  11726.         cout << endl;
  11727.         cout << ">> ";
  11728.         cin  >> entry;
  11729.         cin_is_good = cin.good();
  11730.         cin_isnt_good = ! cin_is_good;
  11731.         if( cin_isnt_good )
  11732.         {
  11733.             BadEntry err;
  11734.             throw( err );
  11735.         }
  11736.         outFile << entry;
  11737.         outFile << ' ';
  11738.     }
  11739.     if( j < number_of_entries )
  11740.     {
  11741.         ++j;
  11742.         ones_digit = j % 10;
  11743.         cout << "Please input the ";
  11744.         cout << j;
  11745.         switch( ones_digit )
  11746.         {
  11747.         case 1:
  11748.             ordinal = "st";
  11749.             break;
  11750.         case 2:
  11751.             ordinal = "nd";
  11752.             break;
  11753.         case 3:
  11754.             ordinal = "rd";
  11755.             break;
  11756.         case 4:
  11757.             ordinal = "th";
  11758.             break;
  11759.         case 5:
  11760.             ordinal = "th";
  11761.             break;
  11762.         case 6:
  11763.             ordinal = "th";
  11764.             break;
  11765.         case 7:
  11766.             ordinal = "th";
  11767.             break;
  11768.         case 8:
  11769.             ordinal = "th";
  11770.             break;
  11771.         case 9:
  11772.             ordinal = "th";
  11773.             break;
  11774.         case 0:
  11775.             ordinal = "th";
  11776.             break;
  11777.         }
  11778.         cout << ordinal;
  11779.         cout << " number.";
  11780.         cout << endl;
  11781.         cout << ">> ";
  11782.         cin  >> entry;
  11783.         cin_is_good = cin.good();
  11784.         cin_isnt_good = ! cin_is_good;
  11785.         if( cin_isnt_good )
  11786.         {
  11787.             BadEntry err;
  11788.             throw( err );
  11789.         }
  11790.         outFile << entry;
  11791.         outFile << ' ';
  11792.     }
  11793.     if( j < number_of_entries )
  11794.     {
  11795.         ++j;
  11796.         ones_digit = j % 10;
  11797.         cout << "Please input the ";
  11798.         cout << j;
  11799.         switch( ones_digit )
  11800.         {
  11801.         case 1:
  11802.             ordinal = "st";
  11803.             break;
  11804.         case 2:
  11805.             ordinal = "nd";
  11806.             break;
  11807.         case 3:
  11808.             ordinal = "rd";
  11809.             break;
  11810.         case 4:
  11811.             ordinal = "th";
  11812.             break;
  11813.         case 5:
  11814.             ordinal = "th";
  11815.             break;
  11816.         case 6:
  11817.             ordinal = "th";
  11818.             break;
  11819.         case 7:
  11820.             ordinal = "th";
  11821.             break;
  11822.         case 8:
  11823.             ordinal = "th";
  11824.             break;
  11825.         case 9:
  11826.             ordinal = "th";
  11827.             break;
  11828.         case 0:
  11829.             ordinal = "th";
  11830.             break;
  11831.         }
  11832.         cout << ordinal;
  11833.         cout << " number.";
  11834.         cout << endl;
  11835.         cout << ">> ";
  11836.         cin  >> entry;
  11837.         cin_is_good = cin.good();
  11838.         cin_isnt_good = ! cin_is_good;
  11839.         if( cin_isnt_good )
  11840.         {
  11841.             BadEntry err;
  11842.             throw( err );
  11843.         }
  11844.         outFile << entry;
  11845.         outFile << ' ';
  11846.     }
  11847.     if( j < number_of_entries )
  11848.     {
  11849.         ++j;
  11850.         ones_digit = j % 10;
  11851.         cout << "Please input the ";
  11852.         cout << j;
  11853.         switch( ones_digit )
  11854.         {
  11855.         case 1:
  11856.             ordinal = "st";
  11857.             break;
  11858.         case 2:
  11859.             ordinal = "nd";
  11860.             break;
  11861.         case 3:
  11862.             ordinal = "rd";
  11863.             break;
  11864.         case 4:
  11865.             ordinal = "th";
  11866.             break;
  11867.         case 5:
  11868.             ordinal = "th";
  11869.             break;
  11870.         case 6:
  11871.             ordinal = "th";
  11872.             break;
  11873.         case 7:
  11874.             ordinal = "th";
  11875.             break;
  11876.         case 8:
  11877.             ordinal = "th";
  11878.             break;
  11879.         case 9:
  11880.             ordinal = "th";
  11881.             break;
  11882.         case 0:
  11883.             ordinal = "th";
  11884.             break;
  11885.         }
  11886.         cout << ordinal;
  11887.         cout << " number.";
  11888.         cout << endl;
  11889.         cout << ">> ";
  11890.         cin  >> entry;
  11891.         cin_is_good = cin.good();
  11892.         cin_isnt_good = ! cin_is_good;
  11893.         if( cin_isnt_good )
  11894.         {
  11895.             BadEntry err;
  11896.             throw( err );
  11897.         }
  11898.         outFile << entry;
  11899.         outFile << ' ';
  11900.     }
  11901.     if( j < number_of_entries )
  11902.     {
  11903.         ++j;
  11904.         ones_digit = j % 10;
  11905.         cout << "Please input the ";
  11906.         cout << j;
  11907.         switch( ones_digit )
  11908.         {
  11909.         case 1:
  11910.             ordinal = "st";
  11911.             break;
  11912.         case 2:
  11913.             ordinal = "nd";
  11914.             break;
  11915.         case 3:
  11916.             ordinal = "rd";
  11917.             break;
  11918.         case 4:
  11919.             ordinal = "th";
  11920.             break;
  11921.         case 5:
  11922.             ordinal = "th";
  11923.             break;
  11924.         case 6:
  11925.             ordinal = "th";
  11926.             break;
  11927.         case 7:
  11928.             ordinal = "th";
  11929.             break;
  11930.         case 8:
  11931.             ordinal = "th";
  11932.             break;
  11933.         case 9:
  11934.             ordinal = "th";
  11935.             break;
  11936.         case 0:
  11937.             ordinal = "th";
  11938.             break;
  11939.         }
  11940.         cout << ordinal;
  11941.         cout << " number.";
  11942.         cout << endl;
  11943.         cout << ">> ";
  11944.         cin  >> entry;
  11945.         cin_is_good = cin.good();
  11946.         cin_isnt_good = ! cin_is_good;
  11947.         if( cin_isnt_good )
  11948.         {
  11949.             BadEntry err;
  11950.             throw( err );
  11951.         }
  11952.         outFile << entry;
  11953.         outFile << ' ';
  11954.     }
  11955.     if( j < number_of_entries )
  11956.     {
  11957.         ++j;
  11958.         ones_digit = j % 10;
  11959.         cout << "Please input the ";
  11960.         cout << j;
  11961.         switch( ones_digit )
  11962.         {
  11963.         case 1:
  11964.             ordinal = "st";
  11965.             break;
  11966.         case 2:
  11967.             ordinal = "nd";
  11968.             break;
  11969.         case 3:
  11970.             ordinal = "rd";
  11971.             break;
  11972.         case 4:
  11973.             ordinal = "th";
  11974.             break;
  11975.         case 5:
  11976.             ordinal = "th";
  11977.             break;
  11978.         case 6:
  11979.             ordinal = "th";
  11980.             break;
  11981.         case 7:
  11982.             ordinal = "th";
  11983.             break;
  11984.         case 8:
  11985.             ordinal = "th";
  11986.             break;
  11987.         case 9:
  11988.             ordinal = "th";
  11989.             break;
  11990.         case 0:
  11991.             ordinal = "th";
  11992.             break;
  11993.         }
  11994.         cout << ordinal;
  11995.         cout << " number.";
  11996.         cout << endl;
  11997.         cout << ">> ";
  11998.         cin  >> entry;
  11999.         cin_is_good = cin.good();
  12000.         cin_isnt_good = ! cin_is_good;
  12001.         if( cin_isnt_good )
  12002.         {
  12003.             BadEntry err;
  12004.             throw( err );
  12005.         }
  12006.         outFile << entry;
  12007.         outFile << ' ';
  12008.     }
  12009.     if( j < number_of_entries )
  12010.     {
  12011.         ++j;
  12012.         ones_digit = j % 10;
  12013.         cout << "Please input the ";
  12014.         cout << j;
  12015.         switch( ones_digit )
  12016.         {
  12017.         case 1:
  12018.             ordinal = "st";
  12019.             break;
  12020.         case 2:
  12021.             ordinal = "nd";
  12022.             break;
  12023.         case 3:
  12024.             ordinal = "rd";
  12025.             break;
  12026.         case 4:
  12027.             ordinal = "th";
  12028.             break;
  12029.         case 5:
  12030.             ordinal = "th";
  12031.             break;
  12032.         case 6:
  12033.             ordinal = "th";
  12034.             break;
  12035.         case 7:
  12036.             ordinal = "th";
  12037.             break;
  12038.         case 8:
  12039.             ordinal = "th";
  12040.             break;
  12041.         case 9:
  12042.             ordinal = "th";
  12043.             break;
  12044.         case 0:
  12045.             ordinal = "th";
  12046.             break;
  12047.         }
  12048.         cout << ordinal;
  12049.         cout << " number.";
  12050.         cout << endl;
  12051.         cout << ">> ";
  12052.         cin  >> entry;
  12053.         cin_is_good = cin.good();
  12054.         cin_isnt_good = ! cin_is_good;
  12055.         if( cin_isnt_good )
  12056.         {
  12057.             BadEntry err;
  12058.             throw( err );
  12059.         }
  12060.         outFile << entry;
  12061.         outFile << ' ';
  12062.     }
  12063.     if( j < number_of_entries )
  12064.     {
  12065.         ++j;
  12066.         ones_digit = j % 10;
  12067.         cout << "Please input the ";
  12068.         cout << j;
  12069.         switch( ones_digit )
  12070.         {
  12071.         case 1:
  12072.             ordinal = "st";
  12073.             break;
  12074.         case 2:
  12075.             ordinal = "nd";
  12076.             break;
  12077.         case 3:
  12078.             ordinal = "rd";
  12079.             break;
  12080.         case 4:
  12081.             ordinal = "th";
  12082.             break;
  12083.         case 5:
  12084.             ordinal = "th";
  12085.             break;
  12086.         case 6:
  12087.             ordinal = "th";
  12088.             break;
  12089.         case 7:
  12090.             ordinal = "th";
  12091.             break;
  12092.         case 8:
  12093.             ordinal = "th";
  12094.             break;
  12095.         case 9:
  12096.             ordinal = "th";
  12097.             break;
  12098.         case 0:
  12099.             ordinal = "th";
  12100.             break;
  12101.         }
  12102.         cout << ordinal;
  12103.         cout << " number.";
  12104.         cout << endl;
  12105.         cout << ">> ";
  12106.         cin  >> entry;
  12107.         cin_is_good = cin.good();
  12108.         cin_isnt_good = ! cin_is_good;
  12109.         if( cin_isnt_good )
  12110.         {
  12111.             BadEntry err;
  12112.             throw( err );
  12113.         }
  12114.         outFile << entry;
  12115.         outFile << ' ';
  12116.     }
  12117.     if( j < number_of_entries )
  12118.     {
  12119.         ++j;
  12120.         ones_digit = j % 10;
  12121.         cout << "Please input the ";
  12122.         cout << j;
  12123.         switch( ones_digit )
  12124.         {
  12125.         case 1:
  12126.             ordinal = "st";
  12127.             break;
  12128.         case 2:
  12129.             ordinal = "nd";
  12130.             break;
  12131.         case 3:
  12132.             ordinal = "rd";
  12133.             break;
  12134.         case 4:
  12135.             ordinal = "th";
  12136.             break;
  12137.         case 5:
  12138.             ordinal = "th";
  12139.             break;
  12140.         case 6:
  12141.             ordinal = "th";
  12142.             break;
  12143.         case 7:
  12144.             ordinal = "th";
  12145.             break;
  12146.         case 8:
  12147.             ordinal = "th";
  12148.             break;
  12149.         case 9:
  12150.             ordinal = "th";
  12151.             break;
  12152.         case 0:
  12153.             ordinal = "th";
  12154.             break;
  12155.         }
  12156.         cout << ordinal;
  12157.         cout << " number.";
  12158.         cout << endl;
  12159.         cout << ">> ";
  12160.         cin  >> entry;
  12161.         cin_is_good = cin.good();
  12162.         cin_isnt_good = ! cin_is_good;
  12163.         if( cin_isnt_good )
  12164.         {
  12165.             BadEntry err;
  12166.             throw( err );
  12167.         }
  12168.         outFile << entry;
  12169.         outFile << ' ';
  12170.     }
  12171.     if( j < number_of_entries )
  12172.     {
  12173.         ++j;
  12174.         ones_digit = j % 10;
  12175.         cout << "Please input the ";
  12176.         cout << j;
  12177.         switch( ones_digit )
  12178.         {
  12179.         case 1:
  12180.             ordinal = "st";
  12181.             break;
  12182.         case 2:
  12183.             ordinal = "nd";
  12184.             break;
  12185.         case 3:
  12186.             ordinal = "rd";
  12187.             break;
  12188.         case 4:
  12189.             ordinal = "th";
  12190.             break;
  12191.         case 5:
  12192.             ordinal = "th";
  12193.             break;
  12194.         case 6:
  12195.             ordinal = "th";
  12196.             break;
  12197.         case 7:
  12198.             ordinal = "th";
  12199.             break;
  12200.         case 8:
  12201.             ordinal = "th";
  12202.             break;
  12203.         case 9:
  12204.             ordinal = "th";
  12205.             break;
  12206.         case 0:
  12207.             ordinal = "th";
  12208.             break;
  12209.         }
  12210.         cout << ordinal;
  12211.         cout << " number.";
  12212.         cout << endl;
  12213.         cout << ">> ";
  12214.         cin  >> entry;
  12215.         cin_is_good = cin.good();
  12216.         cin_isnt_good = ! cin_is_good;
  12217.         if( cin_isnt_good )
  12218.         {
  12219.             BadEntry err;
  12220.             throw( err );
  12221.         }
  12222.         outFile << entry;
  12223.         outFile << ' ';
  12224.     }
  12225.     if( j < number_of_entries )
  12226.     {
  12227.         ++j;
  12228.         ones_digit = j % 10;
  12229.         cout << "Please input the ";
  12230.         cout << j;
  12231.         switch( ones_digit )
  12232.         {
  12233.         case 1:
  12234.             ordinal = "st";
  12235.             break;
  12236.         case 2:
  12237.             ordinal = "nd";
  12238.             break;
  12239.         case 3:
  12240.             ordinal = "rd";
  12241.             break;
  12242.         case 4:
  12243.             ordinal = "th";
  12244.             break;
  12245.         case 5:
  12246.             ordinal = "th";
  12247.             break;
  12248.         case 6:
  12249.             ordinal = "th";
  12250.             break;
  12251.         case 7:
  12252.             ordinal = "th";
  12253.             break;
  12254.         case 8:
  12255.             ordinal = "th";
  12256.             break;
  12257.         case 9:
  12258.             ordinal = "th";
  12259.             break;
  12260.         case 0:
  12261.             ordinal = "th";
  12262.             break;
  12263.         }
  12264.         cout << ordinal;
  12265.         cout << " number.";
  12266.         cout << endl;
  12267.         cout << ">> ";
  12268.         cin  >> entry;
  12269.         cin_is_good = cin.good();
  12270.         cin_isnt_good = ! cin_is_good;
  12271.         if( cin_isnt_good )
  12272.         {
  12273.             BadEntry err;
  12274.             throw( err );
  12275.         }
  12276.         outFile << entry;
  12277.         outFile << ' ';
  12278.     }
  12279.     if( j < number_of_entries )
  12280.     {
  12281.         ++j;
  12282.         ones_digit = j % 10;
  12283.         cout << "Please input the ";
  12284.         cout << j;
  12285.         switch( ones_digit )
  12286.         {
  12287.         case 1:
  12288.             ordinal = "st";
  12289.             break;
  12290.         case 2:
  12291.             ordinal = "nd";
  12292.             break;
  12293.         case 3:
  12294.             ordinal = "rd";
  12295.             break;
  12296.         case 4:
  12297.             ordinal = "th";
  12298.             break;
  12299.         case 5:
  12300.             ordinal = "th";
  12301.             break;
  12302.         case 6:
  12303.             ordinal = "th";
  12304.             break;
  12305.         case 7:
  12306.             ordinal = "th";
  12307.             break;
  12308.         case 8:
  12309.             ordinal = "th";
  12310.             break;
  12311.         case 9:
  12312.             ordinal = "th";
  12313.             break;
  12314.         case 0:
  12315.             ordinal = "th";
  12316.             break;
  12317.         }
  12318.         cout << ordinal;
  12319.         cout << " number.";
  12320.         cout << endl;
  12321.         cout << ">> ";
  12322.         cin  >> entry;
  12323.         cin_is_good = cin.good();
  12324.         cin_isnt_good = ! cin_is_good;
  12325.         if( cin_isnt_good )
  12326.         {
  12327.             BadEntry err;
  12328.             throw( err );
  12329.         }
  12330.         outFile << entry;
  12331.         outFile << ' ';
  12332.     }
  12333.     if( j < number_of_entries )
  12334.     {
  12335.         ++j;
  12336.         ones_digit = j % 10;
  12337.         cout << "Please input the ";
  12338.         cout << j;
  12339.         switch( ones_digit )
  12340.         {
  12341.         case 1:
  12342.             ordinal = "st";
  12343.             break;
  12344.         case 2:
  12345.             ordinal = "nd";
  12346.             break;
  12347.         case 3:
  12348.             ordinal = "rd";
  12349.             break;
  12350.         case 4:
  12351.             ordinal = "th";
  12352.             break;
  12353.         case 5:
  12354.             ordinal = "th";
  12355.             break;
  12356.         case 6:
  12357.             ordinal = "th";
  12358.             break;
  12359.         case 7:
  12360.             ordinal = "th";
  12361.             break;
  12362.         case 8:
  12363.             ordinal = "th";
  12364.             break;
  12365.         case 9:
  12366.             ordinal = "th";
  12367.             break;
  12368.         case 0:
  12369.             ordinal = "th";
  12370.             break;
  12371.         }
  12372.         cout << ordinal;
  12373.         cout << " number.";
  12374.         cout << endl;
  12375.         cout << ">> ";
  12376.         cin  >> entry;
  12377.         cin_is_good = cin.good();
  12378.         cin_isnt_good = ! cin_is_good;
  12379.         if( cin_isnt_good )
  12380.         {
  12381.             BadEntry err;
  12382.             throw( err );
  12383.         }
  12384.         outFile << entry;
  12385.         outFile << ' ';
  12386.     }
  12387.     if( j < number_of_entries )
  12388.     {
  12389.         ++j;
  12390.         ones_digit = j % 10;
  12391.         cout << "Please input the ";
  12392.         cout << j;
  12393.         switch( ones_digit )
  12394.         {
  12395.         case 1:
  12396.             ordinal = "st";
  12397.             break;
  12398.         case 2:
  12399.             ordinal = "nd";
  12400.             break;
  12401.         case 3:
  12402.             ordinal = "rd";
  12403.             break;
  12404.         case 4:
  12405.             ordinal = "th";
  12406.             break;
  12407.         case 5:
  12408.             ordinal = "th";
  12409.             break;
  12410.         case 6:
  12411.             ordinal = "th";
  12412.             break;
  12413.         case 7:
  12414.             ordinal = "th";
  12415.             break;
  12416.         case 8:
  12417.             ordinal = "th";
  12418.             break;
  12419.         case 9:
  12420.             ordinal = "th";
  12421.             break;
  12422.         case 0:
  12423.             ordinal = "th";
  12424.             break;
  12425.         }
  12426.         cout << ordinal;
  12427.         cout << " number.";
  12428.         cout << endl;
  12429.         cout << ">> ";
  12430.         cin  >> entry;
  12431.         cin_is_good = cin.good();
  12432.         cin_isnt_good = ! cin_is_good;
  12433.         if( cin_isnt_good )
  12434.         {
  12435.             BadEntry err;
  12436.             throw( err );
  12437.         }
  12438.         outFile << entry;
  12439.         outFile << ' ';
  12440.     }
  12441.     if( j < number_of_entries )
  12442.     {
  12443.         ++j;
  12444.         ones_digit = j % 10;
  12445.         cout << "Please input the ";
  12446.         cout << j;
  12447.         switch( ones_digit )
  12448.         {
  12449.         case 1:
  12450.             ordinal = "st";
  12451.             break;
  12452.         case 2:
  12453.             ordinal = "nd";
  12454.             break;
  12455.         case 3:
  12456.             ordinal = "rd";
  12457.             break;
  12458.         case 4:
  12459.             ordinal = "th";
  12460.             break;
  12461.         case 5:
  12462.             ordinal = "th";
  12463.             break;
  12464.         case 6:
  12465.             ordinal = "th";
  12466.             break;
  12467.         case 7:
  12468.             ordinal = "th";
  12469.             break;
  12470.         case 8:
  12471.             ordinal = "th";
  12472.             break;
  12473.         case 9:
  12474.             ordinal = "th";
  12475.             break;
  12476.         case 0:
  12477.             ordinal = "th";
  12478.             break;
  12479.         }
  12480.         cout << ordinal;
  12481.         cout << " number.";
  12482.         cout << endl;
  12483.         cout << ">> ";
  12484.         cin  >> entry;
  12485.         cin_is_good = cin.good();
  12486.         cin_isnt_good = ! cin_is_good;
  12487.         if( cin_isnt_good )
  12488.         {
  12489.             BadEntry err;
  12490.             throw( err );
  12491.         }
  12492.         outFile << entry;
  12493.         outFile << ' ';
  12494.     }
  12495.     if( j < number_of_entries )
  12496.     {
  12497.         ++j;
  12498.         ones_digit = j % 10;
  12499.         cout << "Please input the ";
  12500.         cout << j;
  12501.         switch( ones_digit )
  12502.         {
  12503.         case 1:
  12504.             ordinal = "st";
  12505.             break;
  12506.         case 2:
  12507.             ordinal = "nd";
  12508.             break;
  12509.         case 3:
  12510.             ordinal = "rd";
  12511.             break;
  12512.         case 4:
  12513.             ordinal = "th";
  12514.             break;
  12515.         case 5:
  12516.             ordinal = "th";
  12517.             break;
  12518.         case 6:
  12519.             ordinal = "th";
  12520.             break;
  12521.         case 7:
  12522.             ordinal = "th";
  12523.             break;
  12524.         case 8:
  12525.             ordinal = "th";
  12526.             break;
  12527.         case 9:
  12528.             ordinal = "th";
  12529.             break;
  12530.         case 0:
  12531.             ordinal = "th";
  12532.             break;
  12533.         }
  12534.         cout << ordinal;
  12535.         cout << " number.";
  12536.         cout << endl;
  12537.         cout << ">> ";
  12538.         cin  >> entry;
  12539.         cin_is_good = cin.good();
  12540.         cin_isnt_good = ! cin_is_good;
  12541.         if( cin_isnt_good )
  12542.         {
  12543.             BadEntry err;
  12544.             throw( err );
  12545.         }
  12546.         outFile << entry;
  12547.         outFile << ' ';
  12548.     }
  12549.     if( j < number_of_entries )
  12550.     {
  12551.         ++j;
  12552.         ones_digit = j % 10;
  12553.         cout << "Please input the ";
  12554.         cout << j;
  12555.         switch( ones_digit )
  12556.         {
  12557.         case 1:
  12558.             ordinal = "st";
  12559.             break;
  12560.         case 2:
  12561.             ordinal = "nd";
  12562.             break;
  12563.         case 3:
  12564.             ordinal = "rd";
  12565.             break;
  12566.         case 4:
  12567.             ordinal = "th";
  12568.             break;
  12569.         case 5:
  12570.             ordinal = "th";
  12571.             break;
  12572.         case 6:
  12573.             ordinal = "th";
  12574.             break;
  12575.         case 7:
  12576.             ordinal = "th";
  12577.             break;
  12578.         case 8:
  12579.             ordinal = "th";
  12580.             break;
  12581.         case 9:
  12582.             ordinal = "th";
  12583.             break;
  12584.         case 0:
  12585.             ordinal = "th";
  12586.             break;
  12587.         }
  12588.         cout << ordinal;
  12589.         cout << " number.";
  12590.         cout << endl;
  12591.         cout << ">> ";
  12592.         cin  >> entry;
  12593.         cin_is_good = cin.good();
  12594.         cin_isnt_good = ! cin_is_good;
  12595.         if( cin_isnt_good )
  12596.         {
  12597.             BadEntry err;
  12598.             throw( err );
  12599.         }
  12600.         outFile << entry;
  12601.         outFile << ' ';
  12602.     }
  12603.     if( j < number_of_entries )
  12604.     {
  12605.         ++j;
  12606.         ones_digit = j % 10;
  12607.         cout << "Please input the ";
  12608.         cout << j;
  12609.         switch( ones_digit )
  12610.         {
  12611.         case 1:
  12612.             ordinal = "st";
  12613.             break;
  12614.         case 2:
  12615.             ordinal = "nd";
  12616.             break;
  12617.         case 3:
  12618.             ordinal = "rd";
  12619.             break;
  12620.         case 4:
  12621.             ordinal = "th";
  12622.             break;
  12623.         case 5:
  12624.             ordinal = "th";
  12625.             break;
  12626.         case 6:
  12627.             ordinal = "th";
  12628.             break;
  12629.         case 7:
  12630.             ordinal = "th";
  12631.             break;
  12632.         case 8:
  12633.             ordinal = "th";
  12634.             break;
  12635.         case 9:
  12636.             ordinal = "th";
  12637.             break;
  12638.         case 0:
  12639.             ordinal = "th";
  12640.             break;
  12641.         }
  12642.         cout << ordinal;
  12643.         cout << " number.";
  12644.         cout << endl;
  12645.         cout << ">> ";
  12646.         cin  >> entry;
  12647.         cin_is_good = cin.good();
  12648.         cin_isnt_good = ! cin_is_good;
  12649.         if( cin_isnt_good )
  12650.         {
  12651.             BadEntry err;
  12652.             throw( err );
  12653.         }
  12654.         outFile << entry;
  12655.         outFile << ' ';
  12656.     }
  12657.     if( j < number_of_entries )
  12658.     {
  12659.         ++j;
  12660.         ones_digit = j % 10;
  12661.         cout << "Please input the ";
  12662.         cout << j;
  12663.         switch( ones_digit )
  12664.         {
  12665.         case 1:
  12666.             ordinal = "st";
  12667.             break;
  12668.         case 2:
  12669.             ordinal = "nd";
  12670.             break;
  12671.         case 3:
  12672.             ordinal = "rd";
  12673.             break;
  12674.         case 4:
  12675.             ordinal = "th";
  12676.             break;
  12677.         case 5:
  12678.             ordinal = "th";
  12679.             break;
  12680.         case 6:
  12681.             ordinal = "th";
  12682.             break;
  12683.         case 7:
  12684.             ordinal = "th";
  12685.             break;
  12686.         case 8:
  12687.             ordinal = "th";
  12688.             break;
  12689.         case 9:
  12690.             ordinal = "th";
  12691.             break;
  12692.         case 0:
  12693.             ordinal = "th";
  12694.             break;
  12695.         }
  12696.         cout << ordinal;
  12697.         cout << " number.";
  12698.         cout << endl;
  12699.         cout << ">> ";
  12700.         cin  >> entry;
  12701.         cin_is_good = cin.good();
  12702.         cin_isnt_good = ! cin_is_good;
  12703.         if( cin_isnt_good )
  12704.         {
  12705.             BadEntry err;
  12706.             throw( err );
  12707.         }
  12708.         outFile << entry;
  12709.         outFile << ' ';
  12710.     }
  12711.     if( j < number_of_entries )
  12712.     {
  12713.         ++j;
  12714.         ones_digit = j % 10;
  12715.         cout << "Please input the ";
  12716.         cout << j;
  12717.         switch( ones_digit )
  12718.         {
  12719.         case 1:
  12720.             ordinal = "st";
  12721.             break;
  12722.         case 2:
  12723.             ordinal = "nd";
  12724.             break;
  12725.         case 3:
  12726.             ordinal = "rd";
  12727.             break;
  12728.         case 4:
  12729.             ordinal = "th";
  12730.             break;
  12731.         case 5:
  12732.             ordinal = "th";
  12733.             break;
  12734.         case 6:
  12735.             ordinal = "th";
  12736.             break;
  12737.         case 7:
  12738.             ordinal = "th";
  12739.             break;
  12740.         case 8:
  12741.             ordinal = "th";
  12742.             break;
  12743.         case 9:
  12744.             ordinal = "th";
  12745.             break;
  12746.         case 0:
  12747.             ordinal = "th";
  12748.             break;
  12749.         }
  12750.         cout << ordinal;
  12751.         cout << " number.";
  12752.         cout << endl;
  12753.         cout << ">> ";
  12754.         cin  >> entry;
  12755.         cin_is_good = cin.good();
  12756.         cin_isnt_good = ! cin_is_good;
  12757.         if( cin_isnt_good )
  12758.         {
  12759.             BadEntry err;
  12760.             throw( err );
  12761.         }
  12762.         outFile << entry;
  12763.         outFile << ' ';
  12764.     }
  12765.     if( j < number_of_entries )
  12766.     {
  12767.         ++j;
  12768.         ones_digit = j % 10;
  12769.         cout << "Please input the ";
  12770.         cout << j;
  12771.         switch( ones_digit )
  12772.         {
  12773.         case 1:
  12774.             ordinal = "st";
  12775.             break;
  12776.         case 2:
  12777.             ordinal = "nd";
  12778.             break;
  12779.         case 3:
  12780.             ordinal = "rd";
  12781.             break;
  12782.         case 4:
  12783.             ordinal = "th";
  12784.             break;
  12785.         case 5:
  12786.             ordinal = "th";
  12787.             break;
  12788.         case 6:
  12789.             ordinal = "th";
  12790.             break;
  12791.         case 7:
  12792.             ordinal = "th";
  12793.             break;
  12794.         case 8:
  12795.             ordinal = "th";
  12796.             break;
  12797.         case 9:
  12798.             ordinal = "th";
  12799.             break;
  12800.         case 0:
  12801.             ordinal = "th";
  12802.             break;
  12803.         }
  12804.         cout << ordinal;
  12805.         cout << " number.";
  12806.         cout << endl;
  12807.         cout << ">> ";
  12808.         cin  >> entry;
  12809.         cin_is_good = cin.good();
  12810.         cin_isnt_good = ! cin_is_good;
  12811.         if( cin_isnt_good )
  12812.         {
  12813.             BadEntry err;
  12814.             throw( err );
  12815.         }
  12816.         outFile << entry;
  12817.         outFile << ' ';
  12818.     }
  12819.     if( j < number_of_entries )
  12820.     {
  12821.         ++j;
  12822.         ones_digit = j % 10;
  12823.         cout << "Please input the ";
  12824.         cout << j;
  12825.         switch( ones_digit )
  12826.         {
  12827.         case 1:
  12828.             ordinal = "st";
  12829.             break;
  12830.         case 2:
  12831.             ordinal = "nd";
  12832.             break;
  12833.         case 3:
  12834.             ordinal = "rd";
  12835.             break;
  12836.         case 4:
  12837.             ordinal = "th";
  12838.             break;
  12839.         case 5:
  12840.             ordinal = "th";
  12841.             break;
  12842.         case 6:
  12843.             ordinal = "th";
  12844.             break;
  12845.         case 7:
  12846.             ordinal = "th";
  12847.             break;
  12848.         case 8:
  12849.             ordinal = "th";
  12850.             break;
  12851.         case 9:
  12852.             ordinal = "th";
  12853.             break;
  12854.         case 0:
  12855.             ordinal = "th";
  12856.             break;
  12857.         }
  12858.         cout << ordinal;
  12859.         cout << " number.";
  12860.         cout << endl;
  12861.         cout << ">> ";
  12862.         cin  >> entry;
  12863.         cin_is_good = cin.good();
  12864.         cin_isnt_good = ! cin_is_good;
  12865.         if( cin_isnt_good )
  12866.         {
  12867.             BadEntry err;
  12868.             throw( err );
  12869.         }
  12870.         outFile << entry;
  12871.         outFile << ' ';
  12872.     }
  12873.     if( j < number_of_entries )
  12874.     {
  12875.         ++j;
  12876.         ones_digit = j % 10;
  12877.         cout << "Please input the ";
  12878.         cout << j;
  12879.         switch( ones_digit )
  12880.         {
  12881.         case 1:
  12882.             ordinal = "st";
  12883.             break;
  12884.         case 2:
  12885.             ordinal = "nd";
  12886.             break;
  12887.         case 3:
  12888.             ordinal = "rd";
  12889.             break;
  12890.         case 4:
  12891.             ordinal = "th";
  12892.             break;
  12893.         case 5:
  12894.             ordinal = "th";
  12895.             break;
  12896.         case 6:
  12897.             ordinal = "th";
  12898.             break;
  12899.         case 7:
  12900.             ordinal = "th";
  12901.             break;
  12902.         case 8:
  12903.             ordinal = "th";
  12904.             break;
  12905.         case 9:
  12906.             ordinal = "th";
  12907.             break;
  12908.         case 0:
  12909.             ordinal = "th";
  12910.             break;
  12911.         }
  12912.         cout << ordinal;
  12913.         cout << " number.";
  12914.         cout << endl;
  12915.         cout << ">> ";
  12916.         cin  >> entry;
  12917.         cin_is_good = cin.good();
  12918.         cin_isnt_good = ! cin_is_good;
  12919.         if( cin_isnt_good )
  12920.         {
  12921.             BadEntry err;
  12922.             throw( err );
  12923.         }
  12924.         outFile << entry;
  12925.         outFile << ' ';
  12926.     }
  12927.     if( j < number_of_entries )
  12928.     {
  12929.         ++j;
  12930.         ones_digit = j % 10;
  12931.         cout << "Please input the ";
  12932.         cout << j;
  12933.         switch( ones_digit )
  12934.         {
  12935.         case 1:
  12936.             ordinal = "st";
  12937.             break;
  12938.         case 2:
  12939.             ordinal = "nd";
  12940.             break;
  12941.         case 3:
  12942.             ordinal = "rd";
  12943.             break;
  12944.         case 4:
  12945.             ordinal = "th";
  12946.             break;
  12947.         case 5:
  12948.             ordinal = "th";
  12949.             break;
  12950.         case 6:
  12951.             ordinal = "th";
  12952.             break;
  12953.         case 7:
  12954.             ordinal = "th";
  12955.             break;
  12956.         case 8:
  12957.             ordinal = "th";
  12958.             break;
  12959.         case 9:
  12960.             ordinal = "th";
  12961.             break;
  12962.         case 0:
  12963.             ordinal = "th";
  12964.             break;
  12965.         }
  12966.         cout << ordinal;
  12967.         cout << " number.";
  12968.         cout << endl;
  12969.         cout << ">> ";
  12970.         cin  >> entry;
  12971.         cin_is_good = cin.good();
  12972.         cin_isnt_good = ! cin_is_good;
  12973.         if( cin_isnt_good )
  12974.         {
  12975.             BadEntry err;
  12976.             throw( err );
  12977.         }
  12978.         outFile << entry;
  12979.         outFile << ' ';
  12980.     }
  12981.     if( j < number_of_entries )
  12982.     {
  12983.         ++j;
  12984.         ones_digit = j % 10;
  12985.         cout << "Please input the ";
  12986.         cout << j;
  12987.         switch( ones_digit )
  12988.         {
  12989.         case 1:
  12990.             ordinal = "st";
  12991.             break;
  12992.         case 2:
  12993.             ordinal = "nd";
  12994.             break;
  12995.         case 3:
  12996.             ordinal = "rd";
  12997.             break;
  12998.         case 4:
  12999.             ordinal = "th";
  13000.             break;
  13001.         case 5:
  13002.             ordinal = "th";
  13003.             break;
  13004.         case 6:
  13005.             ordinal = "th";
  13006.             break;
  13007.         case 7:
  13008.             ordinal = "th";
  13009.             break;
  13010.         case 8:
  13011.             ordinal = "th";
  13012.             break;
  13013.         case 9:
  13014.             ordinal = "th";
  13015.             break;
  13016.         case 0:
  13017.             ordinal = "th";
  13018.             break;
  13019.         }
  13020.         cout << ordinal;
  13021.         cout << " number.";
  13022.         cout << endl;
  13023.         cout << ">> ";
  13024.         cin  >> entry;
  13025.         cin_is_good = cin.good();
  13026.         cin_isnt_good = ! cin_is_good;
  13027.         if( cin_isnt_good )
  13028.         {
  13029.             BadEntry err;
  13030.             throw( err );
  13031.         }
  13032.         outFile << entry;
  13033.         outFile << ' ';
  13034.     }
  13035.     if( j < number_of_entries )
  13036.     {
  13037.         ++j;
  13038.         ones_digit = j % 10;
  13039.         cout << "Please input the ";
  13040.         cout << j;
  13041.         switch( ones_digit )
  13042.         {
  13043.         case 1:
  13044.             ordinal = "st";
  13045.             break;
  13046.         case 2:
  13047.             ordinal = "nd";
  13048.             break;
  13049.         case 3:
  13050.             ordinal = "rd";
  13051.             break;
  13052.         case 4:
  13053.             ordinal = "th";
  13054.             break;
  13055.         case 5:
  13056.             ordinal = "th";
  13057.             break;
  13058.         case 6:
  13059.             ordinal = "th";
  13060.             break;
  13061.         case 7:
  13062.             ordinal = "th";
  13063.             break;
  13064.         case 8:
  13065.             ordinal = "th";
  13066.             break;
  13067.         case 9:
  13068.             ordinal = "th";
  13069.             break;
  13070.         case 0:
  13071.             ordinal = "th";
  13072.             break;
  13073.         }
  13074.         cout << ordinal;
  13075.         cout << " number.";
  13076.         cout << endl;
  13077.         cout << ">> ";
  13078.         cin  >> entry;
  13079.         cin_is_good = cin.good();
  13080.         cin_isnt_good = ! cin_is_good;
  13081.         if( cin_isnt_good )
  13082.         {
  13083.             BadEntry err;
  13084.             throw( err );
  13085.         }
  13086.         outFile << entry;
  13087.         outFile << ' ';
  13088.     }
  13089.     if( j < number_of_entries )
  13090.     {
  13091.         ++j;
  13092.         ones_digit = j % 10;
  13093.         cout << "Please input the ";
  13094.         cout << j;
  13095.         switch( ones_digit )
  13096.         {
  13097.         case 1:
  13098.             ordinal = "st";
  13099.             break;
  13100.         case 2:
  13101.             ordinal = "nd";
  13102.             break;
  13103.         case 3:
  13104.             ordinal = "rd";
  13105.             break;
  13106.         case 4:
  13107.             ordinal = "th";
  13108.             break;
  13109.         case 5:
  13110.             ordinal = "th";
  13111.             break;
  13112.         case 6:
  13113.             ordinal = "th";
  13114.             break;
  13115.         case 7:
  13116.             ordinal = "th";
  13117.             break;
  13118.         case 8:
  13119.             ordinal = "th";
  13120.             break;
  13121.         case 9:
  13122.             ordinal = "th";
  13123.             break;
  13124.         case 0:
  13125.             ordinal = "th";
  13126.             break;
  13127.         }
  13128.         cout << ordinal;
  13129.         cout << " number.";
  13130.         cout << endl;
  13131.         cout << ">> ";
  13132.         cin  >> entry;
  13133.         cin_is_good = cin.good();
  13134.         cin_isnt_good = ! cin_is_good;
  13135.         if( cin_isnt_good )
  13136.         {
  13137.             BadEntry err;
  13138.             throw( err );
  13139.         }
  13140.         outFile << entry;
  13141.         outFile << ' ';
  13142.     }
  13143.     if( j < number_of_entries )
  13144.     {
  13145.         ++j;
  13146.         ones_digit = j % 10;
  13147.         cout << "Please input the ";
  13148.         cout << j;
  13149.         switch( ones_digit )
  13150.         {
  13151.         case 1:
  13152.             ordinal = "st";
  13153.             break;
  13154.         case 2:
  13155.             ordinal = "nd";
  13156.             break;
  13157.         case 3:
  13158.             ordinal = "rd";
  13159.             break;
  13160.         case 4:
  13161.             ordinal = "th";
  13162.             break;
  13163.         case 5:
  13164.             ordinal = "th";
  13165.             break;
  13166.         case 6:
  13167.             ordinal = "th";
  13168.             break;
  13169.         case 7:
  13170.             ordinal = "th";
  13171.             break;
  13172.         case 8:
  13173.             ordinal = "th";
  13174.             break;
  13175.         case 9:
  13176.             ordinal = "th";
  13177.             break;
  13178.         case 0:
  13179.             ordinal = "th";
  13180.             break;
  13181.         }
  13182.         cout << ordinal;
  13183.         cout << " number.";
  13184.         cout << endl;
  13185.         cout << ">> ";
  13186.         cin  >> entry;
  13187.         cin_is_good = cin.good();
  13188.         cin_isnt_good = ! cin_is_good;
  13189.         if( cin_isnt_good )
  13190.         {
  13191.             BadEntry err;
  13192.             throw( err );
  13193.         }
  13194.         outFile << entry;
  13195.         outFile << ' ';
  13196.     }
  13197.     if( j < number_of_entries )
  13198.     {
  13199.         ++j;
  13200.         ones_digit = j % 10;
  13201.         cout << "Please input the ";
  13202.         cout << j;
  13203.         switch( ones_digit )
  13204.         {
  13205.         case 1:
  13206.             ordinal = "st";
  13207.             break;
  13208.         case 2:
  13209.             ordinal = "nd";
  13210.             break;
  13211.         case 3:
  13212.             ordinal = "rd";
  13213.             break;
  13214.         case 4:
  13215.             ordinal = "th";
  13216.             break;
  13217.         case 5:
  13218.             ordinal = "th";
  13219.             break;
  13220.         case 6:
  13221.             ordinal = "th";
  13222.             break;
  13223.         case 7:
  13224.             ordinal = "th";
  13225.             break;
  13226.         case 8:
  13227.             ordinal = "th";
  13228.             break;
  13229.         case 9:
  13230.             ordinal = "th";
  13231.             break;
  13232.         case 0:
  13233.             ordinal = "th";
  13234.             break;
  13235.         }
  13236.         cout << ordinal;
  13237.         cout << " number.";
  13238.         cout << endl;
  13239.         cout << ">> ";
  13240.         cin  >> entry;
  13241.         cin_is_good = cin.good();
  13242.         cin_isnt_good = ! cin_is_good;
  13243.         if( cin_isnt_good )
  13244.         {
  13245.             BadEntry err;
  13246.             throw( err );
  13247.         }
  13248.         outFile << entry;
  13249.         outFile << ' ';
  13250.     }
  13251.     if( j < number_of_entries )
  13252.     {
  13253.         ++j;
  13254.         ones_digit = j % 10;
  13255.         cout << "Please input the ";
  13256.         cout << j;
  13257.         switch( ones_digit )
  13258.         {
  13259.         case 1:
  13260.             ordinal = "st";
  13261.             break;
  13262.         case 2:
  13263.             ordinal = "nd";
  13264.             break;
  13265.         case 3:
  13266.             ordinal = "rd";
  13267.             break;
  13268.         case 4:
  13269.             ordinal = "th";
  13270.             break;
  13271.         case 5:
  13272.             ordinal = "th";
  13273.             break;
  13274.         case 6:
  13275.             ordinal = "th";
  13276.             break;
  13277.         case 7:
  13278.             ordinal = "th";
  13279.             break;
  13280.         case 8:
  13281.             ordinal = "th";
  13282.             break;
  13283.         case 9:
  13284.             ordinal = "th";
  13285.             break;
  13286.         case 0:
  13287.             ordinal = "th";
  13288.             break;
  13289.         }
  13290.         cout << ordinal;
  13291.         cout << " number.";
  13292.         cout << endl;
  13293.         cout << ">> ";
  13294.         cin  >> entry;
  13295.         cin_is_good = cin.good();
  13296.         cin_isnt_good = ! cin_is_good;
  13297.         if( cin_isnt_good )
  13298.         {
  13299.             BadEntry err;
  13300.             throw( err );
  13301.         }
  13302.         outFile << entry;
  13303.         outFile << ' ';
  13304.     }
  13305.     if( j < number_of_entries )
  13306.     {
  13307.         ++j;
  13308.         ones_digit = j % 10;
  13309.         cout << "Please input the ";
  13310.         cout << j;
  13311.         switch( ones_digit )
  13312.         {
  13313.         case 1:
  13314.             ordinal = "st";
  13315.             break;
  13316.         case 2:
  13317.             ordinal = "nd";
  13318.             break;
  13319.         case 3:
  13320.             ordinal = "rd";
  13321.             break;
  13322.         case 4:
  13323.             ordinal = "th";
  13324.             break;
  13325.         case 5:
  13326.             ordinal = "th";
  13327.             break;
  13328.         case 6:
  13329.             ordinal = "th";
  13330.             break;
  13331.         case 7:
  13332.             ordinal = "th";
  13333.             break;
  13334.         case 8:
  13335.             ordinal = "th";
  13336.             break;
  13337.         case 9:
  13338.             ordinal = "th";
  13339.             break;
  13340.         case 0:
  13341.             ordinal = "th";
  13342.             break;
  13343.         }
  13344.         cout << ordinal;
  13345.         cout << " number.";
  13346.         cout << endl;
  13347.         cout << ">> ";
  13348.         cin  >> entry;
  13349.         cin_is_good = cin.good();
  13350.         cin_isnt_good = ! cin_is_good;
  13351.         if( cin_isnt_good )
  13352.         {
  13353.             BadEntry err;
  13354.             throw( err );
  13355.         }
  13356.         outFile << entry;
  13357.         outFile << ' ';
  13358.     }
  13359.     if( j < number_of_entries )
  13360.     {
  13361.         ++j;
  13362.         ones_digit = j % 10;
  13363.         cout << "Please input the ";
  13364.         cout << j;
  13365.         switch( ones_digit )
  13366.         {
  13367.         case 1:
  13368.             ordinal = "st";
  13369.             break;
  13370.         case 2:
  13371.             ordinal = "nd";
  13372.             break;
  13373.         case 3:
  13374.             ordinal = "rd";
  13375.             break;
  13376.         case 4:
  13377.             ordinal = "th";
  13378.             break;
  13379.         case 5:
  13380.             ordinal = "th";
  13381.             break;
  13382.         case 6:
  13383.             ordinal = "th";
  13384.             break;
  13385.         case 7:
  13386.             ordinal = "th";
  13387.             break;
  13388.         case 8:
  13389.             ordinal = "th";
  13390.             break;
  13391.         case 9:
  13392.             ordinal = "th";
  13393.             break;
  13394.         case 0:
  13395.             ordinal = "th";
  13396.             break;
  13397.         }
  13398.         cout << ordinal;
  13399.         cout << " number.";
  13400.         cout << endl;
  13401.         cout << ">> ";
  13402.         cin  >> entry;
  13403.         cin_is_good = cin.good();
  13404.         cin_isnt_good = ! cin_is_good;
  13405.         if( cin_isnt_good )
  13406.         {
  13407.             BadEntry err;
  13408.             throw( err );
  13409.         }
  13410.         outFile << entry;
  13411.         outFile << ' ';
  13412.     }
  13413.     if( j < number_of_entries )
  13414.     {
  13415.         ++j;
  13416.         ones_digit = j % 10;
  13417.         cout << "Please input the ";
  13418.         cout << j;
  13419.         switch( ones_digit )
  13420.         {
  13421.         case 1:
  13422.             ordinal = "st";
  13423.             break;
  13424.         case 2:
  13425.             ordinal = "nd";
  13426.             break;
  13427.         case 3:
  13428.             ordinal = "rd";
  13429.             break;
  13430.         case 4:
  13431.             ordinal = "th";
  13432.             break;
  13433.         case 5:
  13434.             ordinal = "th";
  13435.             break;
  13436.         case 6:
  13437.             ordinal = "th";
  13438.             break;
  13439.         case 7:
  13440.             ordinal = "th";
  13441.             break;
  13442.         case 8:
  13443.             ordinal = "th";
  13444.             break;
  13445.         case 9:
  13446.             ordinal = "th";
  13447.             break;
  13448.         case 0:
  13449.             ordinal = "th";
  13450.             break;
  13451.         }
  13452.         cout << ordinal;
  13453.         cout << " number.";
  13454.         cout << endl;
  13455.         cout << ">> ";
  13456.         cin  >> entry;
  13457.         cin_is_good = cin.good();
  13458.         cin_isnt_good = ! cin_is_good;
  13459.         if( cin_isnt_good )
  13460.         {
  13461.             BadEntry err;
  13462.             throw( err );
  13463.         }
  13464.         outFile << entry;
  13465.         outFile << ' ';
  13466.     }
  13467.     if( j < number_of_entries )
  13468.     {
  13469.         ++j;
  13470.         ones_digit = j % 10;
  13471.         cout << "Please input the ";
  13472.         cout << j;
  13473.         switch( ones_digit )
  13474.         {
  13475.         case 1:
  13476.             ordinal = "st";
  13477.             break;
  13478.         case 2:
  13479.             ordinal = "nd";
  13480.             break;
  13481.         case 3:
  13482.             ordinal = "rd";
  13483.             break;
  13484.         case 4:
  13485.             ordinal = "th";
  13486.             break;
  13487.         case 5:
  13488.             ordinal = "th";
  13489.             break;
  13490.         case 6:
  13491.             ordinal = "th";
  13492.             break;
  13493.         case 7:
  13494.             ordinal = "th";
  13495.             break;
  13496.         case 8:
  13497.             ordinal = "th";
  13498.             break;
  13499.         case 9:
  13500.             ordinal = "th";
  13501.             break;
  13502.         case 0:
  13503.             ordinal = "th";
  13504.             break;
  13505.         }
  13506.         cout << ordinal;
  13507.         cout << " number.";
  13508.         cout << endl;
  13509.         cout << ">> ";
  13510.         cin  >> entry;
  13511.         cin_is_good = cin.good();
  13512.         cin_isnt_good = ! cin_is_good;
  13513.         if( cin_isnt_good )
  13514.         {
  13515.             BadEntry err;
  13516.             throw( err );
  13517.         }
  13518.         outFile << entry;
  13519.         outFile << ' ';
  13520.     }
  13521.     if( j < number_of_entries )
  13522.     {
  13523.         ++j;
  13524.         ones_digit = j % 10;
  13525.         cout << "Please input the ";
  13526.         cout << j;
  13527.         switch( ones_digit )
  13528.         {
  13529.         case 1:
  13530.             ordinal = "st";
  13531.             break;
  13532.         case 2:
  13533.             ordinal = "nd";
  13534.             break;
  13535.         case 3:
  13536.             ordinal = "rd";
  13537.             break;
  13538.         case 4:
  13539.             ordinal = "th";
  13540.             break;
  13541.         case 5:
  13542.             ordinal = "th";
  13543.             break;
  13544.         case 6:
  13545.             ordinal = "th";
  13546.             break;
  13547.         case 7:
  13548.             ordinal = "th";
  13549.             break;
  13550.         case 8:
  13551.             ordinal = "th";
  13552.             break;
  13553.         case 9:
  13554.             ordinal = "th";
  13555.             break;
  13556.         case 0:
  13557.             ordinal = "th";
  13558.             break;
  13559.         }
  13560.         cout << ordinal;
  13561.         cout << " number.";
  13562.         cout << endl;
  13563.         cout << ">> ";
  13564.         cin  >> entry;
  13565.         cin_is_good = cin.good();
  13566.         cin_isnt_good = ! cin_is_good;
  13567.         if( cin_isnt_good )
  13568.         {
  13569.             BadEntry err;
  13570.             throw( err );
  13571.         }
  13572.         outFile << entry;
  13573.         outFile << ' ';
  13574.     }
  13575.     if( j < number_of_entries )
  13576.     {
  13577.         ++j;
  13578.         ones_digit = j % 10;
  13579.         cout << "Please input the ";
  13580.         cout << j;
  13581.         switch( ones_digit )
  13582.         {
  13583.         case 1:
  13584.             ordinal = "st";
  13585.             break;
  13586.         case 2:
  13587.             ordinal = "nd";
  13588.             break;
  13589.         case 3:
  13590.             ordinal = "rd";
  13591.             break;
  13592.         case 4:
  13593.             ordinal = "th";
  13594.             break;
  13595.         case 5:
  13596.             ordinal = "th";
  13597.             break;
  13598.         case 6:
  13599.             ordinal = "th";
  13600.             break;
  13601.         case 7:
  13602.             ordinal = "th";
  13603.             break;
  13604.         case 8:
  13605.             ordinal = "th";
  13606.             break;
  13607.         case 9:
  13608.             ordinal = "th";
  13609.             break;
  13610.         case 0:
  13611.             ordinal = "th";
  13612.             break;
  13613.         }
  13614.         cout << ordinal;
  13615.         cout << " number.";
  13616.         cout << endl;
  13617.         cout << ">> ";
  13618.         cin  >> entry;
  13619.         cin_is_good = cin.good();
  13620.         cin_isnt_good = ! cin_is_good;
  13621.         if( cin_isnt_good )
  13622.         {
  13623.             BadEntry err;
  13624.             throw( err );
  13625.         }
  13626.         outFile << entry;
  13627.         outFile << ' ';
  13628.     }
  13629.     if( j < number_of_entries )
  13630.     {
  13631.         ++j;
  13632.         ones_digit = j % 10;
  13633.         cout << "Please input the ";
  13634.         cout << j;
  13635.         switch( ones_digit )
  13636.         {
  13637.         case 1:
  13638.             ordinal = "st";
  13639.             break;
  13640.         case 2:
  13641.             ordinal = "nd";
  13642.             break;
  13643.         case 3:
  13644.             ordinal = "rd";
  13645.             break;
  13646.         case 4:
  13647.             ordinal = "th";
  13648.             break;
  13649.         case 5:
  13650.             ordinal = "th";
  13651.             break;
  13652.         case 6:
  13653.             ordinal = "th";
  13654.             break;
  13655.         case 7:
  13656.             ordinal = "th";
  13657.             break;
  13658.         case 8:
  13659.             ordinal = "th";
  13660.             break;
  13661.         case 9:
  13662.             ordinal = "th";
  13663.             break;
  13664.         case 0:
  13665.             ordinal = "th";
  13666.             break;
  13667.         }
  13668.         cout << ordinal;
  13669.         cout << " number.";
  13670.         cout << endl;
  13671.         cout << ">> ";
  13672.         cin  >> entry;
  13673.         cin_is_good = cin.good();
  13674.         cin_isnt_good = ! cin_is_good;
  13675.         if( cin_isnt_good )
  13676.         {
  13677.             BadEntry err;
  13678.             throw( err );
  13679.         }
  13680.         outFile << entry;
  13681.         outFile << ' ';
  13682.     }
  13683.     if( j < number_of_entries )
  13684.     {
  13685.         ++j;
  13686.         ones_digit = j % 10;
  13687.         cout << "Please input the ";
  13688.         cout << j;
  13689.         switch( ones_digit )
  13690.         {
  13691.         case 1:
  13692.             ordinal = "st";
  13693.             break;
  13694.         case 2:
  13695.             ordinal = "nd";
  13696.             break;
  13697.         case 3:
  13698.             ordinal = "rd";
  13699.             break;
  13700.         case 4:
  13701.             ordinal = "th";
  13702.             break;
  13703.         case 5:
  13704.             ordinal = "th";
  13705.             break;
  13706.         case 6:
  13707.             ordinal = "th";
  13708.             break;
  13709.         case 7:
  13710.             ordinal = "th";
  13711.             break;
  13712.         case 8:
  13713.             ordinal = "th";
  13714.             break;
  13715.         case 9:
  13716.             ordinal = "th";
  13717.             break;
  13718.         case 0:
  13719.             ordinal = "th";
  13720.             break;
  13721.         }
  13722.         cout << ordinal;
  13723.         cout << " number.";
  13724.         cout << endl;
  13725.         cout << ">> ";
  13726.         cin  >> entry;
  13727.         cin_is_good = cin.good();
  13728.         cin_isnt_good = ! cin_is_good;
  13729.         if( cin_isnt_good )
  13730.         {
  13731.             BadEntry err;
  13732.             throw( err );
  13733.         }
  13734.         outFile << entry;
  13735.         outFile << ' ';
  13736.     }
  13737.     if( j < number_of_entries )
  13738.     {
  13739.         ++j;
  13740.         ones_digit = j % 10;
  13741.         cout << "Please input the ";
  13742.         cout << j;
  13743.         switch( ones_digit )
  13744.         {
  13745.         case 1:
  13746.             ordinal = "st";
  13747.             break;
  13748.         case 2:
  13749.             ordinal = "nd";
  13750.             break;
  13751.         case 3:
  13752.             ordinal = "rd";
  13753.             break;
  13754.         case 4:
  13755.             ordinal = "th";
  13756.             break;
  13757.         case 5:
  13758.             ordinal = "th";
  13759.             break;
  13760.         case 6:
  13761.             ordinal = "th";
  13762.             break;
  13763.         case 7:
  13764.             ordinal = "th";
  13765.             break;
  13766.         case 8:
  13767.             ordinal = "th";
  13768.             break;
  13769.         case 9:
  13770.             ordinal = "th";
  13771.             break;
  13772.         case 0:
  13773.             ordinal = "th";
  13774.             break;
  13775.         }
  13776.         cout << ordinal;
  13777.         cout << " number.";
  13778.         cout << endl;
  13779.         cout << ">> ";
  13780.         cin  >> entry;
  13781.         cin_is_good = cin.good();
  13782.         cin_isnt_good = ! cin_is_good;
  13783.         if( cin_isnt_good )
  13784.         {
  13785.             BadEntry err;
  13786.             throw( err );
  13787.         }
  13788.         outFile << entry;
  13789.         outFile << ' ';
  13790.     }
  13791.     if( j < number_of_entries )
  13792.     {
  13793.         ++j;
  13794.         ones_digit = j % 10;
  13795.         cout << "Please input the ";
  13796.         cout << j;
  13797.         switch( ones_digit )
  13798.         {
  13799.         case 1:
  13800.             ordinal = "st";
  13801.             break;
  13802.         case 2:
  13803.             ordinal = "nd";
  13804.             break;
  13805.         case 3:
  13806.             ordinal = "rd";
  13807.             break;
  13808.         case 4:
  13809.             ordinal = "th";
  13810.             break;
  13811.         case 5:
  13812.             ordinal = "th";
  13813.             break;
  13814.         case 6:
  13815.             ordinal = "th";
  13816.             break;
  13817.         case 7:
  13818.             ordinal = "th";
  13819.             break;
  13820.         case 8:
  13821.             ordinal = "th";
  13822.             break;
  13823.         case 9:
  13824.             ordinal = "th";
  13825.             break;
  13826.         case 0:
  13827.             ordinal = "th";
  13828.             break;
  13829.         }
  13830.         cout << ordinal;
  13831.         cout << " number.";
  13832.         cout << endl;
  13833.         cout << ">> ";
  13834.         cin  >> entry;
  13835.         cin_is_good = cin.good();
  13836.         cin_isnt_good = ! cin_is_good;
  13837.         if( cin_isnt_good )
  13838.         {
  13839.             BadEntry err;
  13840.             throw( err );
  13841.         }
  13842.         outFile << entry;
  13843.         outFile << ' ';
  13844.     }
  13845.     if( j < number_of_entries )
  13846.     {
  13847.         ++j;
  13848.         ones_digit = j % 10;
  13849.         cout << "Please input the ";
  13850.         cout << j;
  13851.         switch( ones_digit )
  13852.         {
  13853.         case 1:
  13854.             ordinal = "st";
  13855.             break;
  13856.         case 2:
  13857.             ordinal = "nd";
  13858.             break;
  13859.         case 3:
  13860.             ordinal = "rd";
  13861.             break;
  13862.         case 4:
  13863.             ordinal = "th";
  13864.             break;
  13865.         case 5:
  13866.             ordinal = "th";
  13867.             break;
  13868.         case 6:
  13869.             ordinal = "th";
  13870.             break;
  13871.         case 7:
  13872.             ordinal = "th";
  13873.             break;
  13874.         case 8:
  13875.             ordinal = "th";
  13876.             break;
  13877.         case 9:
  13878.             ordinal = "th";
  13879.             break;
  13880.         case 0:
  13881.             ordinal = "th";
  13882.             break;
  13883.         }
  13884.         cout << ordinal;
  13885.         cout << " number.";
  13886.         cout << endl;
  13887.         cout << ">> ";
  13888.         cin  >> entry;
  13889.         cin_is_good = cin.good();
  13890.         cin_isnt_good = ! cin_is_good;
  13891.         if( cin_isnt_good )
  13892.         {
  13893.             BadEntry err;
  13894.             throw( err );
  13895.         }
  13896.         outFile << entry;
  13897.         outFile << ' ';
  13898.     }
  13899.     if( j < number_of_entries )
  13900.     {
  13901.         ++j;
  13902.         ones_digit = j % 10;
  13903.         cout << "Please input the ";
  13904.         cout << j;
  13905.         switch( ones_digit )
  13906.         {
  13907.         case 1:
  13908.             ordinal = "st";
  13909.             break;
  13910.         case 2:
  13911.             ordinal = "nd";
  13912.             break;
  13913.         case 3:
  13914.             ordinal = "rd";
  13915.             break;
  13916.         case 4:
  13917.             ordinal = "th";
  13918.             break;
  13919.         case 5:
  13920.             ordinal = "th";
  13921.             break;
  13922.         case 6:
  13923.             ordinal = "th";
  13924.             break;
  13925.         case 7:
  13926.             ordinal = "th";
  13927.             break;
  13928.         case 8:
  13929.             ordinal = "th";
  13930.             break;
  13931.         case 9:
  13932.             ordinal = "th";
  13933.             break;
  13934.         case 0:
  13935.             ordinal = "th";
  13936.             break;
  13937.         }
  13938.         cout << ordinal;
  13939.         cout << " number.";
  13940.         cout << endl;
  13941.         cout << ">> ";
  13942.         cin  >> entry;
  13943.         cin_is_good = cin.good();
  13944.         cin_isnt_good = ! cin_is_good;
  13945.         if( cin_isnt_good )
  13946.         {
  13947.             BadEntry err;
  13948.             throw( err );
  13949.         }
  13950.         outFile << entry;
  13951.         outFile << ' ';
  13952.     }
  13953.     if( j < number_of_entries )
  13954.     {
  13955.         ++j;
  13956.         ones_digit = j % 10;
  13957.         cout << "Please input the ";
  13958.         cout << j;
  13959.         switch( ones_digit )
  13960.         {
  13961.         case 1:
  13962.             ordinal = "st";
  13963.             break;
  13964.         case 2:
  13965.             ordinal = "nd";
  13966.             break;
  13967.         case 3:
  13968.             ordinal = "rd";
  13969.             break;
  13970.         case 4:
  13971.             ordinal = "th";
  13972.             break;
  13973.         case 5:
  13974.             ordinal = "th";
  13975.             break;
  13976.         case 6:
  13977.             ordinal = "th";
  13978.             break;
  13979.         case 7:
  13980.             ordinal = "th";
  13981.             break;
  13982.         case 8:
  13983.             ordinal = "th";
  13984.             break;
  13985.         case 9:
  13986.             ordinal = "th";
  13987.             break;
  13988.         case 0:
  13989.             ordinal = "th";
  13990.             break;
  13991.         }
  13992.         cout << ordinal;
  13993.         cout << " number.";
  13994.         cout << endl;
  13995.         cout << ">> ";
  13996.         cin  >> entry;
  13997.         cin_is_good = cin.good();
  13998.         cin_isnt_good = ! cin_is_good;
  13999.         if( cin_isnt_good )
  14000.         {
  14001.             BadEntry err;
  14002.             throw( err );
  14003.         }
  14004.         outFile << entry;
  14005.         outFile << ' ';
  14006.     }
  14007.     if( j < number_of_entries )
  14008.     {
  14009.         ++j;
  14010.         ones_digit = j % 10;
  14011.         cout << "Please input the ";
  14012.         cout << j;
  14013.         switch( ones_digit )
  14014.         {
  14015.         case 1:
  14016.             ordinal = "st";
  14017.             break;
  14018.         case 2:
  14019.             ordinal = "nd";
  14020.             break;
  14021.         case 3:
  14022.             ordinal = "rd";
  14023.             break;
  14024.         case 4:
  14025.             ordinal = "th";
  14026.             break;
  14027.         case 5:
  14028.             ordinal = "th";
  14029.             break;
  14030.         case 6:
  14031.             ordinal = "th";
  14032.             break;
  14033.         case 7:
  14034.             ordinal = "th";
  14035.             break;
  14036.         case 8:
  14037.             ordinal = "th";
  14038.             break;
  14039.         case 9:
  14040.             ordinal = "th";
  14041.             break;
  14042.         case 0:
  14043.             ordinal = "th";
  14044.             break;
  14045.         }
  14046.         cout << ordinal;
  14047.         cout << " number.";
  14048.         cout << endl;
  14049.         cout << ">> ";
  14050.         cin  >> entry;
  14051.         cin_is_good = cin.good();
  14052.         cin_isnt_good = ! cin_is_good;
  14053.         if( cin_isnt_good )
  14054.         {
  14055.             BadEntry err;
  14056.             throw( err );
  14057.         }
  14058.         outFile << entry;
  14059.         outFile << ' ';
  14060.     }
  14061.     if( j < number_of_entries )
  14062.     {
  14063.         ++j;
  14064.         ones_digit = j % 10;
  14065.         cout << "Please input the ";
  14066.         cout << j;
  14067.         switch( ones_digit )
  14068.         {
  14069.         case 1:
  14070.             ordinal = "st";
  14071.             break;
  14072.         case 2:
  14073.             ordinal = "nd";
  14074.             break;
  14075.         case 3:
  14076.             ordinal = "rd";
  14077.             break;
  14078.         case 4:
  14079.             ordinal = "th";
  14080.             break;
  14081.         case 5:
  14082.             ordinal = "th";
  14083.             break;
  14084.         case 6:
  14085.             ordinal = "th";
  14086.             break;
  14087.         case 7:
  14088.             ordinal = "th";
  14089.             break;
  14090.         case 8:
  14091.             ordinal = "th";
  14092.             break;
  14093.         case 9:
  14094.             ordinal = "th";
  14095.             break;
  14096.         case 0:
  14097.             ordinal = "th";
  14098.             break;
  14099.         }
  14100.         cout << ordinal;
  14101.         cout << " number.";
  14102.         cout << endl;
  14103.         cout << ">> ";
  14104.         cin  >> entry;
  14105.         cin_is_good = cin.good();
  14106.         cin_isnt_good = ! cin_is_good;
  14107.         if( cin_isnt_good )
  14108.         {
  14109.             BadEntry err;
  14110.             throw( err );
  14111.         }
  14112.         outFile << entry;
  14113.         outFile << ' ';
  14114.     }
  14115.     if( j < number_of_entries )
  14116.     {
  14117.         ++j;
  14118.         ones_digit = j % 10;
  14119.         cout << "Please input the ";
  14120.         cout << j;
  14121.         switch( ones_digit )
  14122.         {
  14123.         case 1:
  14124.             ordinal = "st";
  14125.             break;
  14126.         case 2:
  14127.             ordinal = "nd";
  14128.             break;
  14129.         case 3:
  14130.             ordinal = "rd";
  14131.             break;
  14132.         case 4:
  14133.             ordinal = "th";
  14134.             break;
  14135.         case 5:
  14136.             ordinal = "th";
  14137.             break;
  14138.         case 6:
  14139.             ordinal = "th";
  14140.             break;
  14141.         case 7:
  14142.             ordinal = "th";
  14143.             break;
  14144.         case 8:
  14145.             ordinal = "th";
  14146.             break;
  14147.         case 9:
  14148.             ordinal = "th";
  14149.             break;
  14150.         case 0:
  14151.             ordinal = "th";
  14152.             break;
  14153.         }
  14154.         cout << ordinal;
  14155.         cout << " number.";
  14156.         cout << endl;
  14157.         cout << ">> ";
  14158.         cin  >> entry;
  14159.         cin_is_good = cin.good();
  14160.         cin_isnt_good = ! cin_is_good;
  14161.         if( cin_isnt_good )
  14162.         {
  14163.             BadEntry err;
  14164.             throw( err );
  14165.         }
  14166.         outFile << entry;
  14167.         outFile << ' ';
  14168.     }
  14169.     if( j < number_of_entries )
  14170.     {
  14171.         ++j;
  14172.         ones_digit = j % 10;
  14173.         cout << "Please input the ";
  14174.         cout << j;
  14175.         switch( ones_digit )
  14176.         {
  14177.         case 1:
  14178.             ordinal = "st";
  14179.             break;
  14180.         case 2:
  14181.             ordinal = "nd";
  14182.             break;
  14183.         case 3:
  14184.             ordinal = "rd";
  14185.             break;
  14186.         case 4:
  14187.             ordinal = "th";
  14188.             break;
  14189.         case 5:
  14190.             ordinal = "th";
  14191.             break;
  14192.         case 6:
  14193.             ordinal = "th";
  14194.             break;
  14195.         case 7:
  14196.             ordinal = "th";
  14197.             break;
  14198.         case 8:
  14199.             ordinal = "th";
  14200.             break;
  14201.         case 9:
  14202.             ordinal = "th";
  14203.             break;
  14204.         case 0:
  14205.             ordinal = "th";
  14206.             break;
  14207.         }
  14208.         cout << ordinal;
  14209.         cout << " number.";
  14210.         cout << endl;
  14211.         cout << ">> ";
  14212.         cin  >> entry;
  14213.         cin_is_good = cin.good();
  14214.         cin_isnt_good = ! cin_is_good;
  14215.         if( cin_isnt_good )
  14216.         {
  14217.             BadEntry err;
  14218.             throw( err );
  14219.         }
  14220.         outFile << entry;
  14221.         outFile << ' ';
  14222.     }
  14223.     if( j < number_of_entries )
  14224.     {
  14225.         ++j;
  14226.         ones_digit = j % 10;
  14227.         cout << "Please input the ";
  14228.         cout << j;
  14229.         switch( ones_digit )
  14230.         {
  14231.         case 1:
  14232.             ordinal = "st";
  14233.             break;
  14234.         case 2:
  14235.             ordinal = "nd";
  14236.             break;
  14237.         case 3:
  14238.             ordinal = "rd";
  14239.             break;
  14240.         case 4:
  14241.             ordinal = "th";
  14242.             break;
  14243.         case 5:
  14244.             ordinal = "th";
  14245.             break;
  14246.         case 6:
  14247.             ordinal = "th";
  14248.             break;
  14249.         case 7:
  14250.             ordinal = "th";
  14251.             break;
  14252.         case 8:
  14253.             ordinal = "th";
  14254.             break;
  14255.         case 9:
  14256.             ordinal = "th";
  14257.             break;
  14258.         case 0:
  14259.             ordinal = "th";
  14260.             break;
  14261.         }
  14262.         cout << ordinal;
  14263.         cout << " number.";
  14264.         cout << endl;
  14265.         cout << ">> ";
  14266.         cin  >> entry;
  14267.         cin_is_good = cin.good();
  14268.         cin_isnt_good = ! cin_is_good;
  14269.         if( cin_isnt_good )
  14270.         {
  14271.             BadEntry err;
  14272.             throw( err );
  14273.         }
  14274.         outFile << entry;
  14275.         outFile << ' ';
  14276.     }
  14277.     if( j < number_of_entries )
  14278.     {
  14279.         ++j;
  14280.         ones_digit = j % 10;
  14281.         cout << "Please input the ";
  14282.         cout << j;
  14283.         switch( ones_digit )
  14284.         {
  14285.         case 1:
  14286.             ordinal = "st";
  14287.             break;
  14288.         case 2:
  14289.             ordinal = "nd";
  14290.             break;
  14291.         case 3:
  14292.             ordinal = "rd";
  14293.             break;
  14294.         case 4:
  14295.             ordinal = "th";
  14296.             break;
  14297.         case 5:
  14298.             ordinal = "th";
  14299.             break;
  14300.         case 6:
  14301.             ordinal = "th";
  14302.             break;
  14303.         case 7:
  14304.             ordinal = "th";
  14305.             break;
  14306.         case 8:
  14307.             ordinal = "th";
  14308.             break;
  14309.         case 9:
  14310.             ordinal = "th";
  14311.             break;
  14312.         case 0:
  14313.             ordinal = "th";
  14314.             break;
  14315.         }
  14316.         cout << ordinal;
  14317.         cout << " number.";
  14318.         cout << endl;
  14319.         cout << ">> ";
  14320.         cin  >> entry;
  14321.         cin_is_good = cin.good();
  14322.         cin_isnt_good = ! cin_is_good;
  14323.         if( cin_isnt_good )
  14324.         {
  14325.             BadEntry err;
  14326.             throw( err );
  14327.         }
  14328.         outFile << entry;
  14329.         outFile << ' ';
  14330.     }
  14331.     if( j < number_of_entries )
  14332.     {
  14333.         ++j;
  14334.         ones_digit = j % 10;
  14335.         cout << "Please input the ";
  14336.         cout << j;
  14337.         switch( ones_digit )
  14338.         {
  14339.         case 1:
  14340.             ordinal = "st";
  14341.             break;
  14342.         case 2:
  14343.             ordinal = "nd";
  14344.             break;
  14345.         case 3:
  14346.             ordinal = "rd";
  14347.             break;
  14348.         case 4:
  14349.             ordinal = "th";
  14350.             break;
  14351.         case 5:
  14352.             ordinal = "th";
  14353.             break;
  14354.         case 6:
  14355.             ordinal = "th";
  14356.             break;
  14357.         case 7:
  14358.             ordinal = "th";
  14359.             break;
  14360.         case 8:
  14361.             ordinal = "th";
  14362.             break;
  14363.         case 9:
  14364.             ordinal = "th";
  14365.             break;
  14366.         case 0:
  14367.             ordinal = "th";
  14368.             break;
  14369.         }
  14370.         cout << ordinal;
  14371.         cout << " number.";
  14372.         cout << endl;
  14373.         cout << ">> ";
  14374.         cin  >> entry;
  14375.         cin_is_good = cin.good();
  14376.         cin_isnt_good = ! cin_is_good;
  14377.         if( cin_isnt_good )
  14378.         {
  14379.             BadEntry err;
  14380.             throw( err );
  14381.         }
  14382.         outFile << entry;
  14383.         outFile << ' ';
  14384.     }
  14385.     if( j < number_of_entries )
  14386.     {
  14387.         ++j;
  14388.         ones_digit = j % 10;
  14389.         cout << "Please input the ";
  14390.         cout << j;
  14391.         switch( ones_digit )
  14392.         {
  14393.         case 1:
  14394.             ordinal = "st";
  14395.             break;
  14396.         case 2:
  14397.             ordinal = "nd";
  14398.             break;
  14399.         case 3:
  14400.             ordinal = "rd";
  14401.             break;
  14402.         case 4:
  14403.             ordinal = "th";
  14404.             break;
  14405.         case 5:
  14406.             ordinal = "th";
  14407.             break;
  14408.         case 6:
  14409.             ordinal = "th";
  14410.             break;
  14411.         case 7:
  14412.             ordinal = "th";
  14413.             break;
  14414.         case 8:
  14415.             ordinal = "th";
  14416.             break;
  14417.         case 9:
  14418.             ordinal = "th";
  14419.             break;
  14420.         case 0:
  14421.             ordinal = "th";
  14422.             break;
  14423.         }
  14424.         cout << ordinal;
  14425.         cout << " number.";
  14426.         cout << endl;
  14427.         cout << ">> ";
  14428.         cin  >> entry;
  14429.         cin_is_good = cin.good();
  14430.         cin_isnt_good = ! cin_is_good;
  14431.         if( cin_isnt_good )
  14432.         {
  14433.             BadEntry err;
  14434.             throw( err );
  14435.         }
  14436.         outFile << entry;
  14437.         outFile << ' ';
  14438.     }
  14439.     if( j < number_of_entries )
  14440.     {
  14441.         ++j;
  14442.         ones_digit = j % 10;
  14443.         cout << "Please input the ";
  14444.         cout << j;
  14445.         switch( ones_digit )
  14446.         {
  14447.         case 1:
  14448.             ordinal = "st";
  14449.             break;
  14450.         case 2:
  14451.             ordinal = "nd";
  14452.             break;
  14453.         case 3:
  14454.             ordinal = "rd";
  14455.             break;
  14456.         case 4:
  14457.             ordinal = "th";
  14458.             break;
  14459.         case 5:
  14460.             ordinal = "th";
  14461.             break;
  14462.         case 6:
  14463.             ordinal = "th";
  14464.             break;
  14465.         case 7:
  14466.             ordinal = "th";
  14467.             break;
  14468.         case 8:
  14469.             ordinal = "th";
  14470.             break;
  14471.         case 9:
  14472.             ordinal = "th";
  14473.             break;
  14474.         case 0:
  14475.             ordinal = "th";
  14476.             break;
  14477.         }
  14478.         cout << ordinal;
  14479.         cout << " number.";
  14480.         cout << endl;
  14481.         cout << ">> ";
  14482.         cin  >> entry;
  14483.         cin_is_good = cin.good();
  14484.         cin_isnt_good = ! cin_is_good;
  14485.         if( cin_isnt_good )
  14486.         {
  14487.             BadEntry err;
  14488.             throw( err );
  14489.         }
  14490.         outFile << entry;
  14491.         outFile << ' ';
  14492.     }
  14493.     if( j < number_of_entries )
  14494.     {
  14495.         ++j;
  14496.         ones_digit = j % 10;
  14497.         cout << "Please input the ";
  14498.         cout << j;
  14499.         switch( ones_digit )
  14500.         {
  14501.         case 1:
  14502.             ordinal = "st";
  14503.             break;
  14504.         case 2:
  14505.             ordinal = "nd";
  14506.             break;
  14507.         case 3:
  14508.             ordinal = "rd";
  14509.             break;
  14510.         case 4:
  14511.             ordinal = "th";
  14512.             break;
  14513.         case 5:
  14514.             ordinal = "th";
  14515.             break;
  14516.         case 6:
  14517.             ordinal = "th";
  14518.             break;
  14519.         case 7:
  14520.             ordinal = "th";
  14521.             break;
  14522.         case 8:
  14523.             ordinal = "th";
  14524.             break;
  14525.         case 9:
  14526.             ordinal = "th";
  14527.             break;
  14528.         case 0:
  14529.             ordinal = "th";
  14530.             break;
  14531.         }
  14532.         cout << ordinal;
  14533.         cout << " number.";
  14534.         cout << endl;
  14535.         cout << ">> ";
  14536.         cin  >> entry;
  14537.         cin_is_good = cin.good();
  14538.         cin_isnt_good = ! cin_is_good;
  14539.         if( cin_isnt_good )
  14540.         {
  14541.             BadEntry err;
  14542.             throw( err );
  14543.         }
  14544.         outFile << entry;
  14545.         outFile << ' ';
  14546.     }
  14547.     if( j < number_of_entries )
  14548.     {
  14549.         ++j;
  14550.         ones_digit = j % 10;
  14551.         cout << "Please input the ";
  14552.         cout << j;
  14553.         switch( ones_digit )
  14554.         {
  14555.         case 1:
  14556.             ordinal = "st";
  14557.             break;
  14558.         case 2:
  14559.             ordinal = "nd";
  14560.             break;
  14561.         case 3:
  14562.             ordinal = "rd";
  14563.             break;
  14564.         case 4:
  14565.             ordinal = "th";
  14566.             break;
  14567.         case 5:
  14568.             ordinal = "th";
  14569.             break;
  14570.         case 6:
  14571.             ordinal = "th";
  14572.             break;
  14573.         case 7:
  14574.             ordinal = "th";
  14575.             break;
  14576.         case 8:
  14577.             ordinal = "th";
  14578.             break;
  14579.         case 9:
  14580.             ordinal = "th";
  14581.             break;
  14582.         case 0:
  14583.             ordinal = "th";
  14584.             break;
  14585.         }
  14586.         cout << ordinal;
  14587.         cout << " number.";
  14588.         cout << endl;
  14589.         cout << ">> ";
  14590.         cin  >> entry;
  14591.         cin_is_good = cin.good();
  14592.         cin_isnt_good = ! cin_is_good;
  14593.         if( cin_isnt_good )
  14594.         {
  14595.             BadEntry err;
  14596.             throw( err );
  14597.         }
  14598.         outFile << entry;
  14599.         outFile << ' ';
  14600.     }
  14601.     if( j < number_of_entries )
  14602.     {
  14603.         ++j;
  14604.         ones_digit = j % 10;
  14605.         cout << "Please input the ";
  14606.         cout << j;
  14607.         switch( ones_digit )
  14608.         {
  14609.         case 1:
  14610.             ordinal = "st";
  14611.             break;
  14612.         case 2:
  14613.             ordinal = "nd";
  14614.             break;
  14615.         case 3:
  14616.             ordinal = "rd";
  14617.             break;
  14618.         case 4:
  14619.             ordinal = "th";
  14620.             break;
  14621.         case 5:
  14622.             ordinal = "th";
  14623.             break;
  14624.         case 6:
  14625.             ordinal = "th";
  14626.             break;
  14627.         case 7:
  14628.             ordinal = "th";
  14629.             break;
  14630.         case 8:
  14631.             ordinal = "th";
  14632.             break;
  14633.         case 9:
  14634.             ordinal = "th";
  14635.             break;
  14636.         case 0:
  14637.             ordinal = "th";
  14638.             break;
  14639.         }
  14640.         cout << ordinal;
  14641.         cout << " number.";
  14642.         cout << endl;
  14643.         cout << ">> ";
  14644.         cin  >> entry;
  14645.         cin_is_good = cin.good();
  14646.         cin_isnt_good = ! cin_is_good;
  14647.         if( cin_isnt_good )
  14648.         {
  14649.             BadEntry err;
  14650.             throw( err );
  14651.         }
  14652.         outFile << entry;
  14653.         outFile << ' ';
  14654.     }
  14655.     if( j < number_of_entries )
  14656.     {
  14657.         ++j;
  14658.         ones_digit = j % 10;
  14659.         cout << "Please input the ";
  14660.         cout << j;
  14661.         switch( ones_digit )
  14662.         {
  14663.         case 1:
  14664.             ordinal = "st";
  14665.             break;
  14666.         case 2:
  14667.             ordinal = "nd";
  14668.             break;
  14669.         case 3:
  14670.             ordinal = "rd";
  14671.             break;
  14672.         case 4:
  14673.             ordinal = "th";
  14674.             break;
  14675.         case 5:
  14676.             ordinal = "th";
  14677.             break;
  14678.         case 6:
  14679.             ordinal = "th";
  14680.             break;
  14681.         case 7:
  14682.             ordinal = "th";
  14683.             break;
  14684.         case 8:
  14685.             ordinal = "th";
  14686.             break;
  14687.         case 9:
  14688.             ordinal = "th";
  14689.             break;
  14690.         case 0:
  14691.             ordinal = "th";
  14692.             break;
  14693.         }
  14694.         cout << ordinal;
  14695.         cout << " number.";
  14696.         cout << endl;
  14697.         cout << ">> ";
  14698.         cin  >> entry;
  14699.         cin_is_good = cin.good();
  14700.         cin_isnt_good = ! cin_is_good;
  14701.         if( cin_isnt_good )
  14702.         {
  14703.             BadEntry err;
  14704.             throw( err );
  14705.         }
  14706.         outFile << entry;
  14707.         outFile << ' ';
  14708.     }
  14709.     if( j < number_of_entries )
  14710.     {
  14711.         ++j;
  14712.         ones_digit = j % 10;
  14713.         cout << "Please input the ";
  14714.         cout << j;
  14715.         switch( ones_digit )
  14716.         {
  14717.         case 1:
  14718.             ordinal = "st";
  14719.             break;
  14720.         case 2:
  14721.             ordinal = "nd";
  14722.             break;
  14723.         case 3:
  14724.             ordinal = "rd";
  14725.             break;
  14726.         case 4:
  14727.             ordinal = "th";
  14728.             break;
  14729.         case 5:
  14730.             ordinal = "th";
  14731.             break;
  14732.         case 6:
  14733.             ordinal = "th";
  14734.             break;
  14735.         case 7:
  14736.             ordinal = "th";
  14737.             break;
  14738.         case 8:
  14739.             ordinal = "th";
  14740.             break;
  14741.         case 9:
  14742.             ordinal = "th";
  14743.             break;
  14744.         case 0:
  14745.             ordinal = "th";
  14746.             break;
  14747.         }
  14748.         cout << ordinal;
  14749.         cout << " number.";
  14750.         cout << endl;
  14751.         cout << ">> ";
  14752.         cin  >> entry;
  14753.         cin_is_good = cin.good();
  14754.         cin_isnt_good = ! cin_is_good;
  14755.         if( cin_isnt_good )
  14756.         {
  14757.             BadEntry err;
  14758.             throw( err );
  14759.         }
  14760.         outFile << entry;
  14761.         outFile << ' ';
  14762.     }
  14763.     if( j < number_of_entries )
  14764.     {
  14765.         ++j;
  14766.         ones_digit = j % 10;
  14767.         cout << "Please input the ";
  14768.         cout << j;
  14769.         switch( ones_digit )
  14770.         {
  14771.         case 1:
  14772.             ordinal = "st";
  14773.             break;
  14774.         case 2:
  14775.             ordinal = "nd";
  14776.             break;
  14777.         case 3:
  14778.             ordinal = "rd";
  14779.             break;
  14780.         case 4:
  14781.             ordinal = "th";
  14782.             break;
  14783.         case 5:
  14784.             ordinal = "th";
  14785.             break;
  14786.         case 6:
  14787.             ordinal = "th";
  14788.             break;
  14789.         case 7:
  14790.             ordinal = "th";
  14791.             break;
  14792.         case 8:
  14793.             ordinal = "th";
  14794.             break;
  14795.         case 9:
  14796.             ordinal = "th";
  14797.             break;
  14798.         case 0:
  14799.             ordinal = "th";
  14800.             break;
  14801.         }
  14802.         cout << ordinal;
  14803.         cout << " number.";
  14804.         cout << endl;
  14805.         cout << ">> ";
  14806.         cin  >> entry;
  14807.         cin_is_good = cin.good();
  14808.         cin_isnt_good = ! cin_is_good;
  14809.         if( cin_isnt_good )
  14810.         {
  14811.             BadEntry err;
  14812.             throw( err );
  14813.         }
  14814.         outFile << entry;
  14815.         outFile << ' ';
  14816.     }
  14817.     if( j < number_of_entries )
  14818.     {
  14819.         ++j;
  14820.         ones_digit = j % 10;
  14821.         cout << "Please input the ";
  14822.         cout << j;
  14823.         switch( ones_digit )
  14824.         {
  14825.         case 1:
  14826.             ordinal = "st";
  14827.             break;
  14828.         case 2:
  14829.             ordinal = "nd";
  14830.             break;
  14831.         case 3:
  14832.             ordinal = "rd";
  14833.             break;
  14834.         case 4:
  14835.             ordinal = "th";
  14836.             break;
  14837.         case 5:
  14838.             ordinal = "th";
  14839.             break;
  14840.         case 6:
  14841.             ordinal = "th";
  14842.             break;
  14843.         case 7:
  14844.             ordinal = "th";
  14845.             break;
  14846.         case 8:
  14847.             ordinal = "th";
  14848.             break;
  14849.         case 9:
  14850.             ordinal = "th";
  14851.             break;
  14852.         case 0:
  14853.             ordinal = "th";
  14854.             break;
  14855.         }
  14856.         cout << ordinal;
  14857.         cout << " number.";
  14858.         cout << endl;
  14859.         cout << ">> ";
  14860.         cin  >> entry;
  14861.         cin_is_good = cin.good();
  14862.         cin_isnt_good = ! cin_is_good;
  14863.         if( cin_isnt_good )
  14864.         {
  14865.             BadEntry err;
  14866.             throw( err );
  14867.         }
  14868.         outFile << entry;
  14869.         outFile << ' ';
  14870.     }
  14871.     if( j < number_of_entries )
  14872.     {
  14873.         ++j;
  14874.         ones_digit = j % 10;
  14875.         cout << "Please input the ";
  14876.         cout << j;
  14877.         switch( ones_digit )
  14878.         {
  14879.         case 1:
  14880.             ordinal = "st";
  14881.             break;
  14882.         case 2:
  14883.             ordinal = "nd";
  14884.             break;
  14885.         case 3:
  14886.             ordinal = "rd";
  14887.             break;
  14888.         case 4:
  14889.             ordinal = "th";
  14890.             break;
  14891.         case 5:
  14892.             ordinal = "th";
  14893.             break;
  14894.         case 6:
  14895.             ordinal = "th";
  14896.             break;
  14897.         case 7:
  14898.             ordinal = "th";
  14899.             break;
  14900.         case 8:
  14901.             ordinal = "th";
  14902.             break;
  14903.         case 9:
  14904.             ordinal = "th";
  14905.             break;
  14906.         case 0:
  14907.             ordinal = "th";
  14908.             break;
  14909.         }
  14910.         cout << ordinal;
  14911.         cout << " number.";
  14912.         cout << endl;
  14913.         cout << ">> ";
  14914.         cin  >> entry;
  14915.         cin_is_good = cin.good();
  14916.         cin_isnt_good = ! cin_is_good;
  14917.         if( cin_isnt_good )
  14918.         {
  14919.             BadEntry err;
  14920.             throw( err );
  14921.         }
  14922.         outFile << entry;
  14923.         outFile << ' ';
  14924.     }
  14925.     if( j < number_of_entries )
  14926.     {
  14927.         ++j;
  14928.         ones_digit = j % 10;
  14929.         cout << "Please input the ";
  14930.         cout << j;
  14931.         switch( ones_digit )
  14932.         {
  14933.         case 1:
  14934.             ordinal = "st";
  14935.             break;
  14936.         case 2:
  14937.             ordinal = "nd";
  14938.             break;
  14939.         case 3:
  14940.             ordinal = "rd";
  14941.             break;
  14942.         case 4:
  14943.             ordinal = "th";
  14944.             break;
  14945.         case 5:
  14946.             ordinal = "th";
  14947.             break;
  14948.         case 6:
  14949.             ordinal = "th";
  14950.             break;
  14951.         case 7:
  14952.             ordinal = "th";
  14953.             break;
  14954.         case 8:
  14955.             ordinal = "th";
  14956.             break;
  14957.         case 9:
  14958.             ordinal = "th";
  14959.             break;
  14960.         case 0:
  14961.             ordinal = "th";
  14962.             break;
  14963.         }
  14964.         cout << ordinal;
  14965.         cout << " number.";
  14966.         cout << endl;
  14967.         cout << ">> ";
  14968.         cin  >> entry;
  14969.         cin_is_good = cin.good();
  14970.         cin_isnt_good = ! cin_is_good;
  14971.         if( cin_isnt_good )
  14972.         {
  14973.             BadEntry err;
  14974.             throw( err );
  14975.         }
  14976.         outFile << entry;
  14977.         outFile << ' ';
  14978.     }
  14979.     if( j < number_of_entries )
  14980.     {
  14981.         ++j;
  14982.         ones_digit = j % 10;
  14983.         cout << "Please input the ";
  14984.         cout << j;
  14985.         switch( ones_digit )
  14986.         {
  14987.         case 1:
  14988.             ordinal = "st";
  14989.             break;
  14990.         case 2:
  14991.             ordinal = "nd";
  14992.             break;
  14993.         case 3:
  14994.             ordinal = "rd";
  14995.             break;
  14996.         case 4:
  14997.             ordinal = "th";
  14998.             break;
  14999.         case 5:
  15000.             ordinal = "th";
  15001.             break;
  15002.         case 6:
  15003.             ordinal = "th";
  15004.             break;
  15005.         case 7:
  15006.             ordinal = "th";
  15007.             break;
  15008.         case 8:
  15009.             ordinal = "th";
  15010.             break;
  15011.         case 9:
  15012.             ordinal = "th";
  15013.             break;
  15014.         case 0:
  15015.             ordinal = "th";
  15016.             break;
  15017.         }
  15018.         cout << ordinal;
  15019.         cout << " number.";
  15020.         cout << endl;
  15021.         cout << ">> ";
  15022.         cin  >> entry;
  15023.         cin_is_good = cin.good();
  15024.         cin_isnt_good = ! cin_is_good;
  15025.         if( cin_isnt_good )
  15026.         {
  15027.             BadEntry err;
  15028.             throw( err );
  15029.         }
  15030.         outFile << entry;
  15031.         outFile << ' ';
  15032.     }
  15033.     if( j < number_of_entries )
  15034.     {
  15035.         ++j;
  15036.         ones_digit = j % 10;
  15037.         cout << "Please input the ";
  15038.         cout << j;
  15039.         switch( ones_digit )
  15040.         {
  15041.         case 1:
  15042.             ordinal = "st";
  15043.             break;
  15044.         case 2:
  15045.             ordinal = "nd";
  15046.             break;
  15047.         case 3:
  15048.             ordinal = "rd";
  15049.             break;
  15050.         case 4:
  15051.             ordinal = "th";
  15052.             break;
  15053.         case 5:
  15054.             ordinal = "th";
  15055.             break;
  15056.         case 6:
  15057.             ordinal = "th";
  15058.             break;
  15059.         case 7:
  15060.             ordinal = "th";
  15061.             break;
  15062.         case 8:
  15063.             ordinal = "th";
  15064.             break;
  15065.         case 9:
  15066.             ordinal = "th";
  15067.             break;
  15068.         case 0:
  15069.             ordinal = "th";
  15070.             break;
  15071.         }
  15072.         cout << ordinal;
  15073.         cout << " number.";
  15074.         cout << endl;
  15075.         cout << ">> ";
  15076.         cin  >> entry;
  15077.         cin_is_good = cin.good();
  15078.         cin_isnt_good = ! cin_is_good;
  15079.         if( cin_isnt_good )
  15080.         {
  15081.             BadEntry err;
  15082.             throw( err );
  15083.         }
  15084.         outFile << entry;
  15085.         outFile << ' ';
  15086.     }
  15087.     if( j < number_of_entries )
  15088.     {
  15089.         ++j;
  15090.         ones_digit = j % 10;
  15091.         cout << "Please input the ";
  15092.         cout << j;
  15093.         switch( ones_digit )
  15094.         {
  15095.         case 1:
  15096.             ordinal = "st";
  15097.             break;
  15098.         case 2:
  15099.             ordinal = "nd";
  15100.             break;
  15101.         case 3:
  15102.             ordinal = "rd";
  15103.             break;
  15104.         case 4:
  15105.             ordinal = "th";
  15106.             break;
  15107.         case 5:
  15108.             ordinal = "th";
  15109.             break;
  15110.         case 6:
  15111.             ordinal = "th";
  15112.             break;
  15113.         case 7:
  15114.             ordinal = "th";
  15115.             break;
  15116.         case 8:
  15117.             ordinal = "th";
  15118.             break;
  15119.         case 9:
  15120.             ordinal = "th";
  15121.             break;
  15122.         case 0:
  15123.             ordinal = "th";
  15124.             break;
  15125.         }
  15126.         cout << ordinal;
  15127.         cout << " number.";
  15128.         cout << endl;
  15129.         cout << ">> ";
  15130.         cin  >> entry;
  15131.         cin_is_good = cin.good();
  15132.         cin_isnt_good = ! cin_is_good;
  15133.         if( cin_isnt_good )
  15134.         {
  15135.             BadEntry err;
  15136.             throw( err );
  15137.         }
  15138.         outFile << entry;
  15139.         outFile << ' ';
  15140.     }
  15141.     if( j < number_of_entries )
  15142.     {
  15143.         ++j;
  15144.         ones_digit = j % 10;
  15145.         cout << "Please input the ";
  15146.         cout << j;
  15147.         switch( ones_digit )
  15148.         {
  15149.         case 1:
  15150.             ordinal = "st";
  15151.             break;
  15152.         case 2:
  15153.             ordinal = "nd";
  15154.             break;
  15155.         case 3:
  15156.             ordinal = "rd";
  15157.             break;
  15158.         case 4:
  15159.             ordinal = "th";
  15160.             break;
  15161.         case 5:
  15162.             ordinal = "th";
  15163.             break;
  15164.         case 6:
  15165.             ordinal = "th";
  15166.             break;
  15167.         case 7:
  15168.             ordinal = "th";
  15169.             break;
  15170.         case 8:
  15171.             ordinal = "th";
  15172.             break;
  15173.         case 9:
  15174.             ordinal = "th";
  15175.             break;
  15176.         case 0:
  15177.             ordinal = "th";
  15178.             break;
  15179.         }
  15180.         cout << ordinal;
  15181.         cout << " number.";
  15182.         cout << endl;
  15183.         cout << ">> ";
  15184.         cin  >> entry;
  15185.         cin_is_good = cin.good();
  15186.         cin_isnt_good = ! cin_is_good;
  15187.         if( cin_isnt_good )
  15188.         {
  15189.             BadEntry err;
  15190.             throw( err );
  15191.         }
  15192.         outFile << entry;
  15193.         outFile << ' ';
  15194.     }
  15195.     if( j < number_of_entries )
  15196.     {
  15197.         ++j;
  15198.         ones_digit = j % 10;
  15199.         cout << "Please input the ";
  15200.         cout << j;
  15201.         switch( ones_digit )
  15202.         {
  15203.         case 1:
  15204.             ordinal = "st";
  15205.             break;
  15206.         case 2:
  15207.             ordinal = "nd";
  15208.             break;
  15209.         case 3:
  15210.             ordinal = "rd";
  15211.             break;
  15212.         case 4:
  15213.             ordinal = "th";
  15214.             break;
  15215.         case 5:
  15216.             ordinal = "th";
  15217.             break;
  15218.         case 6:
  15219.             ordinal = "th";
  15220.             break;
  15221.         case 7:
  15222.             ordinal = "th";
  15223.             break;
  15224.         case 8:
  15225.             ordinal = "th";
  15226.             break;
  15227.         case 9:
  15228.             ordinal = "th";
  15229.             break;
  15230.         case 0:
  15231.             ordinal = "th";
  15232.             break;
  15233.         }
  15234.         cout << ordinal;
  15235.         cout << " number.";
  15236.         cout << endl;
  15237.         cout << ">> ";
  15238.         cin  >> entry;
  15239.         cin_is_good = cin.good();
  15240.         cin_isnt_good = ! cin_is_good;
  15241.         if( cin_isnt_good )
  15242.         {
  15243.             BadEntry err;
  15244.             throw( err );
  15245.         }
  15246.         outFile << entry;
  15247.         outFile << ' ';
  15248.     }
  15249.     if( j < number_of_entries )
  15250.     {
  15251.         ++j;
  15252.         ones_digit = j % 10;
  15253.         cout << "Please input the ";
  15254.         cout << j;
  15255.         switch( ones_digit )
  15256.         {
  15257.         case 1:
  15258.             ordinal = "st";
  15259.             break;
  15260.         case 2:
  15261.             ordinal = "nd";
  15262.             break;
  15263.         case 3:
  15264.             ordinal = "rd";
  15265.             break;
  15266.         case 4:
  15267.             ordinal = "th";
  15268.             break;
  15269.         case 5:
  15270.             ordinal = "th";
  15271.             break;
  15272.         case 6:
  15273.             ordinal = "th";
  15274.             break;
  15275.         case 7:
  15276.             ordinal = "th";
  15277.             break;
  15278.         case 8:
  15279.             ordinal = "th";
  15280.             break;
  15281.         case 9:
  15282.             ordinal = "th";
  15283.             break;
  15284.         case 0:
  15285.             ordinal = "th";
  15286.             break;
  15287.         }
  15288.         cout << ordinal;
  15289.         cout << " number.";
  15290.         cout << endl;
  15291.         cout << ">> ";
  15292.         cin  >> entry;
  15293.         cin_is_good = cin.good();
  15294.         cin_isnt_good = ! cin_is_good;
  15295.         if( cin_isnt_good )
  15296.         {
  15297.             BadEntry err;
  15298.             throw( err );
  15299.         }
  15300.         outFile << entry;
  15301.         outFile << ' ';
  15302.     }
  15303.     if( j < number_of_entries )
  15304.     {
  15305.         ++j;
  15306.         ones_digit = j % 10;
  15307.         cout << "Please input the ";
  15308.         cout << j;
  15309.         switch( ones_digit )
  15310.         {
  15311.         case 1:
  15312.             ordinal = "st";
  15313.             break;
  15314.         case 2:
  15315.             ordinal = "nd";
  15316.             break;
  15317.         case 3:
  15318.             ordinal = "rd";
  15319.             break;
  15320.         case 4:
  15321.             ordinal = "th";
  15322.             break;
  15323.         case 5:
  15324.             ordinal = "th";
  15325.             break;
  15326.         case 6:
  15327.             ordinal = "th";
  15328.             break;
  15329.         case 7:
  15330.             ordinal = "th";
  15331.             break;
  15332.         case 8:
  15333.             ordinal = "th";
  15334.             break;
  15335.         case 9:
  15336.             ordinal = "th";
  15337.             break;
  15338.         case 0:
  15339.             ordinal = "th";
  15340.             break;
  15341.         }
  15342.         cout << ordinal;
  15343.         cout << " number.";
  15344.         cout << endl;
  15345.         cout << ">> ";
  15346.         cin  >> entry;
  15347.         cin_is_good = cin.good();
  15348.         cin_isnt_good = ! cin_is_good;
  15349.         if( cin_isnt_good )
  15350.         {
  15351.             BadEntry err;
  15352.             throw( err );
  15353.         }
  15354.         outFile << entry;
  15355.         outFile << ' ';
  15356.     }
  15357.     if( j < number_of_entries )
  15358.     {
  15359.         ++j;
  15360.         ones_digit = j % 10;
  15361.         cout << "Please input the ";
  15362.         cout << j;
  15363.         switch( ones_digit )
  15364.         {
  15365.         case 1:
  15366.             ordinal = "st";
  15367.             break;
  15368.         case 2:
  15369.             ordinal = "nd";
  15370.             break;
  15371.         case 3:
  15372.             ordinal = "rd";
  15373.             break;
  15374.         case 4:
  15375.             ordinal = "th";
  15376.             break;
  15377.         case 5:
  15378.             ordinal = "th";
  15379.             break;
  15380.         case 6:
  15381.             ordinal = "th";
  15382.             break;
  15383.         case 7:
  15384.             ordinal = "th";
  15385.             break;
  15386.         case 8:
  15387.             ordinal = "th";
  15388.             break;
  15389.         case 9:
  15390.             ordinal = "th";
  15391.             break;
  15392.         case 0:
  15393.             ordinal = "th";
  15394.             break;
  15395.         }
  15396.         cout << ordinal;
  15397.         cout << " number.";
  15398.         cout << endl;
  15399.         cout << ">> ";
  15400.         cin  >> entry;
  15401.         cin_is_good = cin.good();
  15402.         cin_isnt_good = ! cin_is_good;
  15403.         if( cin_isnt_good )
  15404.         {
  15405.             BadEntry err;
  15406.             throw( err );
  15407.         }
  15408.         outFile << entry;
  15409.         outFile << ' ';
  15410.     }
  15411.     if( j < number_of_entries )
  15412.     {
  15413.         ++j;
  15414.         ones_digit = j % 10;
  15415.         cout << "Please input the ";
  15416.         cout << j;
  15417.         switch( ones_digit )
  15418.         {
  15419.         case 1:
  15420.             ordinal = "st";
  15421.             break;
  15422.         case 2:
  15423.             ordinal = "nd";
  15424.             break;
  15425.         case 3:
  15426.             ordinal = "rd";
  15427.             break;
  15428.         case 4:
  15429.             ordinal = "th";
  15430.             break;
  15431.         case 5:
  15432.             ordinal = "th";
  15433.             break;
  15434.         case 6:
  15435.             ordinal = "th";
  15436.             break;
  15437.         case 7:
  15438.             ordinal = "th";
  15439.             break;
  15440.         case 8:
  15441.             ordinal = "th";
  15442.             break;
  15443.         case 9:
  15444.             ordinal = "th";
  15445.             break;
  15446.         case 0:
  15447.             ordinal = "th";
  15448.             break;
  15449.         }
  15450.         cout << ordinal;
  15451.         cout << " number.";
  15452.         cout << endl;
  15453.         cout << ">> ";
  15454.         cin  >> entry;
  15455.         cin_is_good = cin.good();
  15456.         cin_isnt_good = ! cin_is_good;
  15457.         if( cin_isnt_good )
  15458.         {
  15459.             BadEntry err;
  15460.             throw( err );
  15461.         }
  15462.         outFile << entry;
  15463.         outFile << ' ';
  15464.     }
  15465.     if( j < number_of_entries )
  15466.     {
  15467.         ++j;
  15468.         ones_digit = j % 10;
  15469.         cout << "Please input the ";
  15470.         cout << j;
  15471.         switch( ones_digit )
  15472.         {
  15473.         case 1:
  15474.             ordinal = "st";
  15475.             break;
  15476.         case 2:
  15477.             ordinal = "nd";
  15478.             break;
  15479.         case 3:
  15480.             ordinal = "rd";
  15481.             break;
  15482.         case 4:
  15483.             ordinal = "th";
  15484.             break;
  15485.         case 5:
  15486.             ordinal = "th";
  15487.             break;
  15488.         case 6:
  15489.             ordinal = "th";
  15490.             break;
  15491.         case 7:
  15492.             ordinal = "th";
  15493.             break;
  15494.         case 8:
  15495.             ordinal = "th";
  15496.             break;
  15497.         case 9:
  15498.             ordinal = "th";
  15499.             break;
  15500.         case 0:
  15501.             ordinal = "th";
  15502.             break;
  15503.         }
  15504.         cout << ordinal;
  15505.         cout << " number.";
  15506.         cout << endl;
  15507.         cout << ">> ";
  15508.         cin  >> entry;
  15509.         cin_is_good = cin.good();
  15510.         cin_isnt_good = ! cin_is_good;
  15511.         if( cin_isnt_good )
  15512.         {
  15513.             BadEntry err;
  15514.             throw( err );
  15515.         }
  15516.         outFile << entry;
  15517.         outFile << ' ';
  15518.     }
  15519.     if( j < number_of_entries )
  15520.     {
  15521.         ++j;
  15522.         ones_digit = j % 10;
  15523.         cout << "Please input the ";
  15524.         cout << j;
  15525.         switch( ones_digit )
  15526.         {
  15527.         case 1:
  15528.             ordinal = "st";
  15529.             break;
  15530.         case 2:
  15531.             ordinal = "nd";
  15532.             break;
  15533.         case 3:
  15534.             ordinal = "rd";
  15535.             break;
  15536.         case 4:
  15537.             ordinal = "th";
  15538.             break;
  15539.         case 5:
  15540.             ordinal = "th";
  15541.             break;
  15542.         case 6:
  15543.             ordinal = "th";
  15544.             break;
  15545.         case 7:
  15546.             ordinal = "th";
  15547.             break;
  15548.         case 8:
  15549.             ordinal = "th";
  15550.             break;
  15551.         case 9:
  15552.             ordinal = "th";
  15553.             break;
  15554.         case 0:
  15555.             ordinal = "th";
  15556.             break;
  15557.         }
  15558.         cout << ordinal;
  15559.         cout << " number.";
  15560.         cout << endl;
  15561.         cout << ">> ";
  15562.         cin  >> entry;
  15563.         cin_is_good = cin.good();
  15564.         cin_isnt_good = ! cin_is_good;
  15565.         if( cin_isnt_good )
  15566.         {
  15567.             BadEntry err;
  15568.             throw( err );
  15569.         }
  15570.         outFile << entry;
  15571.         outFile << ' ';
  15572.     }
  15573.     if( j < number_of_entries )
  15574.     {
  15575.         ++j;
  15576.         ones_digit = j % 10;
  15577.         cout << "Please input the ";
  15578.         cout << j;
  15579.         switch( ones_digit )
  15580.         {
  15581.         case 1:
  15582.             ordinal = "st";
  15583.             break;
  15584.         case 2:
  15585.             ordinal = "nd";
  15586.             break;
  15587.         case 3:
  15588.             ordinal = "rd";
  15589.             break;
  15590.         case 4:
  15591.             ordinal = "th";
  15592.             break;
  15593.         case 5:
  15594.             ordinal = "th";
  15595.             break;
  15596.         case 6:
  15597.             ordinal = "th";
  15598.             break;
  15599.         case 7:
  15600.             ordinal = "th";
  15601.             break;
  15602.         case 8:
  15603.             ordinal = "th";
  15604.             break;
  15605.         case 9:
  15606.             ordinal = "th";
  15607.             break;
  15608.         case 0:
  15609.             ordinal = "th";
  15610.             break;
  15611.         }
  15612.         cout << ordinal;
  15613.         cout << " number.";
  15614.         cout << endl;
  15615.         cout << ">> ";
  15616.         cin  >> entry;
  15617.         cin_is_good = cin.good();
  15618.         cin_isnt_good = ! cin_is_good;
  15619.         if( cin_isnt_good )
  15620.         {
  15621.             BadEntry err;
  15622.             throw( err );
  15623.         }
  15624.         outFile << entry;
  15625.         outFile << ' ';
  15626.     }
  15627.     if( j < number_of_entries )
  15628.     {
  15629.         ++j;
  15630.         ones_digit = j % 10;
  15631.         cout << "Please input the ";
  15632.         cout << j;
  15633.         switch( ones_digit )
  15634.         {
  15635.         case 1:
  15636.             ordinal = "st";
  15637.             break;
  15638.         case 2:
  15639.             ordinal = "nd";
  15640.             break;
  15641.         case 3:
  15642.             ordinal = "rd";
  15643.             break;
  15644.         case 4:
  15645.             ordinal = "th";
  15646.             break;
  15647.         case 5:
  15648.             ordinal = "th";
  15649.             break;
  15650.         case 6:
  15651.             ordinal = "th";
  15652.             break;
  15653.         case 7:
  15654.             ordinal = "th";
  15655.             break;
  15656.         case 8:
  15657.             ordinal = "th";
  15658.             break;
  15659.         case 9:
  15660.             ordinal = "th";
  15661.             break;
  15662.         case 0:
  15663.             ordinal = "th";
  15664.             break;
  15665.         }
  15666.         cout << ordinal;
  15667.         cout << " number.";
  15668.         cout << endl;
  15669.         cout << ">> ";
  15670.         cin  >> entry;
  15671.         cin_is_good = cin.good();
  15672.         cin_isnt_good = ! cin_is_good;
  15673.         if( cin_isnt_good )
  15674.         {
  15675.             BadEntry err;
  15676.             throw( err );
  15677.         }
  15678.         outFile << entry;
  15679.         outFile << ' ';
  15680.     }
  15681.     if( j < number_of_entries )
  15682.     {
  15683.         ++j;
  15684.         ones_digit = j % 10;
  15685.         cout << "Please input the ";
  15686.         cout << j;
  15687.         switch( ones_digit )
  15688.         {
  15689.         case 1:
  15690.             ordinal = "st";
  15691.             break;
  15692.         case 2:
  15693.             ordinal = "nd";
  15694.             break;
  15695.         case 3:
  15696.             ordinal = "rd";
  15697.             break;
  15698.         case 4:
  15699.             ordinal = "th";
  15700.             break;
  15701.         case 5:
  15702.             ordinal = "th";
  15703.             break;
  15704.         case 6:
  15705.             ordinal = "th";
  15706.             break;
  15707.         case 7:
  15708.             ordinal = "th";
  15709.             break;
  15710.         case 8:
  15711.             ordinal = "th";
  15712.             break;
  15713.         case 9:
  15714.             ordinal = "th";
  15715.             break;
  15716.         case 0:
  15717.             ordinal = "th";
  15718.             break;
  15719.         }
  15720.         cout << ordinal;
  15721.         cout << " number.";
  15722.         cout << endl;
  15723.         cout << ">> ";
  15724.         cin  >> entry;
  15725.         cin_is_good = cin.good();
  15726.         cin_isnt_good = ! cin_is_good;
  15727.         if( cin_isnt_good )
  15728.         {
  15729.             BadEntry err;
  15730.             throw( err );
  15731.         }
  15732.         outFile << entry;
  15733.         outFile << ' ';
  15734.     }
  15735.     if( j < number_of_entries )
  15736.     {
  15737.         ++j;
  15738.         ones_digit = j % 10;
  15739.         cout << "Please input the ";
  15740.         cout << j;
  15741.         switch( ones_digit )
  15742.         {
  15743.         case 1:
  15744.             ordinal = "st";
  15745.             break;
  15746.         case 2:
  15747.             ordinal = "nd";
  15748.             break;
  15749.         case 3:
  15750.             ordinal = "rd";
  15751.             break;
  15752.         case 4:
  15753.             ordinal = "th";
  15754.             break;
  15755.         case 5:
  15756.             ordinal = "th";
  15757.             break;
  15758.         case 6:
  15759.             ordinal = "th";
  15760.             break;
  15761.         case 7:
  15762.             ordinal = "th";
  15763.             break;
  15764.         case 8:
  15765.             ordinal = "th";
  15766.             break;
  15767.         case 9:
  15768.             ordinal = "th";
  15769.             break;
  15770.         case 0:
  15771.             ordinal = "th";
  15772.             break;
  15773.         }
  15774.         cout << ordinal;
  15775.         cout << " number.";
  15776.         cout << endl;
  15777.         cout << ">> ";
  15778.         cin  >> entry;
  15779.         cin_is_good = cin.good();
  15780.         cin_isnt_good = ! cin_is_good;
  15781.         if( cin_isnt_good )
  15782.         {
  15783.             BadEntry err;
  15784.             throw( err );
  15785.         }
  15786.         outFile << entry;
  15787.         outFile << ' ';
  15788.     }
  15789.     if( j < number_of_entries )
  15790.     {
  15791.         ++j;
  15792.         ones_digit = j % 10;
  15793.         cout << "Please input the ";
  15794.         cout << j;
  15795.         switch( ones_digit )
  15796.         {
  15797.         case 1:
  15798.             ordinal = "st";
  15799.             break;
  15800.         case 2:
  15801.             ordinal = "nd";
  15802.             break;
  15803.         case 3:
  15804.             ordinal = "rd";
  15805.             break;
  15806.         case 4:
  15807.             ordinal = "th";
  15808.             break;
  15809.         case 5:
  15810.             ordinal = "th";
  15811.             break;
  15812.         case 6:
  15813.             ordinal = "th";
  15814.             break;
  15815.         case 7:
  15816.             ordinal = "th";
  15817.             break;
  15818.         case 8:
  15819.             ordinal = "th";
  15820.             break;
  15821.         case 9:
  15822.             ordinal = "th";
  15823.             break;
  15824.         case 0:
  15825.             ordinal = "th";
  15826.             break;
  15827.         }
  15828.         cout << ordinal;
  15829.         cout << " number.";
  15830.         cout << endl;
  15831.         cout << ">> ";
  15832.         cin  >> entry;
  15833.         cin_is_good = cin.good();
  15834.         cin_isnt_good = ! cin_is_good;
  15835.         if( cin_isnt_good )
  15836.         {
  15837.             BadEntry err;
  15838.             throw( err );
  15839.         }
  15840.         outFile << entry;
  15841.         outFile << ' ';
  15842.     }
  15843.     if( j < number_of_entries )
  15844.     {
  15845.         ++j;
  15846.         ones_digit = j % 10;
  15847.         cout << "Please input the ";
  15848.         cout << j;
  15849.         switch( ones_digit )
  15850.         {
  15851.         case 1:
  15852.             ordinal = "st";
  15853.             break;
  15854.         case 2:
  15855.             ordinal = "nd";
  15856.             break;
  15857.         case 3:
  15858.             ordinal = "rd";
  15859.             break;
  15860.         case 4:
  15861.             ordinal = "th";
  15862.             break;
  15863.         case 5:
  15864.             ordinal = "th";
  15865.             break;
  15866.         case 6:
  15867.             ordinal = "th";
  15868.             break;
  15869.         case 7:
  15870.             ordinal = "th";
  15871.             break;
  15872.         case 8:
  15873.             ordinal = "th";
  15874.             break;
  15875.         case 9:
  15876.             ordinal = "th";
  15877.             break;
  15878.         case 0:
  15879.             ordinal = "th";
  15880.             break;
  15881.         }
  15882.         cout << ordinal;
  15883.         cout << " number.";
  15884.         cout << endl;
  15885.         cout << ">> ";
  15886.         cin  >> entry;
  15887.         cin_is_good = cin.good();
  15888.         cin_isnt_good = ! cin_is_good;
  15889.         if( cin_isnt_good )
  15890.         {
  15891.             BadEntry err;
  15892.             throw( err );
  15893.         }
  15894.         outFile << entry;
  15895.         outFile << ' ';
  15896.     }
  15897.     if( j < number_of_entries )
  15898.     {
  15899.         ++j;
  15900.         ones_digit = j % 10;
  15901.         cout << "Please input the ";
  15902.         cout << j;
  15903.         switch( ones_digit )
  15904.         {
  15905.         case 1:
  15906.             ordinal = "st";
  15907.             break;
  15908.         case 2:
  15909.             ordinal = "nd";
  15910.             break;
  15911.         case 3:
  15912.             ordinal = "rd";
  15913.             break;
  15914.         case 4:
  15915.             ordinal = "th";
  15916.             break;
  15917.         case 5:
  15918.             ordinal = "th";
  15919.             break;
  15920.         case 6:
  15921.             ordinal = "th";
  15922.             break;
  15923.         case 7:
  15924.             ordinal = "th";
  15925.             break;
  15926.         case 8:
  15927.             ordinal = "th";
  15928.             break;
  15929.         case 9:
  15930.             ordinal = "th";
  15931.             break;
  15932.         case 0:
  15933.             ordinal = "th";
  15934.             break;
  15935.         }
  15936.         cout << ordinal;
  15937.         cout << " number.";
  15938.         cout << endl;
  15939.         cout << ">> ";
  15940.         cin  >> entry;
  15941.         cin_is_good = cin.good();
  15942.         cin_isnt_good = ! cin_is_good;
  15943.         if( cin_isnt_good )
  15944.         {
  15945.             BadEntry err;
  15946.             throw( err );
  15947.         }
  15948.         outFile << entry;
  15949.         outFile << ' ';
  15950.     }
  15951.     if( j < number_of_entries )
  15952.     {
  15953.         ++j;
  15954.         ones_digit = j % 10;
  15955.         cout << "Please input the ";
  15956.         cout << j;
  15957.         switch( ones_digit )
  15958.         {
  15959.         case 1:
  15960.             ordinal = "st";
  15961.             break;
  15962.         case 2:
  15963.             ordinal = "nd";
  15964.             break;
  15965.         case 3:
  15966.             ordinal = "rd";
  15967.             break;
  15968.         case 4:
  15969.             ordinal = "th";
  15970.             break;
  15971.         case 5:
  15972.             ordinal = "th";
  15973.             break;
  15974.         case 6:
  15975.             ordinal = "th";
  15976.             break;
  15977.         case 7:
  15978.             ordinal = "th";
  15979.             break;
  15980.         case 8:
  15981.             ordinal = "th";
  15982.             break;
  15983.         case 9:
  15984.             ordinal = "th";
  15985.             break;
  15986.         case 0:
  15987.             ordinal = "th";
  15988.             break;
  15989.         }
  15990.         cout << ordinal;
  15991.         cout << " number.";
  15992.         cout << endl;
  15993.         cout << ">> ";
  15994.         cin  >> entry;
  15995.         cin_is_good = cin.good();
  15996.         cin_isnt_good = ! cin_is_good;
  15997.         if( cin_isnt_good )
  15998.         {
  15999.             BadEntry err;
  16000.             throw( err );
  16001.         }
  16002.         outFile << entry;
  16003.         outFile << ' ';
  16004.     }
  16005.     if( j < number_of_entries )
  16006.     {
  16007.         ++j;
  16008.         ones_digit = j % 10;
  16009.         cout << "Please input the ";
  16010.         cout << j;
  16011.         switch( ones_digit )
  16012.         {
  16013.         case 1:
  16014.             ordinal = "st";
  16015.             break;
  16016.         case 2:
  16017.             ordinal = "nd";
  16018.             break;
  16019.         case 3:
  16020.             ordinal = "rd";
  16021.             break;
  16022.         case 4:
  16023.             ordinal = "th";
  16024.             break;
  16025.         case 5:
  16026.             ordinal = "th";
  16027.             break;
  16028.         case 6:
  16029.             ordinal = "th";
  16030.             break;
  16031.         case 7:
  16032.             ordinal = "th";
  16033.             break;
  16034.         case 8:
  16035.             ordinal = "th";
  16036.             break;
  16037.         case 9:
  16038.             ordinal = "th";
  16039.             break;
  16040.         case 0:
  16041.             ordinal = "th";
  16042.             break;
  16043.         }
  16044.         cout << ordinal;
  16045.         cout << " number.";
  16046.         cout << endl;
  16047.         cout << ">> ";
  16048.         cin  >> entry;
  16049.         cin_is_good = cin.good();
  16050.         cin_isnt_good = ! cin_is_good;
  16051.         if( cin_isnt_good )
  16052.         {
  16053.             BadEntry err;
  16054.             throw( err );
  16055.         }
  16056.         outFile << entry;
  16057.         outFile << ' ';
  16058.     }
  16059.     if( j < number_of_entries )
  16060.     {
  16061.         ++j;
  16062.         ones_digit = j % 10;
  16063.         cout << "Please input the ";
  16064.         cout << j;
  16065.         switch( ones_digit )
  16066.         {
  16067.         case 1:
  16068.             ordinal = "st";
  16069.             break;
  16070.         case 2:
  16071.             ordinal = "nd";
  16072.             break;
  16073.         case 3:
  16074.             ordinal = "rd";
  16075.             break;
  16076.         case 4:
  16077.             ordinal = "th";
  16078.             break;
  16079.         case 5:
  16080.             ordinal = "th";
  16081.             break;
  16082.         case 6:
  16083.             ordinal = "th";
  16084.             break;
  16085.         case 7:
  16086.             ordinal = "th";
  16087.             break;
  16088.         case 8:
  16089.             ordinal = "th";
  16090.             break;
  16091.         case 9:
  16092.             ordinal = "th";
  16093.             break;
  16094.         case 0:
  16095.             ordinal = "th";
  16096.             break;
  16097.         }
  16098.         cout << ordinal;
  16099.         cout << " number.";
  16100.         cout << endl;
  16101.         cout << ">> ";
  16102.         cin  >> entry;
  16103.         cin_is_good = cin.good();
  16104.         cin_isnt_good = ! cin_is_good;
  16105.         if( cin_isnt_good )
  16106.         {
  16107.             BadEntry err;
  16108.             throw( err );
  16109.         }
  16110.         outFile << entry;
  16111.         outFile << ' ';
  16112.     }
  16113.     if( j < number_of_entries )
  16114.     {
  16115.         ++j;
  16116.         ones_digit = j % 10;
  16117.         cout << "Please input the ";
  16118.         cout << j;
  16119.         switch( ones_digit )
  16120.         {
  16121.         case 1:
  16122.             ordinal = "st";
  16123.             break;
  16124.         case 2:
  16125.             ordinal = "nd";
  16126.             break;
  16127.         case 3:
  16128.             ordinal = "rd";
  16129.             break;
  16130.         case 4:
  16131.             ordinal = "th";
  16132.             break;
  16133.         case 5:
  16134.             ordinal = "th";
  16135.             break;
  16136.         case 6:
  16137.             ordinal = "th";
  16138.             break;
  16139.         case 7:
  16140.             ordinal = "th";
  16141.             break;
  16142.         case 8:
  16143.             ordinal = "th";
  16144.             break;
  16145.         case 9:
  16146.             ordinal = "th";
  16147.             break;
  16148.         case 0:
  16149.             ordinal = "th";
  16150.             break;
  16151.         }
  16152.         cout << ordinal;
  16153.         cout << " number.";
  16154.         cout << endl;
  16155.         cout << ">> ";
  16156.         cin  >> entry;
  16157.         cin_is_good = cin.good();
  16158.         cin_isnt_good = ! cin_is_good;
  16159.         if( cin_isnt_good )
  16160.         {
  16161.             BadEntry err;
  16162.             throw( err );
  16163.         }
  16164.         outFile << entry;
  16165.         outFile << ' ';
  16166.     }
  16167.     if( j < number_of_entries )
  16168.     {
  16169.         ++j;
  16170.         ones_digit = j % 10;
  16171.         cout << "Please input the ";
  16172.         cout << j;
  16173.         switch( ones_digit )
  16174.         {
  16175.         case 1:
  16176.             ordinal = "st";
  16177.             break;
  16178.         case 2:
  16179.             ordinal = "nd";
  16180.             break;
  16181.         case 3:
  16182.             ordinal = "rd";
  16183.             break;
  16184.         case 4:
  16185.             ordinal = "th";
  16186.             break;
  16187.         case 5:
  16188.             ordinal = "th";
  16189.             break;
  16190.         case 6:
  16191.             ordinal = "th";
  16192.             break;
  16193.         case 7:
  16194.             ordinal = "th";
  16195.             break;
  16196.         case 8:
  16197.             ordinal = "th";
  16198.             break;
  16199.         case 9:
  16200.             ordinal = "th";
  16201.             break;
  16202.         case 0:
  16203.             ordinal = "th";
  16204.             break;
  16205.         }
  16206.         cout << ordinal;
  16207.         cout << " number.";
  16208.         cout << endl;
  16209.         cout << ">> ";
  16210.         cin  >> entry;
  16211.         cin_is_good = cin.good();
  16212.         cin_isnt_good = ! cin_is_good;
  16213.         if( cin_isnt_good )
  16214.         {
  16215.             BadEntry err;
  16216.             throw( err );
  16217.         }
  16218.         outFile << entry;
  16219.         outFile << ' ';
  16220.     }
  16221.     if( j < number_of_entries )
  16222.     {
  16223.         ++j;
  16224.         ones_digit = j % 10;
  16225.         cout << "Please input the ";
  16226.         cout << j;
  16227.         switch( ones_digit )
  16228.         {
  16229.         case 1:
  16230.             ordinal = "st";
  16231.             break;
  16232.         case 2:
  16233.             ordinal = "nd";
  16234.             break;
  16235.         case 3:
  16236.             ordinal = "rd";
  16237.             break;
  16238.         case 4:
  16239.             ordinal = "th";
  16240.             break;
  16241.         case 5:
  16242.             ordinal = "th";
  16243.             break;
  16244.         case 6:
  16245.             ordinal = "th";
  16246.             break;
  16247.         case 7:
  16248.             ordinal = "th";
  16249.             break;
  16250.         case 8:
  16251.             ordinal = "th";
  16252.             break;
  16253.         case 9:
  16254.             ordinal = "th";
  16255.             break;
  16256.         case 0:
  16257.             ordinal = "th";
  16258.             break;
  16259.         }
  16260.         cout << ordinal;
  16261.         cout << " number.";
  16262.         cout << endl;
  16263.         cout << ">> ";
  16264.         cin  >> entry;
  16265.         cin_is_good = cin.good();
  16266.         cin_isnt_good = ! cin_is_good;
  16267.         if( cin_isnt_good )
  16268.         {
  16269.             BadEntry err;
  16270.             throw( err );
  16271.         }
  16272.         outFile << entry;
  16273.         outFile << ' ';
  16274.     }
  16275.     outFile.close();
  16276.     delete filename_c_str;
  16277.     filename_c_str_iter = nullptr;
  16278. }
  16279. int main()
  16280. {
  16281.     std::string filename;
  16282.     cout << "Please enter the filename.";
  16283.     cout << endl;
  16284.     cout << ">> ";
  16285.     cin  >> filename;
  16286.     std::string mode;
  16287.     cout << "Please select either \"read\" or \"write\" mode.";
  16288.     cout << endl;
  16289.     cout << ">> ";
  16290.     cin  >> mode;
  16291.     if( mode == "read" )
  16292.     {
  16293.         try
  16294.         {
  16295.             read( filename );
  16296.         }
  16297.         catch( FileNameTooLong& err )
  16298.         {
  16299.             cout << err.what();
  16300.         }
  16301.         catch( CouldNotOpenFile& err )
  16302.         {
  16303.             cout << err.what();
  16304.         }
  16305.     }
  16306.     else if( mode == "write" )
  16307.     {
  16308.         try
  16309.         {
  16310.             write( filename );
  16311.         }
  16312.         catch( FileNameTooLong& err )
  16313.         {
  16314.             cout << err.what();
  16315.         }
  16316.         catch( CouldNotOpenFile& err )
  16317.         {
  16318.             cout << err.what();
  16319.         }
  16320.         catch( BadEntry& err )
  16321.         {
  16322.             cout << err.what();
  16323.         }
  16324.     }
  16325.     else
  16326.     {
  16327.         cout << "Bad mode, sorry!";
  16328.         cout << endl;
  16329.     }
  16330. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!