API tools faq
paste
CaCl2

Morse code interpreter written in C

CaCl2
Jan 30th, 2020
187
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 49.57 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdint.h>
  3.  
  4. void morse(char *input) {
  5. /*morsecod'e into normal text;*/
  6. char *O0;
  7. O0 = input;
  8. char output[9999]; /*reserve enough space*/
  9. output[9999]='\0';
  10. char *O1;
  11. O1 = output;
  12.  
  13. start:
  14.     while (*O0)
  15.     {
  16.        
  17.  
  18.         while (!(*O0 - (38+7)))
  19.         {
  20.            
  21.             O0++;
  22.             while (!(*O0 - (38+7)))
  23.             {
  24.                     O0++;
  25.                     while (!(*O0 - (41+4)))
  26.                     {
  27.                         O0++;
  28.                         while (!(*O0 - (34+11)))
  29.                         {
  30.                             O0++;
  31.                             while (!(*O0 - (37+8)))
  32.                             {
  33.                                 O0++;
  34.                                 while (!(*O0 - (38+7)))
  35.                                 {
  36.                                     O0++;
  37.                                     while ((!*O0) || (!(*O0 - 32)))
  38.                                     {
  39.                                         O1++;
  40.                                         O0++;
  41.                                         goto start;
  42.                                     }
  43.                                     break;
  44.                                 }
  45.                                 while (!(*O0 - 46))
  46.                                 {
  47.                                     O0++;
  48.                                     while ((!*O0) || (!(*O0 - 32)))
  49.                                     {
  50.                                         O1++;
  51.                                         O0++;
  52.                                         goto start;
  53.                                     }
  54.                                     break;
  55.                                 }
  56.                                 while ((!*O0) || (!(*O0 - 32)))
  57.                                 {
  58.                                     *O1 = '0';
  59.                            O1++;
  60.                                     O0++;
  61.                                     goto start;
  62.                                 }
  63.                                 break;
  64.                             }
  65.                             while (!(*O0 - 46))
  66.                             {
  67.                                 O0++;
  68.                                 while (!(*O0 - (38+7)))
  69.                                 {
  70.                                     O0++;2
  71.                                     while ((!*O0) || (!(*O0 - 31 -1)))
  72.                                     {
  73.  
  74.                                         O1++;
  75.                                         O0++;
  76.                                         goto start;
  77.                                     }
  78.                                     break;
  79.                                 }
  80.                                 while (!(*O0 - 46))
  81.                                 {
  82.                                     O0++;
  83.                                     while ((!*O0) || (!(*O0 - 32)))
  84.                                     {
  85.  
  86.                                         O1++;
  87.                                         O0++;
  88.                                         goto start;
  89.                                     }
  90.                                     break;
  91.                                 }
  92.                               while ((!*O0) || (!(*O0 - 32)))
  93.                                 {
  94.                                     *O1 = '9';
  95.                                     O1++;
  96.                                     O0++;
  97.                                     goto start;
  98.                                 }
  99.                                 break;
  100.                             }
  101.                             while ((!*O0) || (!(*O0 - 32)))
  102.                             {
  103.  
  104.                                 O1++;
  105.                                 O0++;
  106.                                 goto start;
  107.                             }
  108.                             break;
  109.                     }
  110.                     while (!(*O0 - 46))
  111.                     {
  112.                         O0++;
  113.                         while (!(*O0 - (38+7)))
  114.                         {
  115.                             O0++;
  116.                             while (!(*O0 - (38+7)))
  117.                             {
  118.                                 O0++;
  119.                                 while ((!*O0) || (!(*O0 - 32)))
  120.                                 {
  121.                                     continue;
  122.                                 }
  123.                                 break;
  124.                             }
  125.                             while (!(*O0 - 46))
  126.                             {
  127.                                 O0++;
  128.                                 while ((!*O0) || (!(*O0 - 32)))
  129.                                 {
  130.                                     continue;
  131.                                 }
  132.                                 break;
  133.                             }
  134.                             while ((!*O0) || (!(*O0 - 32)))
  135.                             {
  136.                              continue;
  137.                             }
  138.                             break;
  139.                         }
  140.                         while (!(*O0 - 46))
  141.                         {
  142.                             O0++;
  143.                             while (!(*O0 - (38+7)))
  144.                             {
  145.                                 O0++;
  146.                                 while ((!*O0) || (!(*O0 - 32)))
  147.                                 {
  148.                                     continue;
  149.                                 }
  150.                                 break;
  151.                             }
  152.                             while (!(*O0 - 46))
  153.                             {
  154.                                 O0++;
  155.                                 while ((!*O0) || (!(*O0 - 32)))
  156.                                 {
  157.                          *O1 = ':';
  158.                                     O1++;
  159.                                     O0++;
  160.                                     goto start;
  161.                                 }
  162.                                 break;
  163.                             }
  164.                             while ((!*O0) || (!(*O0 - 32)))
  165.                                    {
  166.                                 *O1 = '8';
  167.                                 O1++;
  168.                                 O0++;
  169.                                 goto start;
  170.                             }
  171.                             break;
  172.                         }
  173.                         while ((!*O0) || (!(*O0 - 32)))
  174.                         {
  175.                             continue;
  176.                                                                  }
  177.                         break;
  178.                     }
  179.                     while ((!*O0) || (!(*O0 - 32)))
  180.                     {
  181.                         *O1 = 'O';
  182.                         O1++;
  183.                         O0++;
  184.                         goto start;
  185.                     }
  186.                     break;
  187.                 }
  188.                 while (!(*O0 - 46))
  189.                 {
  190.                     O0++;
  191.                     while (!(*O0 - (38+7)))
  192.                     {
  193.                         O0++;
  194.                            while (!(*O0 - (38+7)))
  195.                         {
  196.                             O0++;
  197.                             while (!(*O0 - (38+7)))
  198.                             {
  199.                                 O0++;
  200.                                 while ((!*O0) || (!(*O0 - 32)))
  201.                                 {
  202.                                     continue;
  203.                                 }
  204.                                 break;
  205.                             }
  206.                             while (!(*O0 - 46))
  207.                             {
  208.                                 O0++;
  209.                                 while ((!*O0) || (!(*O0 - 32)))
  210.                                 {
  211.                                     continue;
  212.                                 }
  213.                                 break;
  214.                             }
  215.                             while ((!*O0) || (!(*O0 - 32)))
  216.                             {
  217.                                 continue;
  218.                             }
  219.                             break;
  220.                         }
  221.                         while (!(*O0 - 46))
  222.                                        {
  223.                             O0++;
  224.                             while (!(*O0 - (38+7)))
  225.                             {
  226.                                 O0++;
  227.                                 while ((!*O0) || (!(*O0 - 32)))
  228.                                 {
  229.                                     continue;
  230.                                 }
  231.                                 break;
  232.                             }
  233.                             while (!(*O0 - 46))
  234.                             {
  235.                                 O0++;
  236.                                 while ((!*O0) || (!(*O0 - 32)))
  237.                                 {
  238.                                     continue;
  239.                                 }
  240.                                 break;
  241.                             }
  242.                             while ((!*O0) || (!(*O0 - 32)))
  243.                                {
  244.                                 continue;
  245.                             }
  246.                             break;
  247.                         }
  248.                         while ((!*O0) || (!(*O0 - 32)))
  249.                         {
  250.                             *O1 = 'q';
  251.                             O1++;
  252.                             O0++;
  253.                             goto start;
  254.                         }
  255.                         break;
  256.                     }
  257.                     while (!(*O0 - 46))
  258.                     {
  259.                         O0++;
  260.                         while (!(*O0 - (38+7)))
  261.                         {
  262.                             O0++;
  263.                             while (!(*O0 - (38+7)))
  264.                                        {
  265.                                 O0++;
  266.                                 while ((!*O0) || (!(*O0 - 32)))
  267.                                 {
  268.                                     *O1 = ',';
  269.                                     O1++;
  270.                                     O0++;
  271.                                     goto start;
  272.                                 }
  273.                                 break;
  274.                             }
  275.                             while (!(*O0 - 46))
  276.                             {
  277.                                 O0++;
  278.                                 while ((!*O0) || (!(*O0 - 32)))
  279.                                 {
  280.                                     continue;
  281.                                 }
  282.                                 break;
  283.                             }
  284.                             while ((!*O0) || (!(*O0 - 32)))
  285.                             {
  286.                                 continue;
  287.                             }
  288.                             break;
  289.                         }
  290.                                while (!(*O0 - 46))
  291.                         {
  292.                             O0++;
  293.                             while (!(*O0 - (38+7)))
  294.                             {
  295.                                 O0++;
  296.                                 while ((!*O0) || (!(*O0 - 32)))
  297.                                 {
  298.                                     continue;
  299.                                 }
  300.                                 break;
  301.                             }
  302.                             while (!(*O0 - 46))
  303.                             {
  304.                                 O0++;
  305.                                 while ((!*O0) || (!(*O0 - 32)))
  306.                                 {
  307.                                     continue;
  308.                                 }
  309.                                 break;
  310.                             }
  311.                    while ((!*O0) || (!(*O0 - 32)))
  312.                             {
  313.                                 *O1 = '7';
  314.                                 O1++;
  315.                                 O0++;
  316.                                 goto start;
  317.                             }
  318.                             break;
  319.                         }
  320.                         while ((!*O0) || (!(*O0 - 32)))
  321.                         {
  322.                             *O1 = 'Z';
  323.                             O1++;
  324.                             O0++;
  325.                             goto start;
  326.                         }
  327.                         break;
  328.                     }
  329.                     while ((!*O0) || (!(*O0 - 32)))
  330.                     {
  331.                         *O1 = 'G';
  332.                                O1++;
  333.                         O0++;
  334.                         goto start;
  335.                     }
  336.                     break;
  337.                 }
  338.                 while ((!*O0) || (!(*O0 - 32)))
  339.                 {
  340.                     *O1 = 'M';
  341.                     O1++;
  342.                     O0++;
  343.                     goto start;
  344.                 }
  345.                 break;
  346.             }
  347.             while (!(*O0 - 46))
  348.             {
  349.                 O0++;
  350.                 while (!(*O0 - (38+7)))
  351.                     {
  352.                     O0++;
  353.                     while (!(*O0 - (38+7)))
  354.                     {
  355.                         O0++;
  356.                         while (!(*O0 - (38+7)))
  357.                         {
  358.                             O0++;
  359.                             while (!(*O0 - (38+7)))
  360.                             {
  361.                                 O0++;
  362.                                 while ((!*O0) || (!(*O0 - 32)))
  363.                                 {
  364.                                     continue;
  365.                                 }
  366.                                 break;
  367.                             }
  368.                             while (!(*O0 - 46))
  369.                             {
  370.                                 O0++;
  371.                                 while ((!*O0) || (!(*O0 - 32)))
  372.                                 {
  373.                                     continue;
  374.                                 }
  375.                                 break;
  376.                             }
  377.          
  378.          
  379.          
  380.                              while ((!*O0) || (!(*O0 - 32)))
  381.                             {
  382.                                 continue;
  383.                             }
  384.                             break;
  385.                         }
  386.                         while (!(*O0 - 46))
  387.                         {
  388.                             O0++;
  389.                             while (!(*O0 - (38+7)))
  390.                             {
  391.                                 O0++;
  392.                                 while ((!*O0) || (!(*O0 - 32)))
  393.                                 {
  394.                                     *O1 = ')';
  395.                                     O1++;
  396.                                     O0++;
  397.                                     goto start;
  398.                                 }
  399.                                 break;
  400.          
  401.          
  402.          
  403.          
  404.          
  405.          
  406.          
  407.          
  408.          
  409.          
  410.          
  411.                             }
  412.                             while (!(*O0 - 46))
  413.                             {
  414.                                 O0++;
  415.                                 while ((!*O0) || (!(*O0 - 32)))
  416.                                 {
  417.                                     continue;
  418.                                 }
  419.                                 break;
  420.                             }
  421.                             while ((!*O0) || (!(*O0 - 32)))
  422.                             {
  423.                                 *O1 = '(';
  424.                                 O1++;
  425.                                 O0++;
  426.                                 goto start;
  427.                             }
  428.                             break;
  429.                         }
  430.                         while ((!*O0) || (!(*O0 - 32)))
  431.                         {
  432.                             *O1 = 'Y';
  433.                             O1++;
  434.                             O0++;
  435.                             goto start;
  436.                         }
  437.                         break;
  438.                     }
  439.                     while (!(*O0 - 46))
  440.                     {
  441.                         O0++;
  442.                         while (!(*O0 - (38+7)))
  443.                         {
  444.                             O0++;
  445.                             while (!(*O0 - (38+7)))
  446.                             {
  447.                                 O0++;
  448.                                    while ((!*O0) || (!(*O0 - 32)))
  449.                                 {
  450.                                     continue;
  451.                                 }
  452.                                 break;
  453.                             }
  454.                             while (!(*O0 - 46))
  455.                             {
  456.                                 O0++;
  457.                                 while ((!*O0) || (!(*O0 - 32)))
  458.                                 {
  459.                                     continue;
  460.                                 }
  461.                                 break;
  462.                             }
  463.                             while ((!*O0) || (!(*O0 - 32)))
  464.                             {
  465.                                 *O1 = ';';
  466.                                 O1++;
  467.                                 O0++;
  468.                                 goto start;
  469.                             }
  470.                             break;
  471.                         }
  472.                            while (!(*O0 - 46))
  473.                         {
  474.                             O0++;
  475.                             while (!(*O0 - (38+7)))
  476.                             {
  477.                                 O0++;
  478.                                 while ((!*O0) || (!(*O0 - 32)))
  479.                                 {
  480.                                     continue;
  481.                                 }
  482.                                 break;
  483.                             }
  484.                             while (!(*O0 - 46))
  485.                             {
  486.                                 O0++;
  487.                                 while ((!*O0) || (!(*O0 - 32)))
  488.                                 {
  489.                                     continue;
  490.                                 }
  491.                                 break;
  492.                             }
  493.                             while ((!*O0) || (!(*O0 - 32)))
  494.                             {
  495.                                 continue;
  496.                                }
  497.                             break;
  498.                         }
  499.                         while ((!*O0) || (!(*O0 - 32)))
  500.                         {
  501.                             *O1 = 'C';
  502.                             O1++;
  503.                             O0++;
  504.                             goto start;
  505.                         }
  506.                         break;
  507.                     }
  508.                     while ((!*O0) || (!(*O0 - 32)))
  509.                     {
  510.                         *O1 = 'K';
  511.                         O1++;
  512.                         O0++;
  513.                         goto start;
  514.                     }
  515.                     break;
  516.                 }
  517.                 while (!(*O0 - 46))
  518.                     {
  519.                     O0++;
  520.                     while (!(*O0 - (38+7)))
  521.                     {
  522.                         O0++;
  523.                         while (!(*O0 - (38+7)))
  524.                         {
  525.                             O0++;
  526.                             while (!(*O0 - (38+7)))
  527.                             {
  528.                                 O0++;
  529.                                 while ((!*O0) || (!(*O0 - 32)))
  530.                                 {
  531.                                     continue;
  532.                                 }
  533.                                 break;
  534.                             }
  535.                             while (!(*O0 - 46))
  536.                             {
  537.                                 O0++;
  538.                                 while ((!*O0) || (!(*O0 - 32)))
  539.                                 {
  540.                                     continue;
  541.                                 }
  542.                                     break;
  543.                             }
  544.                             while ((!*O0) || (!(*O0 - 32)))
  545.                             {
  546.                                 continue;
  547.                             }
  548.                             break;
  549.                         }
  550.                         while (!(*O0 - 46))
  551.                         {
  552.                             O0++;
  553.                             while (!(*O0 - (38+7)))
  554.                             {
  555.                                 O0++;
  556.                                 while ((!*O0) || (!(*O0 - 32)))
  557.                                 {
  558.                                     continue;
  559.                                 }
  560.                                             break;
  561.                             }
  562.                             while (!(*O0 - 46))
  563.                             {
  564.                                 O0++;
  565.                                 while ((!*O0) || (!(*O0 - 32)))
  566.                                 {
  567.                                     continue;
  568.                                 }
  569.                                 break;
  570.                             }
  571.                             while ((!*O0) || (!(*O0 - 32)))
  572.                             {
  573.                                 *O1 = '/';
  574.                                 O1++;
  575.                                 O0++;
  576.                                 goto start;
  577.                             }
  578.                             break;
  579.                         }
  580.                         while ((!*O0) || (!(*O0 - 32)))
  581.                         {
  582.                             *O1 = 'X';
  583.                             O1++;
  584.                             O0++;                        goto start;
  585.                         }
  586.                         break;
  587.                     }
  588.                     while (!(*O0 - 46))
  589.                     {
  590.                         O0++;
  591.                         while (!(*O0 - (38+7)))
  592.                         {
  593.                             O0++;
  594.                             while (!(*O0 - (38+7)))
  595.                             {
  596.                                 O0++;
  597.                                 while ((!*O0) || (!(*O0 - 32)))
  598.                                 {
  599.                                     continue;
  600.                                 }
  601.                                 break;
  602.                             }
  603.                             while (!(*O0 - 46))
  604.                             {
  605.                                 O0++;
  606.                                 while ((!*O0) || (!(*O0 - 32)))
  607.                                 {
  608.                                     continue;
  609.                                 }
  610.                                 break;
  611.                             }
  612.                             while ((!*O0) || (!(*O0 - 32)))
  613.                                      {
  614.                                 *O1 = '=';
  615.                                 O1++;
  616.                                 O0++;
  617.                                 goto start;
  618.                             }
  619.                             break;
  620.                         }
  621.                         while (!(*O0 - 46))
  622.                         {
  623.                             O0++;
  624.                             while (!(*O0 - (38+7)))
  625.                             {
  626.                                 O0++;
  627.                                 while ((!*O0) || (!(*O0 - 32)))
  628.                                 {
  629.                                     *O1 = '-';
  630.                                     O1++;
  631.                                     O0++;
  632.                                     goto start;
  633.                                 }
  634.                                 break;
  635.                             }
  636.                             while (!(*O0 - 46))
  637.                             {
  638.                                 O0++;
  639.                                 while ((!*O0) || (!(*O0 - 32)))
  640.                                 {
  641.                                     continue;
  642.                                 }
  643.                                 break;
  644.                             }
  645.                                  while ((!*O0) || (!(*O0 - 32)))
  646.                             {
  647.                                 *O1 = '6';
  648.                                 O1++;
  649.                                 O0++;
  650.                                 goto start;
  651.                             }
  652.                             break;
  653.                         }
  654.                         while ((!*O0) || (!(*O0 - 32)))
  655.                         {
  656.                             *O1 = 'B';
  657.                             O1++;
  658.                             O0++;
  659.                             goto start;
  660.                         }
  661.                         break;
  662.                     }
  663.                     while ((!*O0) || (!(*O0 - 32)))
  664.                              {
  665.                         *O1 = 'D';
  666.                         O1++;
  667.                         O0++;
  668.                         goto start;
  669.                     }
  670.                     break;
  671.                 }
  672.                 while ((!*O0) || (!(*O0 - 32)))
  673.                 {
  674.                     *O1 = 'N';
  675.                     O1++;
  676.                     O0++;
  677.                     goto start;
  678.                 }
  679.                 break;
  680.             }
  681.             while ((!*O0) || (!(*O0 - 32)))
  682.             {
  683.                          *O1 = 'T';
  684.                
  685.                 O1++;
  686.                 O0++;
  687.                 goto start;
  688.             }
  689.             break;
  690.         }
  691.         while (!(*O0 - 46))
  692.         {
  693.             O0++;
  694.             while (!(*O0 - (38+7)))
  695.             {
  696.                 O0++;
  697.                 while (!(*O0 - (38+7)))
  698.                 {
  699.                     O0++;
  700.                     while (!(*O0 - (38+7)))
  701.                     {
  702.                         O0++;
  703.                         while (!(*O0 - (38+7)))
  704.                         {
  705.                             O0++;
  706.                             while (!(*O0 - (38+7)))
  707.                             {
  708.                                 O0++;
  709.                                 while ((!*O0) || (!(*O0 - 32)))
  710.                                 {
  711.                                     continue;
  712.                                 }
  713.                                 break;
  714.                             }
  715.                             while (!(*O0 - 46))
  716.                             {
  717.                                 O0++;
  718.                                 while ((!*O0) || (!(*O0 - 32)))
  719.                                 {
  720.                                     *O1 = '\'';
  721.                                     O1++;
  722.                                     O0++;
  723.                                     goto start;
  724.                                 }
  725.                                 break;
  726.                             }
  727.                             while ((!*O0) || (!(*O0 - 32)))
  728.                             {
  729.                                 *O1 = '1';
  730.                                 O1++;
  731.                                 O0++;
  732.                                 goto start;
  733.                             }
  734.                             break;
  735.                         }
  736.                         while (!(*O0 - 46))
  737.                         {
  738.                             O0++;
  739.                             while (!(*O0 - (38+7)))
  740.                             {
  741.                                 O0++;
  742.                                 while ((!*O0) || (!(*O0 - 32)))
  743.                                 {
  744.                                     continue;
  745.                                 }
  746.                                 break;
  747.                             }
  748.                             while (!(*O0 - 46))
  749.                             {
  750.                                 O0++;
  751.                                 while ((!*O0) || (!(*O0 - 32)))
  752.                                 {
  753.                                     continue;
  754.                                 }
  755.                                 break;
  756.                             }
  757.                             while ((!*O0) || (!(*O0 - 32)))
  758.                             {
  759.                                 continue;
  760.                             }
  761.                             break;
  762.                         }
  763.                         while ((!*O0) || (!(*O0 - 32)))
  764.                         {
  765.                             *O1 = 'j';
  766.                             O1++;
  767.                             O0++;
  768.                             goto start;
  769.                         }
  770.                         break;
  771.                     }
  772.                     while (!(*O0 - 46))
  773.                     {
  774.                         O0++;
  775.                         while (!(*O0 - (38+7)))
  776.                         {
  777.                             O0++;
  778.                             while (!(*O0 - (38+7)))
  779.                             {
  780.                                 O0++;
  781.                                 while ((!*O0) || (!(*O0 - 32)))
  782.                                 {
  783.                                     continue;
  784.                                 }
  785.                                 break;
  786.                             }
  787.                             while (!(*O0 - 46))
  788.                             {
  789.                                 O0++;
  790.                                 while ((!*O0) || (!(*O0 - 32)))
  791.                                 {
  792.                                     *O1 = '@';
  793.                                     O1++;
  794.                                     O0++;
  795.                                     goto start;
  796.                                 }
  797.                                 break;
  798.                             }
  799.                             while ((!*O0) || (!(*O0 - 32)))
  800.                             {
  801.                                 continue;
  802.                             }
  803.                             break;
  804.                         }
  805.                         while (!(*O0 - 46))
  806.                         {
  807.                             O0++;
  808.                             while (!(*O0 - (38+7)))
  809.                             {
  810.                                 O0++;
  811.                                 while ((!*O0) || (!(*O0 - 32)))
  812.                                 {
  813.                                     continue;
  814.                                 }
  815.                                 break;
  816.                             }
  817.                             while (!(*O0 - 46))
  818.                             {
  819.                                 O0++;
  820.                                 while ((!*O0) || (!(*O0 - 32)))
  821.                                 {
  822.                                     continue;
  823.                                 }
  824.                                 break;
  825.                             }
  826.                             while ((!*O0) || (!(*O0 - 32)))
  827.                             {
  828.                                 continue;
  829.                             }
  830.                             break;
  831.                         }
  832.                         while ((!*O0) || (!(*O0 - 32)))
  833.                         {
  834.                             *O1 = 'P';
  835.                             O1++;
  836.                             O0++;
  837.                             goto start;
  838.                         }
  839.                         break;
  840.                     }
  841.                     while ((!*O0) || (!(*O0 - 32)))
  842.                     {
  843.                         *O1 = 'W';
  844.                         O1++;
  845.                         O0++;
  846.                         goto start;
  847.                     }
  848.                     break;
  849.                 }
  850.                 while (!(*O0 - 46))
  851.                 {
  852.                     O0++;
  853.                     while (!(*O0 - (38+7)))
  854.                     {
  855.                         O0++;
  856.                         while (!(*O0 - (38+7)))
  857.                         {
  858.                             O0++;
  859.                             while (!(*O0 - (38+7)))
  860.                             {
  861.                                 O0++;
  862.                                 while ((!*O0) || (!(*O0 - 32)))
  863.                                 {
  864.                                     continue;
  865.                                 }
  866.                                 break;
  867.                             }
  868.                             while (!(*O0 - 46))
  869.                             {
  870.                                 O0++;
  871.                                 while ((!*O0) || (!(*O0 - 32)))
  872.                                 {
  873.                                     continue;
  874.                                 }
  875.                                 break;
  876.                             }
  877.                             while ((!*O0) || (!(*O0 - 32)))
  878.                             {
  879.                                 continue;
  880.                             }
  881.                             break;
  882.                         }
  883.                         while (!(*O0 - 46))
  884.                         {
  885.                             O0++;
  886.                             while (!(*O0 - (38+7)))
  887.                             {
  888.                                 O0++;
  889.                                 while ((!*O0) || (!(*O0 - 32)))
  890.                                 {
  891.                                     *O1 = '.';
  892.                                     O1++;
  893.                                     O0++;
  894.                                     goto start;
  895.                                 }
  896.                                 break;
  897.                             }
  898.                             while (!(*O0 - 46))
  899.                             {
  900.                                 O0++;
  901.                                 while ((!*O0) || (!(*O0 - 32)))
  902.                                 {
  903.                                     continue;
  904.                                 }
  905.                                 break;
  906.                             }
  907.                             while ((!*O0) || (!(*O0 - 32)))
  908.                             {
  909.                                 continue;
  910.                             }
  911.                             break;
  912.                         }
  913.                         while ((!*O0) || (!(*O0 - 32)))
  914.                         {
  915.                             continue;
  916.                         }
  917.                         break;
  918.                     }
  919.                     while (!(*O0 - 46))
  920.                     {
  921.                         O0++;
  922.                         while (!(*O0 - (38+7)))
  923.                         {
  924.                             O0++;
  925.                             while (!(*O0 - (38+7)))
  926.                             {
  927.                                 O0++;
  928.                                 while ((!*O0) || (!(*O0 - 32)))
  929.                                 {
  930.                                     continue;
  931.                                 }
  932.                                 break;
  933.                             }
  934.                             while (!(*O0 - 46))
  935.                             {
  936.                                 O0++;
  937.                                 while ((!*O0) || (!(*O0 - 32)))
  938.                                 {
  939.                                     continue;
  940.                                 }
  941.                                 break;
  942.                             }
  943.                             while ((!*O0) || (!(*O0 - 32)))
  944.                             {
  945.                                 continue;
  946.                             }
  947.                             break;
  948.                         }
  949.                         while (!(*O0 - 46))
  950.                         {
  951.                             O0++;
  952.                             while (!(*O0 - (38+7)))
  953.                             {
  954.                                 O0++;
  955.                                 while ((!*O0) || (!(*O0 - 32)))
  956.                                 {
  957.                                     continue;
  958.                                 }
  959.                                 break;
  960.                             }
  961.                             while (!(*O0 - 46))
  962.                             {
  963.                                 O0++;
  964.                                 while ((!*O0) || (!(*O0 - 32)))
  965.                                 {
  966.                                     continue;
  967.                                 }
  968.                                 break;
  969.                             }
  970.                             while ((!*O0) || (!(*O0 - 32)))
  971.                             {
  972.                                 continue;
  973.                             }
  974.                             break;
  975.                         }
  976.                         while ((!*O0) || (!(*O0 - 32)))
  977.                         {
  978.                             *O1 = 'L';
  979.                             O1++;
  980.                             O0++;
  981.                             goto start;
  982.                         }
  983.                         break;
  984.                     }
  985.                     while ((!*O0) || (!(*O0 - 32)))
  986.                     {
  987.                         *O1 = 'R';
  988.                         O1++;
  989.                         O0++;
  990.                         goto start;
  991.                     }
  992.                     break;
  993.                 }
  994.                 while ((!*O0) || (!(*O0 - 32)))
  995.                 {
  996.                     *O1 = 'A';
  997.                     O1++;
  998.                     O0++;
  999.                     goto start;
  1000.                 }
  1001.                 break;
  1002.             }
  1003.             while (!(*O0 - 46))
  1004.             {
  1005.                 O0++;
  1006.                 while (!(*O0 - (38+7)))
  1007.                 {
  1008.                     O0++;
  1009.                     while (!(*O0 - (38+7)))
  1010.                     {
  1011.                         O0++;
  1012.                         while (!(*O0 - (38+7)))
  1013.                         {
  1014.                             O0++;
  1015.                             while (!(*O0 - (38+7)))
  1016.                             {
  1017.                                 O0++;
  1018.                                 while ((!*O0) || (!(*O0 - 32)))
  1019.                                 {
  1020.                                     continue;
  1021.                                 }
  1022.                                 break;
  1023.                             }
  1024.                             while (!(*O0 - 46))
  1025.                             {
  1026.                                 O0++;
  1027.                                 while ((!*O0) || (!(*O0 - 32)))
  1028.                                 {
  1029.                                     continue;
  1030.                                 }
  1031.                                 break;
  1032.                             }
  1033.                             while ((!*O0) || (!(*O0 - 32)))
  1034.                             {
  1035.                                 *O1 = '2';
  1036.                                 O1++;
  1037.                                 O0++;
  1038.                                 goto start;
  1039.                             }
  1040.                             break;
  1041.                         }
  1042.                         while (!(*O0 - 46))
  1043.                         {
  1044.                             O0++;
  1045.                             while (!(*O0 - (38+7)))
  1046.                             {
  1047.                                 O0++;
  1048.                                 while ((!*O0) || (!(*O0 - 32)))
  1049.                                 {
  1050.                                     continue;
  1051.                                 }
  1052.                                 break;
  1053.                             }
  1054.                             while (!(*O0 - 46))
  1055.                             {
  1056.                                 O0++;
  1057.                                 while ((!*O0) || (!(*O0 - 32)))
  1058.                                 {
  1059.                                     *O1 = '?';
  1060.                                     O1++;
  1061.                                     O0++;
  1062.                                     goto start;
  1063.                                 }
  1064.                                 break;
  1065.                             }
  1066.                             while ((!*O0) || (!(*O0 - 32)))
  1067.                             {
  1068.                                 continue;
  1069.                             }
  1070.                             break;
  1071.                         }
  1072.                         while ((!*O0) || (!(*O0 - 32)))
  1073.                         {
  1074.                             continue;
  1075.                         }
  1076.                         break;
  1077.                     }
  1078.                     while (!(*O0 - 46))
  1079.                     {
  1080.                         O0++;
  1081.                         while (!(*O0 - (38+7)))
  1082.                         {
  1083.                             O0++;
  1084.                             while (!(*O0 - (38+7)))
  1085.                             {
  1086.                                 O0++;
  1087.                                 while ((!*O0) || (!(*O0 - 32)))
  1088.                                 {
  1089.                                     continue;
  1090.                                 }
  1091.                                 break;
  1092.                             }
  1093.                             while (!(*O0 - 46))
  1094.                             {
  1095.                                 O0++;
  1096.                                 while ((!*O0) || (!(*O0 - 32)))
  1097.                                 {
  1098.                                     continue;
  1099.                                 }
  1100.                                 break;
  1101.                             }
  1102.                             while ((!*O0) || (!(*O0 - 32)))
  1103.                             {
  1104.                                 continue;
  1105.                             }
  1106.                             break;
  1107.                         }
  1108.                         while (!(*O0 - 46))
  1109.                         {
  1110.                             O0++;
  1111.                             while (!(*O0 - (38+7)))
  1112.                             {
  1113.                                 O0++;
  1114.                                 while ((!*O0) || (!(*O0 - 32)))
  1115.                                 {
  1116.                                     continue;
  1117.                                 }
  1118.                                 break;
  1119.                             }
  1120.                             while (!(*O0 - 46))
  1121.                             {
  1122.                                 O0++;
  1123.                                 while ((!*O0) || (!(*O0 - 32)))
  1124.                                 {
  1125.                                     continue;
  1126.                                 }
  1127.                                 break;
  1128.                             }
  1129.                             while ((!*O0) || (!(*O0 - 32)))
  1130.                             {
  1131.                                 continue;
  1132.                             }
  1133.                             break;
  1134.                         }
  1135.                         while ((!*O0) || (!(*O0 - 32)))
  1136.                         {
  1137.                             *O1 = 'F';
  1138.                             O1++;
  1139.                             O0++;
  1140.                             goto start;
  1141.                         }
  1142.                         break;
  1143.                     }
  1144.                     while ((!*O0) || (!(*O0 - 32)))
  1145.                     {
  1146.                         *O1 = 'U';
  1147.                         O1++;
  1148.                         O0++;
  1149.                         goto start;
  1150.                     }
  1151.                     break;
  1152.                 }
  1153.                 while (!(*O0 - 46))
  1154.                 {
  1155.                     O0++;
  1156.                     while (!(*O0 - (38+7)))
  1157.                     {
  1158.                         O0++;
  1159.                         while (!(*O0 - (38+7)))
  1160.                         {
  1161.                             O0++;
  1162.                             while (!(*O0 - (38+7)))
  1163.                             {
  1164.                                 O0++;
  1165.                                 while ((!*O0) || (!(*O0 - 32)))
  1166.                                 {
  1167.                                     continue;
  1168.                                 }
  1169.                                 break;
  1170.                             }
  1171.                             while (!(*O0 - 46))
  1172.                             {
  1173.                                 O0++;
  1174.                                 while ((!*O0) || (!(*O0 - 32)))
  1175.                                 {
  1176.                                     continue;
  1177.                                 }
  1178.                                 break;
  1179.                             }
  1180.                             while ((!*O0) || (!(*O0 - 32)))
  1181.                             {
  1182.                                 *O1 = '3';
  1183.                                 O1++;
  1184.                                 O0++;
  1185.                                 goto start;
  1186.                             }
  1187.                             break;
  1188.                         }
  1189.                         while (!(*O0 - 46))
  1190.                         {
  1191.                             O0++;
  1192.                             while (!(*O0 - (38+7)))
  1193.                             {
  1194.                                 O0++;
  1195.                                 while ((!*O0) || (!(*O0 - 32)))
  1196.                                 {
  1197.                                     continue;
  1198.                                 }
  1199.                                 break;
  1200.                             }
  1201.                             while (!(*O0 - 46))
  1202.                             {
  1203.                                 O0++;
  1204.                                 while ((!*O0) || (!(*O0 - 32)))
  1205.                                 {
  1206.                                     continue;
  1207.                                 }
  1208.                                 break;
  1209.                             }
  1210.                             while ((!*O0) || (!(*O0 - 32)))
  1211.                             {
  1212.                                 continue;
  1213.                             }
  1214.                             break;
  1215.                         }
  1216.                         while ((!*O0) || (!(*O0 - 32)))
  1217.                         {
  1218.                             *O1 = 'V';
  1219.                             O1++;
  1220.                             O0++;
  1221.                             goto start;
  1222.                         }
  1223.                         break;
  1224.                     }
  1225.                     while (!(*O0 - 46))
  1226.                     {
  1227.                         O0++;
  1228.                         while (!(*O0 - (38+7)))
  1229.                         {
  1230.                             O0++;
  1231.                             while (!(*O0 - (38+7)))
  1232.                             {
  1233.                                 O0++;
  1234.                                 while ((!*O0) || (!(*O0 - 32)))
  1235.                                 {
  1236.                                     continue;
  1237.                                 }
  1238.                                 break;
  1239.                             }
  1240.                             while (!(*O0 - 46))
  1241.                             {
  1242.                                 O0++;
  1243.                                 while ((!*O0) || (!(*O0 - 32)))
  1244.                                 {
  1245.                                     *O1 = '4';
  1246.                                     O1++;
  1247.                                     O0++;
  1248.                                     goto start;
  1249.                                 }
  1250.                                 break;
  1251.                             }
  1252.                             while ((!*O0) || (!(*O0 - 32)))
  1253.                             {
  1254.                                 *O1 = '4';
  1255.                                 O1++;
  1256.                                 O0++;
  1257.                                 goto start;
  1258.                             }
  1259.                             break;
  1260.                         }
  1261.                         while (!(*O0 - 46))
  1262.                         {
  1263.                             O0++;
  1264.                             while (!(*O0 - (38+7)))
  1265.                             {
  1266.                                 O0++;
  1267.                                 while ((!*O0) || (!(*O0 - 32)))
  1268.                                 {
  1269.                                     continue;
  1270.                                 }
  1271.                                 break;
  1272.                             }
  1273.                             while (!(*O0 - 46))
  1274.                             {
  1275.                                 O0++;
  1276.                                 while ((!*O0) || (!(*O0 - 32)))
  1277.                                 {
  1278.                                     continue;
  1279.                                 }
  1280.                                 break;
  1281.                             }
  1282.                             while ((!*O0) || (!(*O0 - 32)))
  1283.                             {
  1284.                                 *O1 = '5';
  1285.                                 O1++;
  1286.                                 O0++;
  1287.                                 goto start;
  1288.                             }
  1289.                             break;
  1290.                         }
  1291.                         while ((!*O0) || (!(*O0 - 32)))
  1292.                         {
  1293.                             *O1 = 'H';
  1294.                             O1++;
  1295.                             O0++;
  1296.                             goto start;
  1297.                         }
  1298.                         break;
  1299.                     }
  1300.                     while ((!*O0) || (!(*O0 - 32)))
  1301.                     {
  1302.                         *O1 = 'S';
  1303.                         O1++;
  1304.                         O0++;
  1305.                         goto start;
  1306.                     }
  1307.                     break;
  1308.                 }
  1309.                 while ((!*O0) || (!(*O0 - 32)))
  1310.                 {
  1311.                     *O1 = 'I';
  1312.                     O1++;
  1313.                     O0++;
  1314.                     goto start;
  1315.                 }
  1316.                 break;
  1317.             }
  1318.             while ((!*O0) || (!(*O0 - 32)))
  1319.             {
  1320.                 *O1 = 'E';
  1321.                 O1++;
  1322.                 O0++;
  1323.                 goto start;
  1324.             }
  1325.             break;
  1326.         }
  1327.         while (!(*O0 - 47))
  1328.         {
  1329.             O0++;
  1330.             while ((!*O0) || (!(*O0 - 32)))
  1331.             {
  1332.                 *O1 = ' ';
  1333.                 O1++;
  1334.                 O0++;
  1335.                 goto start;
  1336.             }
  1337.             break;
  1338.         }
  1339.  
  1340.         break;
  1341.     }
  1342.     O1++;
  1343.     *O1 = '\0';
  1344.    
  1345.     char* outputparser = &output[0];
  1346.     while(*outputparser) {
  1347.     int O3 = 0;
  1348.     *input = *outputparser;
  1349.     outputparser++;
  1350.     input++;
  1351.     }
  1352.  
  1353.    while(*input) {
  1354.         *input = '\0';
  1355.         input++;
  1356.     }
  1357.  
  1358.  
  1359.  
  1360.  
  1361.  
  1362. }
  1363.  
  1364.  
  1365. void main() {
  1366. printf("plz input morsecode");
  1367. char morsecode[999999] = {'\0'};
  1368. //Enough space for long inputs;
  1369. char *code;
  1370. code = &morsecode[1];
  1371.  
  1372. scanf("%[^\n]s", code);
  1373. morse(code);
  1374. printf("Result: %s\n", code);
  1375. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!