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

wereboobs-battleship

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