home *** CD-ROM | disk | FTP | other *** search
/ Graphics 16,000 / graphics-16000.iso / amiga / fractal / mak / source.lzh / Source / L&S_Parms.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-29  |  61.3 KB  |  1,770 lines
  1. /************************************************************************
  2.  
  3.               L O A D   A N D   S A V E   P A R A M E T E R S
  4.  
  5. ************************************************************************/
  6.  
  7. #include <stdio.h>
  8. #include <exec/types.h>
  9. #include <intuition/intuition.h>
  10.  
  11. extern struct IntuiText ok_request;
  12.  
  13. extern struct ViewPort *vp;
  14. extern struct TextAttr Font;
  15. extern struct Window *file_window;
  16. extern struct MenuItem Iterations[];
  17. extern int maxcolr, *Zones[];
  18. extern long da_W, da_H, da_TE, da_LE;
  19. extern float realmin, realmax, imagmin, imagmax, jl_rlmin,
  20.              jl_rlmax, jl_imgmin, jl_imgmax, rlparm, imparm;
  21. extern SHORT FractalType;
  22. extern USHORT colortable[];
  23. extern unsigned char zn1_StringBuffer[], zn2_StringBuffer[],
  24.        zn3_StringBuffer[], zn4_StringBuffer[], zn5_StringBuffer[],
  25.        zn6_StringBuffer[], zn7_StringBuffer[], zn8_StringBuffer[],
  26.        zn9_StringBuffer[], zn10_StringBuffer[], zn11_StringBuffer[],
  27.        zn12_StringBuffer[], zn13_StringBuffer[], zn14_StringBuffer[],
  28.        zn15_StringBuffer[], zn16_StringBuffer[], zn17_StringBuffer[],
  29.        zn18_StringBuffer[], zn19_StringBuffer[], zn20_StringBuffer[],
  30.        zn21_StringBuffer[], zn22_StringBuffer[], zn23_StringBuffer[], 
  31.        zn24_StringBuffer[], zn25_StringBuffer[], zn26_StringBuffer[], 
  32.        zn27_StringBuffer[], zn28_StringBuffer[], zn29_StringBuffer[], 
  33.        zn30_StringBuffer[], zn31_StringBuffer[], zn32_StringBuffer[], 
  34.        zn33_StringBuffer[], zn34_StringBuffer[], zn35_StringBuffer[], 
  35.        zn36_StringBuffer[], zn37_StringBuffer[], zn38_StringBuffer[], 
  36.        zn39_StringBuffer[], zn40_StringBuffer[], zn41_StringBuffer[],
  37.        zn42_StringBuffer[], zn43_StringBuffer[], zn44_StringBuffer[],
  38.        zn45_StringBuffer[], zn46_StringBuffer[], zn47_StringBuffer[],
  39.        zn48_StringBuffer[], zn49_StringBuffer[], zn50_StringBuffer[];
  40.        
  41. extern unsigned char zn51_StringBuffer[], zn52_StringBuffer[], 
  42.        zn53_StringBuffer[], zn54_StringBuffer[], zn55_StringBuffer[], 
  43.        zn56_StringBuffer[], zn57_StringBuffer[], zn58_StringBuffer[], 
  44.        zn59_StringBuffer[], zn60_StringBuffer[], zn61_StringBuffer[], 
  45.        zn62_StringBuffer[], zn63_StringBuffer[], zn64_StringBuffer[], 
  46.        zn65_StringBuffer[], zn66_StringBuffer[], zn67_StringBuffer[], 
  47.        zn68_StringBuffer[], zn69_StringBuffer[], zn70_StringBuffer[], 
  48.        zn71_StringBuffer[], zn72_StringBuffer[], zn73_StringBuffer[], 
  49.        zn74_StringBuffer[], zn75_StringBuffer[], zn76_StringBuffer[], 
  50.        zn77_StringBuffer[], zn78_StringBuffer[], zn79_StringBuffer[], 
  51.        zn80_StringBuffer[], zn81_StringBuffer[], zn82_StringBuffer[], 
  52.        zn83_StringBuffer[], zn84_StringBuffer[], zn85_StringBuffer[], 
  53.        zn86_StringBuffer[], zn87_StringBuffer[], zn88_StringBuffer[], 
  54.        zn89_StringBuffer[], zn90_StringBuffer[], zn91_StringBuffer[], 
  55.        zn92_StringBuffer[], zn93_StringBuffer[], zn94_StringBuffer[], 
  56.        zn95_StringBuffer[], zn96_StringBuffer[], zn97_StringBuffer[], 
  57.        zn98_StringBuffer[], zn99_StringBuffer[], zn100_StringBuffer[];
  58.        
  59.  
  60. extern unsigned char zn101_StringBuffer[], zn102_StringBuffer[],
  61.        zn103_StringBuffer[], zn104_StringBuffer[], zn105_StringBuffer[],
  62.        zn106_StringBuffer[], zn107_StringBuffer[], zn108_StringBuffer[],
  63.        zn109_StringBuffer[], zn110_StringBuffer[], zn111_StringBuffer[],
  64.        zn112_StringBuffer[], zn113_StringBuffer[], zn114_StringBuffer[],
  65.        zn115_StringBuffer[], zn116_StringBuffer[], zn117_StringBuffer[],
  66.        zn118_StringBuffer[], zn119_StringBuffer[], zn120_StringBuffer[],
  67.        zn121_StringBuffer[], zn122_StringBuffer[], zn123_StringBuffer[], 
  68.        zn124_StringBuffer[], zn125_StringBuffer[], zn126_StringBuffer[], 
  69.        zn127_StringBuffer[], zn128_StringBuffer[], zn129_StringBuffer[], 
  70.        zn130_StringBuffer[], zn131_StringBuffer[], zn132_StringBuffer[], 
  71.        zn133_StringBuffer[], zn134_StringBuffer[], zn135_StringBuffer[], 
  72.        zn136_StringBuffer[], zn137_StringBuffer[], zn138_StringBuffer[], 
  73.        zn139_StringBuffer[], zn140_StringBuffer[], zn141_StringBuffer[],
  74.        zn142_StringBuffer[], zn143_StringBuffer[], zn144_StringBuffer[],
  75.        zn145_StringBuffer[], zn146_StringBuffer[], zn147_StringBuffer[],
  76.        zn148_StringBuffer[], zn149_StringBuffer[], zn150_StringBuffer[];
  77.        
  78. extern unsigned char       
  79.        zn151_StringBuffer[], zn152_StringBuffer[], zn153_StringBuffer[], 
  80.        zn154_StringBuffer[], zn155_StringBuffer[], zn156_StringBuffer[], 
  81.        zn157_StringBuffer[], zn158_StringBuffer[], zn159_StringBuffer[], 
  82.        zn160_StringBuffer[], zn161_StringBuffer[], zn162_StringBuffer[], 
  83.        zn163_StringBuffer[], zn164_StringBuffer[], zn165_StringBuffer[], 
  84.        zn166_StringBuffer[], zn167_StringBuffer[], zn168_StringBuffer[], 
  85.        zn169_StringBuffer[], zn170_StringBuffer[], zn171_StringBuffer[],
  86.        zn172_StringBuffer[], zn173_StringBuffer[], zn174_StringBuffer[],
  87.        zn175_StringBuffer[], zn176_StringBuffer[], zn177_StringBuffer[],
  88.        zn178_StringBuffer[], zn179_StringBuffer[], zn180_StringBuffer[],
  89.        zn181_StringBuffer[], zn182_StringBuffer[], zn183_StringBuffer[], 
  90.        zn184_StringBuffer[], zn185_StringBuffer[], zn186_StringBuffer[], 
  91.        zn187_StringBuffer[], zn188_StringBuffer[], zn189_StringBuffer[], 
  92.        zn190_StringBuffer[], zn191_StringBuffer[], zn192_StringBuffer[], 
  93.        zn193_StringBuffer[], zn194_StringBuffer[], zn195_StringBuffer[], 
  94.        zn196_StringBuffer[], zn197_StringBuffer[], zn198_StringBuffer[], 
  95.        zn199_StringBuffer[], zn200_StringBuffer[];
  96.  
  97. extern struct StringInfo *zn1_ptr, *zn2_ptr, *zn3_ptr, *zn4_ptr, 
  98.        *zn5_ptr, *zn6_ptr, *zn7_ptr, *zn8_ptr, *zn9_ptr, 
  99.        *zn10_ptr, *zn11_ptr, *zn12_ptr, *zn13_ptr, *zn14_ptr,
  100.        *zn15_ptr, *zn16_ptr, *zn17_ptr, *zn18_ptr, *zn19_ptr,
  101.        *zn20_ptr, *zn21_ptr, *zn22_ptr, *zn23_ptr, *zn24_ptr,
  102.        *zn25_ptr, *zn26_ptr, *zn27_ptr, *zn28_ptr, *zn29_ptr,
  103.        *zn30_ptr, *zn31_ptr, *zn32_ptr, *zn33_ptr, *zn34_ptr,
  104.        *zn35_ptr, *zn36_ptr, *zn37_ptr, *zn38_ptr, *zn39_ptr,
  105.        *zn40_ptr, *zn41_ptr, *zn42_ptr, *zn43_ptr, *zn44_ptr,
  106.        *zn45_ptr, *zn46_ptr, *zn47_ptr, *zn48_ptr, *zn49_ptr,
  107.        *zn50_ptr, *zn51_ptr, *zn52_ptr, *zn53_ptr, *zn54_ptr,
  108.        *zn55_ptr, *zn56_ptr, *zn57_ptr, *zn58_ptr, *zn59_ptr,
  109.        *zn60_ptr, *zn61_ptr, *zn62_ptr, *zn63_ptr, *zn64_ptr,
  110.        *zn65_ptr, *zn66_ptr, *zn67_ptr, *zn68_ptr, *zn69_ptr,
  111.        *zn70_ptr, *zn71_ptr, *zn72_ptr, *zn73_ptr, *zn74_ptr,
  112.        *zn75_ptr, *zn76_ptr, *zn77_ptr, *zn78_ptr, *zn79_ptr,
  113.        *zn80_ptr, *zn81_ptr, *zn82_ptr, *zn83_ptr, *zn84_ptr,
  114.        *zn85_ptr, *zn86_ptr, *zn87_ptr, *zn88_ptr, *zn89_ptr,
  115.        *zn90_ptr, *zn91_ptr, *zn92_ptr, *zn93_ptr, *zn94_ptr,
  116.        *zn95_ptr, *zn96_ptr, *zn97_ptr, *zn98_ptr, *zn99_ptr,
  117.        *zn100_ptr;
  118.        
  119. extern struct StringInfo *zn101_ptr, *zn102_ptr, *zn103_ptr, *zn104_ptr, 
  120.        *zn105_ptr, *zn106_ptr, *zn107_ptr, *zn108_ptr, *zn109_ptr, 
  121.        *zn110_ptr, *zn111_ptr, *zn112_ptr, *zn113_ptr, *zn114_ptr,
  122.        *zn115_ptr, *zn116_ptr, *zn117_ptr, *zn118_ptr, *zn119_ptr,
  123.        *zn120_ptr, *zn121_ptr, *zn122_ptr, *zn123_ptr, *zn124_ptr,
  124.        *zn125_ptr, *zn126_ptr, *zn127_ptr, *zn128_ptr, *zn129_ptr,
  125.        *zn130_ptr, *zn131_ptr, *zn132_ptr, *zn133_ptr, *zn134_ptr,
  126.        *zn135_ptr, *zn136_ptr, *zn137_ptr, *zn138_ptr, *zn139_ptr,
  127.        *zn140_ptr, *zn141_ptr, *zn142_ptr, *zn143_ptr, *zn144_ptr,
  128.        *zn145_ptr, *zn146_ptr, *zn147_ptr, *zn148_ptr, *zn149_ptr,
  129.        *zn150_ptr, *zn151_ptr, *zn152_ptr, *zn153_ptr, *zn154_ptr,
  130.        *zn155_ptr, *zn156_ptr, *zn157_ptr, *zn158_ptr, *zn159_ptr,
  131.        *zn160_ptr, *zn161_ptr, *zn162_ptr, *zn163_ptr, *zn164_ptr,
  132.        *zn165_ptr, *zn166_ptr, *zn167_ptr, *zn168_ptr, *zn169_ptr,
  133.        *zn170_ptr, *zn171_ptr, *zn172_ptr, *zn173_ptr, *zn174_ptr,
  134.        *zn175_ptr, *zn176_ptr, *zn177_ptr, *zn178_ptr, *zn179_ptr,
  135.        *zn180_ptr, *zn181_ptr, *zn182_ptr, *zn183_ptr, *zn184_ptr,
  136.        *zn185_ptr, *zn186_ptr, *zn187_ptr, *zn188_ptr, *zn189_ptr,
  137.        *zn190_ptr, *zn191_ptr, *zn192_ptr, *zn193_ptr, *zn194_ptr,
  138.        *zn195_ptr, *zn196_ptr, *zn197_ptr, *zn198_ptr, *zn199_ptr,
  139.        *zn200_ptr;       
  140.        
  141. extern struct StringInfo zn1_StringInfo, zn2_StringInfo,
  142.   zn3_StringInfo, zn4_StringInfo, zn5_StringInfo, zn6_StringInfo,
  143.   zn7_StringInfo, zn8_StringInfo, zn9_StringInfo, zn10_StringInfo,
  144.   zn11_StringInfo, zn12_StringInfo, zn13_StringInfo, zn14_StringInfo, 
  145.   zn15_StringInfo, zn16_StringInfo, zn17_StringInfo, zn18_StringInfo, 
  146.   zn19_StringInfo, zn20_StringInfo, zn21_StringInfo, zn22_StringInfo,
  147.   zn23_StringInfo, zn24_StringInfo, zn25_StringInfo, zn26_StringInfo,
  148.   zn27_StringInfo, zn28_StringInfo, zn29_StringInfo, zn30_StringInfo,
  149.   zn31_StringInfo, zn32_StringInfo, zn33_StringInfo, zn34_StringInfo, 
  150.   zn35_StringInfo, zn36_StringInfo, zn37_StringInfo, zn38_StringInfo, 
  151.   zn39_StringInfo, zn40_StringInfo, zn41_StringInfo, zn42_StringInfo,
  152.   zn43_StringInfo, zn44_StringInfo, zn45_StringInfo, zn46_StringInfo,
  153.   zn47_StringInfo, zn48_StringInfo, zn49_StringInfo, zn50_StringInfo,
  154.   zn51_StringInfo, zn52_StringInfo, zn53_StringInfo, zn54_StringInfo, 
  155.   zn55_StringInfo, zn56_StringInfo, zn57_StringInfo, zn58_StringInfo, 
  156.   zn59_StringInfo, zn60_StringInfo, zn61_StringInfo, zn62_StringInfo,
  157.   zn63_StringInfo, zn64_StringInfo, zn65_StringInfo, zn66_StringInfo,
  158.   zn67_StringInfo, zn68_StringInfo, zn69_StringInfo, zn70_StringInfo,
  159.   zn71_StringInfo, zn72_StringInfo, zn73_StringInfo, zn74_StringInfo, 
  160.   zn75_StringInfo, zn76_StringInfo, zn77_StringInfo, zn78_StringInfo, 
  161.   zn79_StringInfo, zn80_StringInfo, zn81_StringInfo, zn82_StringInfo,
  162.   zn83_StringInfo, zn84_StringInfo, zn85_StringInfo, zn86_StringInfo,
  163.   zn87_StringInfo, zn88_StringInfo, zn89_StringInfo, zn90_StringInfo,
  164.   zn91_StringInfo, zn92_StringInfo, zn93_StringInfo, zn94_StringInfo, 
  165.   zn95_StringInfo, zn96_StringInfo, zn97_StringInfo, zn98_StringInfo, 
  166.   zn99_StringInfo, zn100_StringInfo;
  167.   
  168. extern struct StringInfo zn101_StringInfo, zn102_StringInfo,
  169.   zn103_StringInfo, zn104_StringInfo, zn105_StringInfo, zn106_StringInfo,
  170.   zn107_StringInfo, zn108_StringInfo, zn109_StringInfo, zn110_StringInfo,
  171.   zn111_StringInfo, zn112_StringInfo, zn113_StringInfo, zn114_StringInfo, 
  172.   zn115_StringInfo, zn116_StringInfo, zn117_StringInfo, zn118_StringInfo, 
  173.   zn119_StringInfo, zn120_StringInfo, zn121_StringInfo, zn122_StringInfo,
  174.   zn123_StringInfo, zn124_StringInfo, zn125_StringInfo, zn126_StringInfo,
  175.   zn127_StringInfo, zn128_StringInfo, zn129_StringInfo, zn130_StringInfo,
  176.   zn131_StringInfo, zn132_StringInfo, zn133_StringInfo, zn134_StringInfo, 
  177.   zn135_StringInfo, zn136_StringInfo, zn137_StringInfo, zn138_StringInfo, 
  178.   zn139_StringInfo, zn140_StringInfo, zn141_StringInfo, zn142_StringInfo,
  179.   zn143_StringInfo, zn144_StringInfo, zn145_StringInfo, zn146_StringInfo,
  180.   zn147_StringInfo, zn148_StringInfo, zn149_StringInfo, zn150_StringInfo,
  181.   zn151_StringInfo, zn152_StringInfo, zn153_StringInfo, zn154_StringInfo, 
  182.   zn155_StringInfo, zn156_StringInfo, zn157_StringInfo, zn158_StringInfo, 
  183.   zn159_StringInfo, zn160_StringInfo, zn161_StringInfo, zn162_StringInfo,
  184.   zn163_StringInfo, zn164_StringInfo, zn165_StringInfo, zn166_StringInfo,
  185.   zn167_StringInfo, zn168_StringInfo, zn169_StringInfo, zn170_StringInfo,
  186.   zn171_StringInfo, zn172_StringInfo, zn173_StringInfo, zn174_StringInfo, 
  187.   zn175_StringInfo, zn176_StringInfo, zn177_StringInfo, zn178_StringInfo, 
  188.   zn179_StringInfo, zn180_StringInfo, zn181_StringInfo, zn182_StringInfo,
  189.   zn183_StringInfo, zn184_StringInfo, zn185_StringInfo, zn186_StringInfo,
  190.   zn187_StringInfo, zn188_StringInfo, zn189_StringInfo, zn190_StringInfo,
  191.   zn191_StringInfo, zn192_StringInfo, zn193_StringInfo, zn194_StringInfo, 
  192.   zn195_StringInfo, zn196_StringInfo, zn197_StringInfo, zn198_StringInfo, 
  193.   zn199_StringInfo, zn200_StringInfo;  
  194.            
  195. extern unsigned char da_H_StringBuffer[], da_W_StringBuffer[],
  196.                      da_TE_StringBuffer[], da_LE_StringBuffer[];
  197.    
  198. extern struct StringInfo *da_H_ptr, *da_W_ptr, *da_TE_ptr, *da_LE_ptr;
  199.  
  200. extern struct StringInfo da_H_StringInfo, da_W_StringInfo,
  201.                          da_TE_StringInfo, da_LE_StringInfo;
  202.                          
  203. extern unsigned char fv_rn_StringBuffer[], fv_rx_StringBuffer[],
  204.                      fv_in_StringBuffer[], fv_ix_StringBuffer[];
  205.                      
  206. extern unsigned char jv_rn_StringBuffer[], jv_rx_StringBuffer[],
  207.                      jv_in_StringBuffer[], jv_ix_StringBuffer[],
  208.                      rl_pm_StringBuffer[], im_pm_StringBuffer[];
  209.  
  210. struct IntuiText prompt =
  211.   { 0, 2, JAM1, 6, 3, &Font, NULL, NULL };                               
  212.    
  213.        
  214. SaveParms(filename)
  215. char *filename;
  216.   {
  217.     char mainMessage[40];
  218.     
  219.     FILE *SaveFile;
  220.     int count, i;
  221.     
  222.     SaveFile = fopen(filename, "w");
  223.     
  224.     if(SaveFile == (FILE *)NULL)
  225.       {
  226.         strcpy(mainMessage,"Can't open the file");
  227.         prompt.IText = mainMessage;
  228.         AutoRequest(file_window,&prompt,&ok_request,
  229.                                  NULL,NULL,NULL,320,72); 
  230.         return(FALSE);
  231.       }
  232.     
  233.     if(FractalType == 1 || FractalType == 2)
  234.       { 
  235.         fwrite((char *) "PARMS", 5, 1, SaveFile);
  236.     
  237.         fwrite((char *) &FractalType, sizeof(FractalType), 1, SaveFile);
  238.     
  239.         for(i = 0; i < 16; i++)
  240.            {
  241.              fwrite((char *) &colortable[i], sizeof(USHORT), 1, SaveFile);
  242.            }
  243.        
  244.         fwrite((char *) &da_W, sizeof(da_W), 1, SaveFile);
  245.         fwrite((char *) &da_H, sizeof(da_H), 1, SaveFile);
  246.         fwrite((char *) &da_TE, sizeof(da_TE), 1, SaveFile);
  247.         fwrite((char *) &da_LE, sizeof(da_LE), 1, SaveFile);
  248.     
  249.         if(FractalType == 1)
  250.           {
  251.             fwrite((char *) &realmin, sizeof(realmin), 1, SaveFile);
  252.             fwrite((char *) &realmax, sizeof(realmax), 1, SaveFile);
  253.             fwrite((char *) &imagmax, sizeof(imagmax), 1, SaveFile);
  254.             fwrite((char *) &imagmin, sizeof(imagmin), 1, SaveFile);
  255.           }
  256.       
  257.         if(FractalType == 2)
  258.           {
  259.             fwrite((char *) &jl_rlmin, sizeof(jl_rlmin), 1, SaveFile);
  260.             fwrite((char *) &jl_rlmax, sizeof(jl_rlmax), 1, SaveFile);
  261.             fwrite((char *) &jl_imgmax, sizeof(jl_imgmax), 1, SaveFile);
  262.             fwrite((char *) &jl_imgmin, sizeof(jl_imgmin), 1, SaveFile);
  263.             fwrite((char *) &rlparm, sizeof(rlparm), 1, SaveFile);
  264.             fwrite((char *) &imparm, sizeof(imparm), 1, SaveFile);
  265.           }  
  266.     
  267.     
  268.         fwrite((char *) &maxcolr, sizeof(maxcolr), 1, SaveFile);
  269.     
  270.         switch(maxcolr)
  271.           {
  272.             case 25:
  273.                for(count = 0; count < 25; count++)
  274.                  {
  275.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  276.                  }          
  277.                break;
  278.             
  279.             case 50:
  280.                for(count = 0; count < 38; count++)
  281.                  {
  282.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  283.                  }                                                    
  284.                break;
  285.                
  286.             case 75:
  287.                for(count = 0; count < 50; count++)
  288.                  {
  289.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  290.                  }          
  291.                break;   
  292.  
  293.             case 100:
  294.                for(count = 0; count < 63; count++)
  295.                  {
  296.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  297.                  }          
  298.                break;
  299.                
  300.             case 125:
  301.                for(count = 0; count < 75; count++)
  302.                  {
  303.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  304.                  }          
  305.                break;   
  306.                
  307.             case 175:
  308.                for(count = 0; count < 100; count++)
  309.                  {
  310.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  311.                  }          
  312.                break;   
  313.                
  314.             case 225:   
  315.                for(count = 0; count < 125; count++)
  316.                  {
  317.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  318.                  }          
  319.                break;
  320.                
  321.             case 275:
  322.                for(count = 0; count < 150; count++)
  323.                  {
  324.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  325.                  }          
  326.                break;   
  327.                
  328.             case 325:
  329.                for(count = 0; count < 175; count++)
  330.                  {
  331.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  332.                  }          
  333.                break;   
  334.                
  335.             case 375:
  336.                for(count = 0; count < 200; count++)
  337.                  {
  338.                    fwrite((char *) Zones[count], sizeof(int), 1, SaveFile);
  339.                  }          
  340.                break; 
  341.           }  /*  Switch Statement  */
  342.           
  343.         fclose(SaveFile);
  344.         return(TRUE);
  345.       } /*  If FractalType  */    
  346.     else
  347.       {
  348.         strcpy(mainMessage,"Nothing to save");
  349.         prompt.IText = mainMessage;
  350.         AutoRequest(file_window,&prompt,&ok_request,
  351.                                  NULL,NULL,NULL,320,72); 
  352.         fclose(SaveFile);
  353.         return(FALSE);
  354.       }            
  355.   } /*  SaveParms  */                 
  356.  
  357.  
  358. LoadParms(filename)
  359. char *filename;
  360.   {
  361.     void resetIterations();
  362.     char mainMessage[40];
  363.     
  364.     FILE *LoadFile;
  365.     char string[5], File_Header[6];
  366.     int count, i;
  367.     
  368.     da_W_ptr = &da_W_StringInfo;
  369.     da_H_ptr = &da_H_StringInfo;
  370.     da_TE_ptr = &da_TE_StringInfo;
  371.     da_LE_ptr = &da_LE_StringInfo;
  372.     
  373.     LoadFile = fopen(filename, "r");
  374.     
  375.     if(LoadFile == (FILE *)NULL)
  376.       {
  377.         strcpy(mainMessage,"Can't open the file");
  378.         prompt.IText = mainMessage;
  379.         AutoRequest(file_window,&prompt,&ok_request,
  380.                                  NULL,NULL,NULL,320,72); 
  381.         return(FALSE);
  382.       }
  383.     
  384.     fread((char *) &File_Header[0], 5, 1, LoadFile);
  385.     File_Header[5] = '\0';
  386.     
  387.     if(strcmp(&File_Header[0], "PARMS") != 0)
  388.       {
  389.         strcpy(mainMessage,"Not a parameter file");
  390.         prompt.IText = mainMessage;
  391.         AutoRequest(file_window,&prompt,&ok_request,
  392.                                  NULL,NULL,NULL,320,72);
  393.         fclose(LoadFile);
  394.         return(FALSE);
  395.       }   
  396.     else
  397.       {
  398.         fread((char *) &FractalType, sizeof(SHORT), 1, LoadFile);
  399.     
  400.         for(i=0;i<16;i++)
  401.           {
  402.            fread((char *) &colortable[i], sizeof(USHORT), 1, LoadFile);
  403.           } 
  404.        
  405.         LoadRGB4(vp,&colortable,16);
  406.         
  407.         fread((char *) &da_W, sizeof(long), 1, LoadFile);
  408.         fread((char *) &da_H, sizeof(long), 1, LoadFile);
  409.         fread((char *) &da_TE, sizeof(long), 1, LoadFile);
  410.         fread((char *) &da_LE, sizeof(long), 1, LoadFile);
  411.         
  412.         sprintf(&string[0],"%d",da_W);
  413.         strcpy(da_W_StringBuffer, string);
  414.         da_W_ptr->LongInt = da_W;
  415.         sprintf(&string[0],"%d",da_H);
  416.         strcpy(da_H_StringBuffer, string);
  417.         da_H_ptr->LongInt = da_H;
  418.         sprintf(&string[0],"%d",da_TE);
  419.         strcpy(da_TE_StringBuffer, string);
  420.         da_TE_ptr->LongInt = da_TE;
  421.         sprintf(&string[0],"%d",da_LE);
  422.         strcpy(da_LE_StringBuffer, string);
  423.         da_LE_ptr->LongInt = da_LE;
  424.             
  425.         if(FractalType == 1)
  426.           {
  427.             fread((char *) &realmin, sizeof(float), 1, LoadFile);
  428.             fread((char *) &realmax, sizeof(float), 1, LoadFile);
  429.             fread((char *) &imagmax, sizeof(float), 1, LoadFile);
  430.             fread((char *) &imagmin, sizeof(float), 1, LoadFile);
  431.             
  432.             sprintf(&string[0],"%f",realmin);
  433.             strcpy(fv_rn_StringBuffer,string);
  434.             sprintf(&string[0],"%f",realmax);
  435.             strcpy(fv_rx_StringBuffer,string);
  436.             sprintf(&string[0],"%f",imagmax);
  437.             strcpy(fv_ix_StringBuffer,string);
  438.             sprintf(&string[0],"%f",imagmin);
  439.             strcpy(fv_in_StringBuffer,string);
  440.           }
  441.       
  442.         if(FractalType == 2)
  443.           {
  444.             fread((char *) &jl_rlmin, sizeof(float), 1, LoadFile);
  445.             fread((char *) &jl_rlmax, sizeof(float), 1, LoadFile);
  446.             fread((char *) &jl_imgmax, sizeof(float), 1, LoadFile);
  447.             fread((char *) &jl_imgmin, sizeof(float), 1, LoadFile);
  448.             fread((char *) &rlparm, sizeof(float), 1, LoadFile);
  449.             fread((char *) &imparm, sizeof(float), 1, LoadFile);
  450.             
  451.             sprintf(&string[0],"%f",jl_rlmin);
  452.             strcpy(jv_rn_StringBuffer,string);
  453.             sprintf(&string[0],"%f",jl_rlmax);
  454.             strcpy(jv_rx_StringBuffer,string);
  455.             sprintf(&string[0],"%f",jl_imgmax);
  456.             strcpy(jv_ix_StringBuffer,string);
  457.             sprintf(&string[0],"%f",jl_imgmin);
  458.             strcpy(jv_in_StringBuffer,string);
  459.             sprintf(&string[0],"%f",rlparm);
  460.             strcpy(rl_pm_StringBuffer,string);
  461.             sprintf(&string[0],"%f",imparm);
  462.             strcpy(im_pm_StringBuffer,string);
  463.           }  
  464.     
  465.     
  466.         fread((char *) &maxcolr, sizeof(int), 1, LoadFile);
  467.     
  468.         switch(maxcolr)
  469.           {
  470.             case 25:
  471.                for(count = 0; count < 25; count++)
  472.                  {
  473.                   fread((char *) Zones[count], sizeof(int), 1, LoadFile);
  474.                  }
  475.                updateZonegadgs(maxcolr);
  476.                resetIterations(); 
  477.                Iterations[0].Flags |= CHECKED; 
  478.                break;
  479.             
  480.             case 50:
  481.                for(count = 0; count < 38; count++)
  482.                  {
  483.                    fread((char *) Zones[count], sizeof(int),
  484.                            1, LoadFile);
  485.                  }                 
  486.                updateZonegadgs(maxcolr);
  487.                resetIterations();  
  488.                Iterations[1].Flags |= CHECKED;                            
  489.                break;
  490.                
  491.             case 75:
  492.                for(count = 0; count < 50; count++)
  493.                  {
  494.                    fread((char *) Zones[count], sizeof(int),
  495.                            1, LoadFile);
  496.                  }
  497.                updateZonegadgs(maxcolr);
  498.                resetIterations();
  499.                Iterations[2].Flags |= CHECKED;              
  500.                break;   
  501.  
  502.             case 100:
  503.                for(count = 0; count < 63; count++)
  504.                  {
  505.                    fread((char *) Zones[count], sizeof(int),
  506.                            1, LoadFile);
  507.                  }
  508.                updateZonegadgs(maxcolr);
  509.                resetIterations();
  510.                Iterations[3].Flags |= CHECKED;              
  511.                break;
  512.                
  513.             case 125:
  514.                for(count = 0; count < 75; count++)
  515.                  {
  516.                    fread((char *) Zones[count], sizeof(int),
  517.                            1, LoadFile);
  518.                  }
  519.                updateZonegadgs(maxcolr);
  520.                resetIterations();
  521.                Iterations[4].Flags |= CHECKED;               
  522.                break;   
  523.                
  524.             case 175:
  525.                for(count = 0; count < 100; count++)
  526.                  {
  527.                    fread((char *) Zones[count], sizeof(int),
  528.                            1, LoadFile);
  529.                  } 
  530.                updateZonegadgs(maxcolr);
  531.                resetIterations();
  532.                Iterations[5].Flags |= CHECKED;              
  533.                break;   
  534.                
  535.             case 225:   
  536.                for(count = 0; count < 125; count++)
  537.                  {
  538.                    fread((char *) Zones[count], sizeof(int),
  539.                            1, LoadFile);
  540.                  }
  541.                updateZonegadgs(maxcolr);
  542.                resetIterations();
  543.                Iterations[6].Flags |= CHECKED;               
  544.                break;
  545.                
  546.             case 275:
  547.                for(count = 0; count < 150; count++)
  548.                  {
  549.                    fread((char *) Zones[count], sizeof(int),
  550.                            1, LoadFile);
  551.                  }
  552.                updateZonegadgs(maxcolr);
  553.                resetIterations();
  554.                Iterations[7].Flags |= CHECKED;               
  555.                break;   
  556.                
  557.             case 325:
  558.                for(count = 0; count < 175; count++)
  559.                  {
  560.                    fread((char *) Zones[count], sizeof(int),
  561.                            1, LoadFile);
  562.                  }
  563.                updateZonegadgs(maxcolr);
  564.                resetIterations();
  565.                Iterations[8].Flags |= CHECKED;               
  566.                break;   
  567.                
  568.             case 375:
  569.                for(count = 0; count < 200; count++)
  570.                  {
  571.                    fread((char *) Zones[count], sizeof(int),
  572.                            1, LoadFile);
  573.                  } 
  574.                updateZonegadgs(maxcolr);
  575.                resetIterations();
  576.                Iterations[9].Flags |= CHECKED;              
  577.                break; 
  578.           }  /*  Switch Statement  */
  579.           
  580.         fclose(LoadFile);
  581.         return(TRUE);
  582.           
  583.       } /*  else  */    
  584.   } /*  LoadParms  */ 
  585.  
  586.  
  587.  
  588. updateZonegadgs(num)
  589. int num;
  590.    {
  591.      void doGroup1(), doGroup2(), doGroup3(), doGroup4(), doGroup5(),
  592.           doGroup6(), doGroup7(), doGroup8(), doGroup9(), doGroup10(); 
  593.      
  594.      int amnt;
  595.      
  596.      amnt = num / 25;
  597.       
  598.      switch(amnt)
  599.        {
  600.          case 1: doGroup1();
  601.                  break;
  602.             
  603.          case 2: doGroup1();
  604.                  doGroup2();
  605.                  break;
  606.                
  607.          case 3: doGroup1();
  608.                  doGroup2();
  609.                  doGroup3();
  610.                  break;   
  611.  
  612.          case 4: doGroup1();
  613.                  doGroup2();
  614.                  doGroup3();
  615.                  doGroup4();
  616.                  break;
  617.                
  618.          case 5: doGroup1();
  619.                  doGroup2();
  620.                  doGroup3();
  621.                  doGroup4();
  622.                  doGroup5();
  623.                  break;   
  624.                
  625.          case 7: doGroup1();
  626.                  doGroup2();
  627.                  doGroup3();
  628.                  doGroup4();
  629.                  doGroup5();
  630.                  doGroup6();
  631.                  break;   
  632.                
  633.          case 9: doGroup1();
  634.                  doGroup2();
  635.                  doGroup3();
  636.                  doGroup4();
  637.                  doGroup5();
  638.                  doGroup6();
  639.                  doGroup7();   
  640.                  break;
  641.                
  642.          case 11: doGroup1();
  643.                   doGroup2();
  644.                   doGroup3();
  645.                   doGroup4();
  646.                   doGroup5();
  647.                   doGroup6();
  648.                   doGroup7();
  649.                   doGroup8();
  650.                   break;   
  651.                
  652.          case 13: doGroup1();
  653.                   doGroup2();
  654.                   doGroup3();
  655.                   doGroup4();
  656.                   doGroup5();
  657.                   doGroup6();
  658.                   doGroup7();
  659.                   doGroup8();
  660.                   doGroup9();
  661.                   break;   
  662.                
  663.          case 15: doGroup1();
  664.                   doGroup2();
  665.                   doGroup3();
  666.                   doGroup4();
  667.                   doGroup5();
  668.                   doGroup6();
  669.                   doGroup7();
  670.                   doGroup8();
  671.                   doGroup9();
  672.                   doGroup10();
  673.                   break; 
  674.                   
  675.           }  /*  Switch Statement  */
  676.              
  677.      return(TRUE);               
  678.    }
  679.  
  680.  
  681. void doGroup1()
  682.   {
  683.     char str[4];
  684.     int number;
  685.     
  686.     zn1_ptr = &zn1_StringInfo;
  687.     zn2_ptr = &zn2_StringInfo;
  688.     zn3_ptr = &zn3_StringInfo;
  689.     zn4_ptr = &zn4_StringInfo;
  690.     zn5_ptr = &zn5_StringInfo;
  691.     zn6_ptr = &zn6_StringInfo;
  692.     zn7_ptr = &zn7_StringInfo;
  693.     zn8_ptr = &zn8_StringInfo;
  694.     zn9_ptr = &zn9_StringInfo;
  695.     zn10_ptr = &zn10_StringInfo;
  696.     zn11_ptr = &zn11_StringInfo;
  697.     zn12_ptr = &zn12_StringInfo;
  698.     zn13_ptr = &zn13_StringInfo;
  699.     zn14_ptr = &zn14_StringInfo;
  700.     zn15_ptr = &zn15_StringInfo;
  701.     zn16_ptr = &zn16_StringInfo;
  702.     zn17_ptr = &zn17_StringInfo;
  703.     zn18_ptr = &zn18_StringInfo;
  704.     zn19_ptr = &zn19_StringInfo;
  705.     zn20_ptr = &zn20_StringInfo;
  706.     zn21_ptr = &zn21_StringInfo;
  707.     zn22_ptr = &zn22_StringInfo;
  708.     zn23_ptr = &zn23_StringInfo;
  709.     zn24_ptr = &zn24_StringInfo;
  710.     zn25_ptr = &zn25_StringInfo;
  711.     
  712.     number = *Zones[0];    
  713.     sprintf(&str[0],"%d",number);
  714.     strcpy(zn1_StringBuffer, str);
  715.     zn1_ptr->LongInt = *Zones[0];
  716.     number = *Zones[1];    
  717.     sprintf(&str[0],"%d",number);
  718.     strcpy(zn2_StringBuffer, str);
  719.     zn2_ptr->LongInt = *Zones[1]; 
  720.     number = *Zones[2];    
  721.     sprintf(&str[0],"%d",number);
  722.     strcpy(zn3_StringBuffer, str);
  723.     zn3_ptr->LongInt = *Zones[2];
  724.     number = *Zones[3];    
  725.     sprintf(&str[0],"%d",number);
  726.     strcpy(zn4_StringBuffer, str);
  727.     zn4_ptr->LongInt = *Zones[3];
  728.     number = *Zones[4];    
  729.     sprintf(&str[0],"%d",number);
  730.     strcpy(zn5_StringBuffer, str);
  731.     zn5_ptr->LongInt = *Zones[4];
  732.     number = *Zones[5];    
  733.     sprintf(&str[0],"%d",number);
  734.     strcpy(zn6_StringBuffer, str);
  735.     zn6_ptr->LongInt = *Zones[5]; 
  736.     number = *Zones[6];    
  737.     sprintf(&str[0],"%d",number);
  738.     strcpy(zn7_StringBuffer, str);
  739.     zn7_ptr->LongInt = *Zones[6];
  740.     number = *Zones[7];    
  741.     sprintf(&str[0],"%d",number);
  742.     strcpy(zn8_StringBuffer, str);
  743.     zn8_ptr->LongInt = *Zones[7];  
  744.     number = *Zones[8];    
  745.     sprintf(&str[0],"%d",number);
  746.     strcpy(zn9_StringBuffer, str);
  747.     zn9_ptr->LongInt = *Zones[8];
  748.     number = *Zones[9];    
  749.     sprintf(&str[0],"%d",number);
  750.     strcpy(zn10_StringBuffer, str);
  751.     zn10_ptr->LongInt = *Zones[9]; 
  752.     number = *Zones[10];    
  753.     sprintf(&str[0],"%d",number);
  754.     strcpy(zn11_StringBuffer, str);
  755.     zn11_ptr->LongInt = *Zones[10];
  756.     number = *Zones[11];    
  757.     sprintf(&str[0],"%d",number);
  758.     strcpy(zn12_StringBuffer, str);
  759.     zn12_ptr->LongInt = *Zones[11];
  760.     number = *Zones[12];    
  761.     sprintf(&str[0],"%d",number);
  762.     strcpy(zn13_StringBuffer, str);
  763.     zn13_ptr->LongInt = *Zones[12];
  764.     number = *Zones[13];    
  765.     sprintf(&str[0],"%d",number);
  766.     strcpy(zn14_StringBuffer, str);
  767.     zn14_ptr->LongInt = *Zones[13]; 
  768.     number = *Zones[14];    
  769.     sprintf(&str[0],"%d",number);
  770.     strcpy(zn15_StringBuffer, str);
  771.     zn15_ptr->LongInt = *Zones[14];
  772.     number = *Zones[15];    
  773.     sprintf(&str[0],"%d",number);
  774.     strcpy(zn16_StringBuffer, str);
  775.     zn16_ptr->LongInt = *Zones[15]; 
  776.     number = *Zones[16];    
  777.     sprintf(&str[0],"%d",number);
  778.     strcpy(zn17_StringBuffer, str);
  779.     zn17_ptr->LongInt = *Zones[16];
  780.     number = *Zones[17];    
  781.     sprintf(&str[0],"%d",number);
  782.     strcpy(zn18_StringBuffer, str);
  783.     zn18_ptr->LongInt = *Zones[17]; 
  784.     number = *Zones[18];    
  785.     sprintf(&str[0],"%d",number);
  786.     strcpy(zn19_StringBuffer, str);
  787.     zn19_ptr->LongInt = *Zones[18];
  788.     number = *Zones[19];    
  789.     sprintf(&str[0],"%d",number);
  790.     strcpy(zn20_StringBuffer, str);
  791.     zn20_ptr->LongInt = *Zones[19];
  792.     number = *Zones[20];    
  793.     sprintf(&str[0],"%d",number);
  794.     strcpy(zn21_StringBuffer, str);
  795.     zn21_ptr->LongInt = *Zones[20];
  796.     number = *Zones[21];    
  797.     sprintf(&str[0],"%d",number);
  798.     strcpy(zn22_StringBuffer, str);
  799.     zn22_ptr->LongInt = *Zones[21]; 
  800.     number = *Zones[22];    
  801.     sprintf(&str[0],"%d",number);
  802.     strcpy(zn23_StringBuffer, str);
  803.     zn23_ptr->LongInt = *Zones[22];
  804.     number = *Zones[23];    
  805.     sprintf(&str[0],"%d",number);
  806.     strcpy(zn24_StringBuffer, str);
  807.     zn24_ptr->LongInt = *Zones[23]; 
  808.     number = *Zones[24];
  809.     strcpy(zn25_StringBuffer, str);
  810.     zn25_ptr->LongInt = *Zones[24]; 
  811.   } 
  812.   
  813. void doGroup2()
  814.   {
  815.     char str[4];
  816.     int number;
  817.     
  818.     zn26_ptr = &zn26_StringInfo;
  819.     zn27_ptr = &zn27_StringInfo;
  820.     zn28_ptr = &zn28_StringInfo;
  821.     zn29_ptr = &zn29_StringInfo;
  822.     zn30_ptr = &zn30_StringInfo;
  823.     zn31_ptr = &zn31_StringInfo;
  824.     zn32_ptr = &zn32_StringInfo;
  825.     zn33_ptr = &zn33_StringInfo;
  826.     zn34_ptr = &zn34_StringInfo;
  827.     zn35_ptr = &zn35_StringInfo;
  828.     zn36_ptr = &zn36_StringInfo;
  829.     zn37_ptr = &zn37_StringInfo;
  830.     zn38_ptr = &zn38_StringInfo;
  831.     
  832.     number = *Zones[25];    
  833.     sprintf(&str[0],"%d",number);
  834.     strcpy(zn26_StringBuffer, str);
  835.     zn26_ptr->LongInt = *Zones[25];
  836.     number = *Zones[26];    
  837.     sprintf(&str[0],"%d",number);
  838.     strcpy(zn27_StringBuffer, str);
  839.     zn27_ptr->LongInt = *Zones[26]; 
  840.     number = *Zones[27];    
  841.     sprintf(&str[0],"%d",number);
  842.     strcpy(zn28_StringBuffer, str);
  843.     zn28_ptr->LongInt = *Zones[27];
  844.     number = *Zones[28];    
  845.     sprintf(&str[0],"%d",number);
  846.     strcpy(zn29_StringBuffer, str);
  847.     zn29_ptr->LongInt = *Zones[28];
  848.     number = *Zones[29];    
  849.     sprintf(&str[0],"%d",number);
  850.     strcpy(zn30_StringBuffer, str);
  851.     zn30_ptr->LongInt = *Zones[29];
  852.     number = *Zones[30];    
  853.     sprintf(&str[0],"%d",number);
  854.     strcpy(zn31_StringBuffer, str);
  855.     zn31_ptr->LongInt = *Zones[30]; 
  856.     number = *Zones[31];    
  857.     sprintf(&str[0],"%d",number);
  858.     strcpy(zn32_StringBuffer, str);
  859.     zn32_ptr->LongInt = *Zones[31];
  860.     number = *Zones[32];    
  861.     sprintf(&str[0],"%d",number);
  862.     strcpy(zn33_StringBuffer, str);
  863.     zn33_ptr->LongInt = *Zones[32];  
  864.     number = *Zones[33];    
  865.     sprintf(&str[0],"%d",number);
  866.     strcpy(zn34_StringBuffer, str);
  867.     zn34_ptr->LongInt = *Zones[33];
  868.     number = *Zones[34];    
  869.     sprintf(&str[0],"%d",number);
  870.     strcpy(zn35_StringBuffer, str);
  871.     zn35_ptr->LongInt = *Zones[34]; 
  872.     number = *Zones[35];    
  873.     sprintf(&str[0],"%d",number);
  874.     strcpy(zn36_StringBuffer, str);
  875.     zn36_ptr->LongInt = *Zones[35];
  876.     number = *Zones[36];    
  877.     sprintf(&str[0],"%d",number);
  878.     strcpy(zn37_StringBuffer, str);
  879.     zn37_ptr->LongInt = *Zones[36];
  880.     number = *Zones[37];    
  881.     sprintf(&str[0],"%d",number);
  882.     strcpy(zn38_StringBuffer, str);
  883.     zn38_ptr->LongInt = *Zones[37];
  884.   }    
  885.  
  886. void doGroup3()
  887.   {
  888.     char str[4];
  889.     int number;
  890.    
  891.     zn39_ptr = &zn39_StringInfo;
  892.     zn40_ptr = &zn40_StringInfo;
  893.     zn41_ptr = &zn41_StringInfo;
  894.     zn42_ptr = &zn42_StringInfo;
  895.     zn43_ptr = &zn43_StringInfo;
  896.     zn44_ptr = &zn44_StringInfo;
  897.     zn45_ptr = &zn45_StringInfo;
  898.     zn46_ptr = &zn46_StringInfo;
  899.     zn47_ptr = &zn47_StringInfo;
  900.     zn48_ptr = &zn48_StringInfo;
  901.     zn49_ptr = &zn49_StringInfo;
  902.     zn50_ptr = &zn50_StringInfo;
  903.    
  904.     number = *Zones[38];    
  905.     sprintf(&str[0],"%d",number);
  906.     strcpy(zn39_StringBuffer, str);
  907.     zn39_ptr->LongInt = *Zones[38]; 
  908.     number = *Zones[39];    
  909.     sprintf(&str[0],"%d",number);
  910.     strcpy(zn40_StringBuffer, str);
  911.     zn40_ptr->LongInt = *Zones[39];
  912.     number = *Zones[40];    
  913.     sprintf(&str[0],"%d",number);
  914.     strcpy(zn41_StringBuffer, str);
  915.     zn41_ptr->LongInt = *Zones[40]; 
  916.     number = *Zones[41];    
  917.     sprintf(&str[0],"%d",number);
  918.     strcpy(zn42_StringBuffer, str);
  919.     zn42_ptr->LongInt = *Zones[41];
  920.     number = *Zones[42];    
  921.     sprintf(&str[0],"%d",number);
  922.     strcpy(zn43_StringBuffer, str);
  923.     zn43_ptr->LongInt = *Zones[42]; 
  924.     number = *Zones[43];    
  925.     sprintf(&str[0],"%d",number);
  926.     strcpy(zn44_StringBuffer, str);
  927.     zn44_ptr->LongInt = *Zones[43];
  928.     number = *Zones[44];    
  929.     sprintf(&str[0],"%d",number);
  930.     strcpy(zn45_StringBuffer, str);
  931.     zn45_ptr->LongInt = *Zones[44];
  932.     number = *Zones[45];    
  933.     sprintf(&str[0],"%d",number);
  934.     strcpy(zn46_StringBuffer, str);
  935.     zn46_ptr->LongInt = *Zones[45];
  936.     number = *Zones[46];    
  937.     sprintf(&str[0],"%d",number);
  938.     strcpy(zn47_StringBuffer, str);
  939.     zn47_ptr->LongInt = *Zones[46]; 
  940.     number = *Zones[47];    
  941.     sprintf(&str[0],"%d",number);
  942.     strcpy(zn48_StringBuffer, str);
  943.     zn48_ptr->LongInt = *Zones[47];
  944.     number = *Zones[48];    
  945.     sprintf(&str[0],"%d",number);
  946.     strcpy(zn49_StringBuffer, str);
  947.     zn49_ptr->LongInt = *Zones[48]; 
  948.     number = *Zones[49];
  949.     sprintf(&str[0],"%d",number);
  950.     strcpy(zn50_StringBuffer, str);
  951.     zn50_ptr->LongInt = *Zones[49];
  952.   }
  953.  
  954. void doGroup4()
  955.   {
  956.     char str[4];
  957.     int number;
  958.    
  959.     zn51_ptr = &zn51_StringInfo;
  960.     zn52_ptr = &zn52_StringInfo;
  961.     zn53_ptr = &zn53_StringInfo;
  962.     zn54_ptr = &zn54_StringInfo;
  963.     zn55_ptr = &zn55_StringInfo;
  964.     zn56_ptr = &zn56_StringInfo;
  965.     zn57_ptr = &zn57_StringInfo;
  966.     zn58_ptr = &zn58_StringInfo;
  967.     zn59_ptr = &zn59_StringInfo;
  968.     zn60_ptr = &zn60_StringInfo;
  969.     zn61_ptr = &zn61_StringInfo;
  970.     zn62_ptr = &zn62_StringInfo;
  971.     zn63_ptr = &zn63_StringInfo;
  972.    
  973.     number = *Zones[50];    
  974.     sprintf(&str[0],"%d",number);
  975.     strcpy(zn51_StringBuffer, str);
  976.     zn51_ptr->LongInt = *Zones[50]; 
  977.     number = *Zones[51];    
  978.     sprintf(&str[0],"%d",number);
  979.     strcpy(zn52_StringBuffer, str);
  980.     zn52_ptr->LongInt = *Zones[51];
  981.     number = *Zones[52];    
  982.     sprintf(&str[0],"%d",number);
  983.     strcpy(zn53_StringBuffer, str);
  984.     zn53_ptr->LongInt = *Zones[52]; 
  985.     number = *Zones[53];    
  986.     sprintf(&str[0],"%d",number);
  987.     strcpy(zn54_StringBuffer, str);
  988.     zn54_ptr->LongInt = *Zones[53];
  989.     number = *Zones[54];    
  990.     sprintf(&str[0],"%d",number);
  991.     strcpy(zn55_StringBuffer, str);
  992.     zn55_ptr->LongInt = *Zones[54]; 
  993.     number = *Zones[55];    
  994.     sprintf(&str[0],"%d",number);
  995.     strcpy(zn56_StringBuffer, str);
  996.     zn56_ptr->LongInt = *Zones[55];
  997.     number = *Zones[56];    
  998.     sprintf(&str[0],"%d",number);
  999.     strcpy(zn57_StringBuffer, str);
  1000.     zn57_ptr->LongInt = *Zones[56];
  1001.     number = *Zones[57];    
  1002.     sprintf(&str[0],"%d",number);
  1003.     strcpy(zn58_StringBuffer, str);
  1004.     zn58_ptr->LongInt = *Zones[57];
  1005.     number = *Zones[58];    
  1006.     sprintf(&str[0],"%d",number);
  1007.     strcpy(zn59_StringBuffer, str);
  1008.     zn59_ptr->LongInt = *Zones[58]; 
  1009.     number = *Zones[59];    
  1010.     sprintf(&str[0],"%d",number);
  1011.     strcpy(zn60_StringBuffer, str);
  1012.     zn60_ptr->LongInt = *Zones[59];
  1013.     number = *Zones[60];    
  1014.     sprintf(&str[0],"%d",number);
  1015.     strcpy(zn61_StringBuffer, str);
  1016.     zn61_ptr->LongInt = *Zones[60]; 
  1017.     number = *Zones[61];
  1018.     sprintf(&str[0],"%d",number);
  1019.     strcpy(zn62_StringBuffer, str);
  1020.     zn62_ptr->LongInt = *Zones[61];
  1021.     number = *Zones[62];
  1022.     sprintf(&str[0],"%d",number);
  1023.     strcpy(zn63_StringBuffer, str);
  1024.     zn63_ptr->LongInt = *Zones[62];
  1025.   }
  1026.  
  1027. void doGroup5()
  1028.   {
  1029.     char str[4];
  1030.     int number;
  1031.    
  1032.     zn64_ptr = &zn64_StringInfo;
  1033.     zn65_ptr = &zn65_StringInfo;
  1034.     zn66_ptr = &zn66_StringInfo;
  1035.     zn67_ptr = &zn67_StringInfo;
  1036.     zn68_ptr = &zn68_StringInfo;
  1037.     zn69_ptr = &zn69_StringInfo;
  1038.     zn70_ptr = &zn70_StringInfo;
  1039.     zn71_ptr = &zn71_StringInfo;
  1040.     zn72_ptr = &zn72_StringInfo;
  1041.     zn73_ptr = &zn73_StringInfo;
  1042.     zn74_ptr = &zn74_StringInfo;
  1043.     zn75_ptr = &zn75_StringInfo;
  1044.    
  1045.     number = *Zones[63];    
  1046.     sprintf(&str[0],"%d",number);
  1047.     strcpy(zn64_StringBuffer, str);
  1048.     zn64_ptr->LongInt = *Zones[63]; 
  1049.     number = *Zones[64];    
  1050.     sprintf(&str[0],"%d",number);
  1051.     strcpy(zn65_StringBuffer, str);
  1052.     zn65_ptr->LongInt = *Zones[64];
  1053.     number = *Zones[65];    
  1054.     sprintf(&str[0],"%d",number);
  1055.     strcpy(zn66_StringBuffer, str);
  1056.     zn66_ptr->LongInt = *Zones[65]; 
  1057.     number = *Zones[66];    
  1058.     sprintf(&str[0],"%d",number);
  1059.     strcpy(zn67_StringBuffer, str);
  1060.     zn67_ptr->LongInt = *Zones[66];
  1061.     number = *Zones[67];    
  1062.     sprintf(&str[0],"%d",number);
  1063.     strcpy(zn68_StringBuffer, str);
  1064.     zn68_ptr->LongInt = *Zones[67]; 
  1065.     number = *Zones[68];    
  1066.     sprintf(&str[0],"%d",number);
  1067.     strcpy(zn69_StringBuffer, str);
  1068.     zn69_ptr->LongInt = *Zones[68];
  1069.     number = *Zones[69];    
  1070.     sprintf(&str[0],"%d",number);
  1071.     strcpy(zn70_StringBuffer, str);
  1072.     zn70_ptr->LongInt = *Zones[69];
  1073.     number = *Zones[70];    
  1074.     sprintf(&str[0],"%d",number);
  1075.     strcpy(zn71_StringBuffer, str);
  1076.     zn71_ptr->LongInt = *Zones[70];
  1077.     number = *Zones[71];    
  1078.     sprintf(&str[0],"%d",number);
  1079.     strcpy(zn72_StringBuffer, str);
  1080.     zn72_ptr->LongInt = *Zones[71]; 
  1081.     number = *Zones[72];    
  1082.     sprintf(&str[0],"%d",number);
  1083.     strcpy(zn73_StringBuffer, str);
  1084.     zn73_ptr->LongInt = *Zones[72];
  1085.     number = *Zones[73];    
  1086.     sprintf(&str[0],"%d",number);
  1087.     strcpy(zn74_StringBuffer, str);
  1088.     zn74_ptr->LongInt = *Zones[73]; 
  1089.     number = *Zones[74];
  1090.     sprintf(&str[0],"%d",number);
  1091.     strcpy(zn75_StringBuffer, str);
  1092.     zn75_ptr->LongInt = *Zones[74];
  1093.   }
  1094.   
  1095. void doGroup6()
  1096.   {
  1097.     char str[4];
  1098.     int number;
  1099.    
  1100.     zn76_ptr = &zn76_StringInfo;
  1101.     zn77_ptr = &zn77_StringInfo;
  1102.     zn78_ptr = &zn78_StringInfo;
  1103.     zn79_ptr = &zn79_StringInfo;
  1104.     zn80_ptr = &zn80_StringInfo;
  1105.     zn81_ptr = &zn81_StringInfo;
  1106.     zn82_ptr = &zn82_StringInfo;
  1107.     zn83_ptr = &zn83_StringInfo;
  1108.     zn84_ptr = &zn84_StringInfo;
  1109.     zn85_ptr = &zn85_StringInfo;
  1110.     zn86_ptr = &zn86_StringInfo;
  1111.     zn87_ptr = &zn87_StringInfo;
  1112.     zn88_ptr = &zn88_StringInfo;
  1113.     zn89_ptr = &zn89_StringInfo;
  1114.     zn90_ptr = &zn90_StringInfo;
  1115.     zn91_ptr = &zn91_StringInfo;
  1116.     zn92_ptr = &zn92_StringInfo;
  1117.     zn93_ptr = &zn93_StringInfo;
  1118.     zn94_ptr = &zn94_StringInfo;
  1119.     zn95_ptr = &zn95_StringInfo;
  1120.     zn96_ptr = &zn96_StringInfo;
  1121.     zn97_ptr = &zn97_StringInfo;
  1122.     zn98_ptr = &zn98_StringInfo;
  1123.     zn99_ptr = &zn99_StringInfo;
  1124.     zn100_ptr = &zn100_StringInfo;
  1125.     
  1126.     number = *Zones[75];
  1127.     sprintf(&str[0],"%d",number);
  1128.     strcpy(zn76_StringBuffer, str);
  1129.     zn76_ptr->LongInt = *Zones[75];
  1130.     number = *Zones[76];    
  1131.     sprintf(&str[0],"%d",number);
  1132.     strcpy(zn77_StringBuffer, str);
  1133.     zn77_ptr->LongInt = *Zones[76];
  1134.     number = *Zones[77];    
  1135.     sprintf(&str[0],"%d",number);
  1136.     strcpy(zn78_StringBuffer, str);
  1137.     zn78_ptr->LongInt = *Zones[77]; 
  1138.     number = *Zones[78];    
  1139.     sprintf(&str[0],"%d",number);
  1140.     strcpy(zn79_StringBuffer, str);
  1141.     zn79_ptr->LongInt = *Zones[78];
  1142.     number = *Zones[79];    
  1143.     sprintf(&str[0],"%d",number);
  1144.     strcpy(zn80_StringBuffer, str);
  1145.     zn80_ptr->LongInt = *Zones[79];
  1146.     number = *Zones[80];    
  1147.     sprintf(&str[0],"%d",number);
  1148.     strcpy(zn81_StringBuffer, str);
  1149.     zn81_ptr->LongInt = *Zones[80];
  1150.     number = *Zones[81];    
  1151.     sprintf(&str[0],"%d",number);
  1152.     strcpy(zn82_StringBuffer, str);
  1153.     zn82_ptr->LongInt = *Zones[81]; 
  1154.     number = *Zones[82];    
  1155.     sprintf(&str[0],"%d",number);
  1156.     strcpy(zn83_StringBuffer, str);
  1157.     zn83_ptr->LongInt = *Zones[82];
  1158.     number = *Zones[83];    
  1159.     sprintf(&str[0],"%d",number);
  1160.     strcpy(zn84_StringBuffer, str);
  1161.     zn84_ptr->LongInt = *Zones[83]; 
  1162.     number = *Zones[84];
  1163.     sprintf(&str[0],"%d",number);
  1164.     strcpy(zn85_StringBuffer, str);
  1165.     zn85_ptr->LongInt = *Zones[84];
  1166.     number = *Zones[85];
  1167.     sprintf(&str[0],"%d",number);
  1168.     strcpy(zn86_StringBuffer, str);
  1169.     zn86_ptr->LongInt = *Zones[85];
  1170.     number = *Zones[86];    
  1171.     sprintf(&str[0],"%d",number);
  1172.     strcpy(zn87_StringBuffer, str);
  1173.     zn87_ptr->LongInt = *Zones[86]; 
  1174.     number = *Zones[87];    
  1175.     sprintf(&str[0],"%d",number);
  1176.     strcpy(zn88_StringBuffer, str);
  1177.     zn88_ptr->LongInt = *Zones[87]; 
  1178.     number = *Zones[88];    
  1179.     sprintf(&str[0],"%d",number);
  1180.     strcpy(zn89_StringBuffer, str);
  1181.     zn89_ptr->LongInt = *Zones[88];
  1182.     number = *Zones[89];    
  1183.     sprintf(&str[0],"%d",number);
  1184.     strcpy(zn90_StringBuffer, str);
  1185.     zn90_ptr->LongInt = *Zones[89];
  1186.     number = *Zones[90];    
  1187.     sprintf(&str[0],"%d",number);
  1188.     strcpy(zn91_StringBuffer, str);
  1189.     zn91_ptr->LongInt = *Zones[90];
  1190.     number = *Zones[91];    
  1191.     sprintf(&str[0],"%d",number);
  1192.     strcpy(zn92_StringBuffer, str);
  1193.     zn92_ptr->LongInt = *Zones[91]; 
  1194.     number = *Zones[92];    
  1195.     sprintf(&str[0],"%d",number);
  1196.     strcpy(zn93_StringBuffer, str);
  1197.     zn93_ptr->LongInt = *Zones[92];
  1198.     number = *Zones[93];    
  1199.     sprintf(&str[0],"%d",number);
  1200.     strcpy(zn94_StringBuffer, str);
  1201.     zn94_ptr->LongInt = *Zones[93];
  1202.     number = *Zones[94];
  1203.     sprintf(&str[0],"%d",number);
  1204.     strcpy(zn95_StringBuffer, str);
  1205.     zn95_ptr->LongInt = *Zones[94];
  1206.     number = *Zones[95];
  1207.     sprintf(&str[0],"%d",number);
  1208.     strcpy(zn96_StringBuffer, str);
  1209.     zn96_ptr->LongInt = *Zones[95];
  1210.     number = *Zones[96];    
  1211.     sprintf(&str[0],"%d",number);
  1212.     strcpy(zn97_StringBuffer, str);
  1213.     zn97_ptr->LongInt = *Zones[96];
  1214.     number = *Zones[97];    
  1215.     sprintf(&str[0],"%d",number);
  1216.     strcpy(zn98_StringBuffer, str);
  1217.     zn98_ptr->LongInt = *Zones[97]; 
  1218.     number = *Zones[98];    
  1219.     sprintf(&str[0],"%d",number);
  1220.     strcpy(zn99_StringBuffer, str);
  1221.     zn99_ptr->LongInt = *Zones[98];
  1222.     number = *Zones[99];    
  1223.     sprintf(&str[0],"%d",number);
  1224.     strcpy(zn100_StringBuffer, str);
  1225.     zn100_ptr->LongInt = *Zones[99]; 
  1226.   }  
  1227.  
  1228. void doGroup7()
  1229.   {
  1230.     char str[4];
  1231.     int number;
  1232.     
  1233.     zn101_ptr = &zn101_StringInfo;
  1234.     zn102_ptr = &zn102_StringInfo;
  1235.     zn103_ptr = &zn103_StringInfo;
  1236.     zn104_ptr = &zn104_StringInfo;
  1237.     zn105_ptr = &zn105_StringInfo;
  1238.     zn106_ptr = &zn106_StringInfo;
  1239.     zn107_ptr = &zn107_StringInfo;
  1240.     zn108_ptr = &zn108_StringInfo;
  1241.     zn109_ptr = &zn109_StringInfo;
  1242.     zn110_ptr = &zn110_StringInfo;
  1243.     zn111_ptr = &zn111_StringInfo;
  1244.     zn112_ptr = &zn112_StringInfo;
  1245.     zn113_ptr = &zn113_StringInfo;
  1246.     zn114_ptr = &zn114_StringInfo;
  1247.     zn115_ptr = &zn115_StringInfo;
  1248.     zn116_ptr = &zn116_StringInfo;
  1249.     zn117_ptr = &zn117_StringInfo;
  1250.     zn118_ptr = &zn118_StringInfo;
  1251.     zn119_ptr = &zn119_StringInfo;
  1252.     zn120_ptr = &zn120_StringInfo;
  1253.     zn121_ptr = &zn121_StringInfo;
  1254.     zn122_ptr = &zn122_StringInfo;
  1255.     zn123_ptr = &zn123_StringInfo;
  1256.     zn124_ptr = &zn124_StringInfo;
  1257.     zn125_ptr = &zn125_StringInfo;
  1258.      
  1259.     number = *Zones[100];    
  1260.     sprintf(&str[0],"%d",number);
  1261.     strcpy(zn101_StringBuffer, str);
  1262.     zn101_ptr->LongInt = *Zones[100];
  1263.     number = *Zones[101];    
  1264.     sprintf(&str[0],"%d",number);
  1265.     strcpy(zn102_StringBuffer, str); 
  1266.     zn102_ptr->LongInt = *Zones[101];
  1267.     number = *Zones[102];    
  1268.     sprintf(&str[0],"%d",number);
  1269.     strcpy(zn103_StringBuffer, str);
  1270.     zn103_ptr->LongInt = *Zones[102];
  1271.     number = *Zones[103];    
  1272.     sprintf(&str[0],"%d",number);
  1273.     strcpy(zn104_StringBuffer, str);
  1274.     zn104_ptr->LongInt = *Zones[103];
  1275.     number = *Zones[104];    
  1276.     sprintf(&str[0],"%d",number);
  1277.     strcpy(zn105_StringBuffer, str);
  1278.     zn105_ptr->LongInt = *Zones[104];
  1279.     number = *Zones[105];    
  1280.     sprintf(&str[0],"%d",number);
  1281.     strcpy(zn106_StringBuffer, str); 
  1282.     zn106_ptr->LongInt = *Zones[105];
  1283.     number = *Zones[106];    
  1284.     sprintf(&str[0],"%d",number);
  1285.     strcpy(zn107_StringBuffer, str);
  1286.     zn107_ptr->LongInt = *Zones[106];
  1287.     number = *Zones[107];    
  1288.     sprintf(&str[0],"%d",number);
  1289.     strcpy(zn108_StringBuffer, str); 
  1290.     zn108_ptr->LongInt = *Zones[107]; 
  1291.     number = *Zones[108];    
  1292.     sprintf(&str[0],"%d",number);
  1293.     strcpy(zn109_StringBuffer, str);
  1294.     zn109_ptr->LongInt = *Zones[108];
  1295.     number = *Zones[109];    
  1296.     sprintf(&str[0],"%d",number);
  1297.     strcpy(zn110_StringBuffer, str); 
  1298.     zn110_ptr->LongInt = *Zones[109];
  1299.     number = *Zones[110];    
  1300.     sprintf(&str[0],"%d",number);
  1301.     strcpy(zn111_StringBuffer, str);
  1302.     zn111_ptr->LongInt = *Zones[110];
  1303.     number = *Zones[111];    
  1304.     sprintf(&str[0],"%d",number);
  1305.     strcpy(zn112_StringBuffer, str);
  1306.     zn112_ptr->LongInt = *Zones[111];
  1307.     number = *Zones[112];    
  1308.     sprintf(&str[0],"%d",number);
  1309.     strcpy(zn113_StringBuffer, str);
  1310.     zn113_ptr->LongInt = *Zones[112];
  1311.     number = *Zones[113];    
  1312.     sprintf(&str[0],"%d",number);
  1313.     strcpy(zn114_StringBuffer, str); 
  1314.     zn114_ptr->LongInt = *Zones[113];
  1315.     number = *Zones[114];    
  1316.     sprintf(&str[0],"%d",number);
  1317.     strcpy(zn115_StringBuffer, str);
  1318.     zn115_ptr->LongInt = *Zones[114];
  1319.     number = *Zones[115];    
  1320.     sprintf(&str[0],"%d",number);
  1321.     strcpy(zn116_StringBuffer, str); 
  1322.     zn116_ptr->LongInt = *Zones[115];
  1323.     number = *Zones[116];    
  1324.     sprintf(&str[0],"%d",number);
  1325.     strcpy(zn117_StringBuffer, str);
  1326.     zn117_ptr->LongInt = *Zones[116];
  1327.     number = *Zones[117];    
  1328.     sprintf(&str[0],"%d",number);
  1329.     strcpy(zn118_StringBuffer, str); 
  1330.     zn118_ptr->LongInt = *Zones[117];
  1331.     number = *Zones[118];    
  1332.     sprintf(&str[0],"%d",number);
  1333.     strcpy(zn119_StringBuffer, str);
  1334.     zn119_ptr->LongInt = *Zones[118];
  1335.     number = *Zones[119];    
  1336.     sprintf(&str[0],"%d",number);
  1337.     strcpy(zn120_StringBuffer, str);
  1338.     zn120_ptr->LongInt = *Zones[119];
  1339.     number = *Zones[120];    
  1340.     sprintf(&str[0],"%d",number);
  1341.     strcpy(zn121_StringBuffer, str);
  1342.     zn121_ptr->LongInt = *Zones[120];
  1343.     number = *Zones[121];    
  1344.     sprintf(&str[0],"%d",number);
  1345.     strcpy(zn122_StringBuffer, str); 
  1346.     zn122_ptr->LongInt = *Zones[121];
  1347.     number = *Zones[122];    
  1348.     sprintf(&str[0],"%d",number);
  1349.     strcpy(zn123_StringBuffer, str);
  1350.     zn123_ptr->LongInt = *Zones[122];
  1351.     number = *Zones[123];    
  1352.     sprintf(&str[0],"%d",number);
  1353.     strcpy(zn124_StringBuffer, str); 
  1354.     zn124_ptr->LongInt = *Zones[123];
  1355.     number = *Zones[124];
  1356.     strcpy(zn125_StringBuffer, str); 
  1357.     zn125_ptr->LongInt = *Zones[124];
  1358.   } 
  1359.   
  1360. void doGroup8()
  1361.   {
  1362.     char str[4];
  1363.     int number;
  1364.     
  1365.     zn126_ptr = &zn126_StringInfo;
  1366.     zn127_ptr = &zn127_StringInfo;
  1367.     zn128_ptr = &zn128_StringInfo;
  1368.     zn129_ptr = &zn129_StringInfo;
  1369.     zn130_ptr = &zn130_StringInfo;
  1370.     zn131_ptr = &zn131_StringInfo;
  1371.     zn132_ptr = &zn132_StringInfo;
  1372.     zn133_ptr = &zn133_StringInfo;
  1373.     zn134_ptr = &zn134_StringInfo;
  1374.     zn135_ptr = &zn135_StringInfo;
  1375.     zn136_ptr = &zn136_StringInfo;
  1376.     zn137_ptr = &zn137_StringInfo;
  1377.     zn138_ptr = &zn138_StringInfo;
  1378.     zn139_ptr = &zn139_StringInfo;
  1379.     zn140_ptr = &zn140_StringInfo;
  1380.     zn141_ptr = &zn141_StringInfo;
  1381.     zn142_ptr = &zn142_StringInfo;
  1382.     zn143_ptr = &zn143_StringInfo;
  1383.     zn144_ptr = &zn144_StringInfo;
  1384.     zn145_ptr = &zn145_StringInfo;
  1385.     zn146_ptr = &zn146_StringInfo;
  1386.     zn147_ptr = &zn147_StringInfo;
  1387.     zn148_ptr = &zn148_StringInfo;
  1388.     zn149_ptr = &zn149_StringInfo;
  1389.     zn150_ptr = &zn150_StringInfo;
  1390.     
  1391.     number = *Zones[125];    
  1392.     sprintf(&str[0],"%d",number);
  1393.     strcpy(zn126_StringBuffer, str);
  1394.     zn126_ptr->LongInt = *Zones[125];
  1395.     number = *Zones[126];    
  1396.     sprintf(&str[0],"%d",number);
  1397.     strcpy(zn127_StringBuffer, str); 
  1398.     zn127_ptr->LongInt = *Zones[126];
  1399.     number = *Zones[127];    
  1400.     sprintf(&str[0],"%d",number);
  1401.     strcpy(zn128_StringBuffer, str);
  1402.     zn128_ptr->LongInt = *Zones[127];
  1403.     number = *Zones[128];    
  1404.     sprintf(&str[0],"%d",number);
  1405.     strcpy(zn129_StringBuffer, str);
  1406.     zn129_ptr->LongInt = *Zones[128];
  1407.     number = *Zones[129];    
  1408.     sprintf(&str[0],"%d",number);
  1409.     strcpy(zn130_StringBuffer, str);
  1410.     zn130_ptr->LongInt = *Zones[129];
  1411.     number = *Zones[130];    
  1412.     sprintf(&str[0],"%d",number);
  1413.     strcpy(zn131_StringBuffer, str); 
  1414.     zn131_ptr->LongInt = *Zones[130];
  1415.     number = *Zones[131];    
  1416.     sprintf(&str[0],"%d",number);
  1417.     strcpy(zn132_StringBuffer, str);
  1418.     zn132_ptr->LongInt = *Zones[131];
  1419.     number = *Zones[132];    
  1420.     sprintf(&str[0],"%d",number);
  1421.     strcpy(zn133_StringBuffer, str); 
  1422.     zn133_ptr->LongInt = *Zones[132]; 
  1423.     number = *Zones[133];    
  1424.     sprintf(&str[0],"%d",number);
  1425.     strcpy(zn134_StringBuffer, str);
  1426.     zn134_ptr->LongInt = *Zones[133];
  1427.     number = *Zones[134];    
  1428.     sprintf(&str[0],"%d",number);
  1429.     strcpy(zn135_StringBuffer, str); 
  1430.     zn135_ptr->LongInt = *Zones[134];
  1431.     number = *Zones[135];    
  1432.     sprintf(&str[0],"%d",number);
  1433.     strcpy(zn136_StringBuffer, str);
  1434.     zn136_ptr->LongInt = *Zones[135];
  1435.     number = *Zones[136];    
  1436.     sprintf(&str[0],"%d",number);
  1437.     strcpy(zn137_StringBuffer, str);
  1438.     zn137_ptr->LongInt = *Zones[136];
  1439.     number = *Zones[137];    
  1440.     sprintf(&str[0],"%d",number);
  1441.     strcpy(zn138_StringBuffer, str); 
  1442.     zn138_ptr->LongInt = *Zones[137]; 
  1443.     number = *Zones[138];    
  1444.     sprintf(&str[0],"%d",number);
  1445.     strcpy(zn139_StringBuffer, str); 
  1446.     zn139_ptr->LongInt = *Zones[138];
  1447.     number = *Zones[139];    
  1448.     sprintf(&str[0],"%d",number);
  1449.     strcpy(zn140_StringBuffer, str);
  1450.     zn140_ptr->LongInt = *Zones[139];
  1451.     number = *Zones[140];    
  1452.     sprintf(&str[0],"%d",number);
  1453.     strcpy(zn141_StringBuffer, str); 
  1454.     zn141_ptr->LongInt = *Zones[140];
  1455.     number = *Zones[141];    
  1456.     sprintf(&str[0],"%d",number);
  1457.     strcpy(zn142_StringBuffer, str);
  1458.     zn142_ptr->LongInt = *Zones[141];
  1459.     number = *Zones[142];    
  1460.     sprintf(&str[0],"%d",number);
  1461.     strcpy(zn143_StringBuffer, str); 
  1462.     zn143_ptr->LongInt = *Zones[142];
  1463.     number = *Zones[143];    
  1464.     sprintf(&str[0],"%d",number);
  1465.     strcpy(zn144_StringBuffer, str);
  1466.     zn144_ptr->LongInt = *Zones[143];
  1467.     number = *Zones[144];    
  1468.     sprintf(&str[0],"%d",number);
  1469.     strcpy(zn145_StringBuffer, str);
  1470.     zn145_ptr->LongInt = *Zones[144];
  1471.     number = *Zones[145];    
  1472.     sprintf(&str[0],"%d",number);
  1473.     strcpy(zn146_StringBuffer, str);
  1474.     zn146_ptr->LongInt = *Zones[145];
  1475.     number = *Zones[146];    
  1476.     sprintf(&str[0],"%d",number);
  1477.     strcpy(zn147_StringBuffer, str); 
  1478.     zn147_ptr->LongInt = *Zones[146];
  1479.     number = *Zones[147];    
  1480.     sprintf(&str[0],"%d",number);
  1481.     strcpy(zn148_StringBuffer, str);
  1482.     zn148_ptr->LongInt = *Zones[147];
  1483.     number = *Zones[148];    
  1484.     sprintf(&str[0],"%d",number);
  1485.     strcpy(zn149_StringBuffer, str); 
  1486.     zn149_ptr->LongInt = *Zones[148];
  1487.     number = *Zones[149];
  1488.     sprintf(&str[0],"%d",number);
  1489.     strcpy(zn150_StringBuffer, str);
  1490.     zn150_ptr->LongInt = *Zones[149];
  1491.   }
  1492.   
  1493. void doGroup9()
  1494.   {
  1495.     char str[4];
  1496.     int number;
  1497.    
  1498.     zn151_ptr = &zn151_StringInfo;
  1499.     zn152_ptr = &zn152_StringInfo;
  1500.     zn153_ptr = &zn153_StringInfo;
  1501.     zn154_ptr = &zn154_StringInfo;
  1502.     zn155_ptr = &zn155_StringInfo;
  1503.     zn156_ptr = &zn156_StringInfo;
  1504.     zn157_ptr = &zn157_StringInfo;
  1505.     zn158_ptr = &zn158_StringInfo;
  1506.     zn159_ptr = &zn159_StringInfo;
  1507.     zn160_ptr = &zn160_StringInfo;
  1508.     zn161_ptr = &zn161_StringInfo;
  1509.     zn162_ptr = &zn162_StringInfo;
  1510.     zn163_ptr = &zn163_StringInfo;
  1511.     zn164_ptr = &zn164_StringInfo;
  1512.     zn165_ptr = &zn165_StringInfo;
  1513.     zn166_ptr = &zn166_StringInfo;
  1514.     zn167_ptr = &zn167_StringInfo;
  1515.     zn168_ptr = &zn168_StringInfo;
  1516.     zn169_ptr = &zn169_StringInfo;
  1517.     zn170_ptr = &zn170_StringInfo;
  1518.     zn171_ptr = &zn171_StringInfo;
  1519.     zn172_ptr = &zn172_StringInfo;
  1520.     zn173_ptr = &zn173_StringInfo;
  1521.     zn174_ptr = &zn174_StringInfo;
  1522.     zn175_ptr = &zn175_StringInfo;   
  1523.    
  1524.     number = *Zones[150];    
  1525.     sprintf(&str[0],"%d",number);
  1526.     strcpy(zn151_StringBuffer, str);
  1527.     zn151_ptr->LongInt = *Zones[150]; 
  1528.     number = *Zones[151];    
  1529.     sprintf(&str[0],"%d",number);
  1530.     strcpy(zn152_StringBuffer, str);
  1531.     zn152_ptr->LongInt = *Zones[151];
  1532.     number = *Zones[152];    
  1533.     sprintf(&str[0],"%d",number);
  1534.     strcpy(zn153_StringBuffer, str); 
  1535.     zn153_ptr->LongInt = *Zones[152];
  1536.     number = *Zones[153];    
  1537.     sprintf(&str[0],"%d",number);
  1538.     strcpy(zn154_StringBuffer, str);
  1539.     zn154_ptr->LongInt = *Zones[153];
  1540.     number = *Zones[154];    
  1541.     sprintf(&str[0],"%d",number);
  1542.     strcpy(zn155_StringBuffer, str); 
  1543.     zn155_ptr->LongInt = *Zones[154];
  1544.     number = *Zones[155];    
  1545.     sprintf(&str[0],"%d",number);
  1546.     strcpy(zn156_StringBuffer, str);
  1547.     zn156_ptr->LongInt = *Zones[155];
  1548.     number = *Zones[156];    
  1549.     sprintf(&str[0],"%d",number);
  1550.     strcpy(zn157_StringBuffer, str);
  1551.     zn157_ptr->LongInt = *Zones[156];
  1552.     number = *Zones[157];    
  1553.     sprintf(&str[0],"%d",number);
  1554.     strcpy(zn158_StringBuffer, str);
  1555.     zn158_ptr->LongInt = *Zones[157];
  1556.     number = *Zones[158];    
  1557.     sprintf(&str[0],"%d",number);
  1558.     strcpy(zn159_StringBuffer, str); 
  1559.     zn159_ptr->LongInt = *Zones[158];
  1560.     number = *Zones[159];    
  1561.     sprintf(&str[0],"%d",number);
  1562.     strcpy(zn160_StringBuffer, str);
  1563.     zn160_ptr->LongInt = *Zones[159];
  1564.     number = *Zones[160];    
  1565.     sprintf(&str[0],"%d",number);
  1566.     strcpy(zn161_StringBuffer, str); 
  1567.     zn161_ptr->LongInt = *Zones[160];
  1568.     number = *Zones[161];
  1569.     sprintf(&str[0],"%d",number);
  1570.     strcpy(zn162_StringBuffer, str);
  1571.     zn162_ptr->LongInt = *Zones[161];
  1572.     number = *Zones[162];
  1573.     sprintf(&str[0],"%d",number);
  1574.     strcpy(zn163_StringBuffer, str); 
  1575.     zn163_ptr->LongInt = *Zones[162]; 
  1576.     number = *Zones[163];    
  1577.     sprintf(&str[0],"%d",number);
  1578.     strcpy(zn164_StringBuffer, str); 
  1579.     zn164_ptr->LongInt = *Zones[163];
  1580.     number = *Zones[164];    
  1581.     sprintf(&str[0],"%d",number);
  1582.     strcpy(zn165_StringBuffer, str);
  1583.     zn165_ptr->LongInt = *Zones[164];
  1584.     number = *Zones[165];    
  1585.     sprintf(&str[0],"%d",number);
  1586.     strcpy(zn166_StringBuffer, str); 
  1587.     zn166_ptr->LongInt = *Zones[165];
  1588.     number = *Zones[166];    
  1589.     sprintf(&str[0],"%d",number);
  1590.     strcpy(zn167_StringBuffer, str);
  1591.     zn167_ptr->LongInt = *Zones[166];
  1592.     number = *Zones[167];    
  1593.     sprintf(&str[0],"%d",number);
  1594.     strcpy(zn168_StringBuffer, str); 
  1595.     zn168_ptr->LongInt = *Zones[167];
  1596.     number = *Zones[168];    
  1597.     sprintf(&str[0],"%d",number);
  1598.     strcpy(zn169_StringBuffer, str);
  1599.     zn169_ptr->LongInt = *Zones[168];
  1600.     number = *Zones[169];    
  1601.     sprintf(&str[0],"%d",number);
  1602.     strcpy(zn170_StringBuffer, str);
  1603.     zn170_ptr->LongInt = *Zones[169];
  1604.     number = *Zones[170];    
  1605.     sprintf(&str[0],"%d",number);
  1606.     strcpy(zn171_StringBuffer, str);
  1607.     zn171_ptr->LongInt = *Zones[170];
  1608.     number = *Zones[171];    
  1609.     sprintf(&str[0],"%d",number);
  1610.     strcpy(zn172_StringBuffer, str);
  1611.     zn172_ptr->LongInt = *Zones[171]; 
  1612.     number = *Zones[172];    
  1613.     sprintf(&str[0],"%d",number);
  1614.     strcpy(zn173_StringBuffer, str);
  1615.     zn173_ptr->LongInt = *Zones[172];
  1616.     number = *Zones[173];    
  1617.     sprintf(&str[0],"%d",number);
  1618.     strcpy(zn174_StringBuffer, str); 
  1619.     zn174_ptr->LongInt = *Zones[173];
  1620.     number = *Zones[174];
  1621.     sprintf(&str[0],"%d",number);
  1622.     strcpy(zn175_StringBuffer, str);
  1623.     zn175_ptr->LongInt = *Zones[174];
  1624.   }
  1625.  
  1626. void doGroup10()
  1627.   {
  1628.     char str[4];
  1629.     int number;
  1630.    
  1631.     zn176_ptr = &zn176_StringInfo;
  1632.     zn177_ptr = &zn177_StringInfo;
  1633.     zn178_ptr = &zn178_StringInfo;
  1634.     zn179_ptr = &zn179_StringInfo;
  1635.     zn180_ptr = &zn180_StringInfo;
  1636.     zn181_ptr = &zn181_StringInfo;
  1637.     zn182_ptr = &zn182_StringInfo;
  1638.     zn183_ptr = &zn183_StringInfo;
  1639.     zn184_ptr = &zn184_StringInfo;
  1640.     zn185_ptr = &zn185_StringInfo;
  1641.     zn186_ptr = &zn186_StringInfo;
  1642.     zn187_ptr = &zn187_StringInfo;
  1643.     zn188_ptr = &zn188_StringInfo;
  1644.     zn189_ptr = &zn189_StringInfo;
  1645.     zn190_ptr = &zn190_StringInfo;
  1646.     zn191_ptr = &zn191_StringInfo;
  1647.     zn192_ptr = &zn192_StringInfo;
  1648.     zn193_ptr = &zn193_StringInfo;
  1649.     zn194_ptr = &zn194_StringInfo;
  1650.     zn195_ptr = &zn195_StringInfo;
  1651.     zn196_ptr = &zn196_StringInfo;
  1652.     zn197_ptr = &zn197_StringInfo;
  1653.     zn198_ptr = &zn198_StringInfo;
  1654.     zn199_ptr = &zn199_StringInfo;
  1655.     zn200_ptr = &zn200_StringInfo;
  1656.    
  1657.     number = *Zones[175];
  1658.     sprintf(&str[0],"%d",number);
  1659.     strcpy(zn176_StringBuffer, str);
  1660.     zn176_ptr->LongInt = *Zones[175];
  1661.     number = *Zones[176];    
  1662.     sprintf(&str[0],"%d",number);
  1663.     strcpy(zn177_StringBuffer, str);
  1664.     zn177_ptr->LongInt = *Zones[176];
  1665.     number = *Zones[177];    
  1666.     sprintf(&str[0],"%d",number);
  1667.     strcpy(zn178_StringBuffer, str); 
  1668.     zn178_ptr->LongInt = *Zones[177];
  1669.     number = *Zones[178];    
  1670.     sprintf(&str[0],"%d",number);
  1671.     strcpy(zn179_StringBuffer, str);
  1672.     zn179_ptr->LongInt = *Zones[178];
  1673.     number = *Zones[179];    
  1674.     sprintf(&str[0],"%d",number);
  1675.     strcpy(zn180_StringBuffer, str);
  1676.     zn180_ptr->LongInt = *Zones[179];
  1677.     number = *Zones[180];    
  1678.     sprintf(&str[0],"%d",number);
  1679.     strcpy(zn181_StringBuffer, str);
  1680.     zn181_ptr->LongInt = *Zones[180];
  1681.     number = *Zones[181];    
  1682.     sprintf(&str[0],"%d",number);
  1683.     strcpy(zn182_StringBuffer, str); 
  1684.     zn182_ptr->LongInt = *Zones[181];
  1685.     number = *Zones[182];    
  1686.     sprintf(&str[0],"%d",number);
  1687.     strcpy(zn183_StringBuffer, str);
  1688.     zn183_ptr->LongInt = *Zones[182];
  1689.     number = *Zones[183];    
  1690.     sprintf(&str[0],"%d",number);
  1691.     strcpy(zn184_StringBuffer, str); 
  1692.     zn184_ptr->LongInt = *Zones[183];
  1693.     number = *Zones[184];
  1694.     sprintf(&str[0],"%d",number);
  1695.     strcpy(zn185_StringBuffer, str);
  1696.     zn185_ptr->LongInt = *Zones[184];
  1697.     number = *Zones[185];
  1698.     sprintf(&str[0],"%d",number);
  1699.     strcpy(zn186_StringBuffer, str);
  1700.     zn186_ptr->LongInt = *Zones[185];
  1701.     number = *Zones[186];    
  1702.     sprintf(&str[0],"%d",number);
  1703.     strcpy(zn187_StringBuffer, str); 
  1704.     zn187_ptr->LongInt = *Zones[186];
  1705.     number = *Zones[187];    
  1706.     sprintf(&str[0],"%d",number);
  1707.     strcpy(zn188_StringBuffer, str); 
  1708.     zn188_ptr->LongInt = *Zones[187];
  1709.     number = *Zones[188];    
  1710.     sprintf(&str[0],"%d",number);
  1711.     strcpy(zn189_StringBuffer, str);
  1712.     zn189_ptr->LongInt = *Zones[188];
  1713.     number = *Zones[189];    
  1714.     sprintf(&str[0],"%d",number);
  1715.     strcpy(zn190_StringBuffer, str);
  1716.     zn190_ptr->LongInt = *Zones[189];
  1717.     number = *Zones[190];    
  1718.     sprintf(&str[0],"%d",number);
  1719.     strcpy(zn191_StringBuffer, str);
  1720.     zn191_ptr->LongInt = *Zones[190];
  1721.     number = *Zones[191];    
  1722.     sprintf(&str[0],"%d",number);
  1723.     strcpy(zn192_StringBuffer, str); 
  1724.     zn192_ptr->LongInt = *Zones[191];
  1725.     number = *Zones[192];    
  1726.     sprintf(&str[0],"%d",number);
  1727.     strcpy(zn193_StringBuffer, str);
  1728.     zn193_ptr->LongInt = *Zones[192];
  1729.     number = *Zones[193];    
  1730.     sprintf(&str[0],"%d",number);
  1731.     strcpy(zn194_StringBuffer, str); 
  1732.     zn194_ptr->LongInt = *Zones[193];
  1733.     number = *Zones[194];
  1734.     sprintf(&str[0],"%d",number);
  1735.     strcpy(zn195_StringBuffer, str);
  1736.     zn195_ptr->LongInt = *Zones[194];
  1737.     number = *Zones[195];
  1738.     sprintf(&str[0],"%d",number);
  1739.     strcpy(zn196_StringBuffer, str); 
  1740.     zn196_ptr->LongInt = *Zones[195];
  1741.     number = *Zones[196];    
  1742.     sprintf(&str[0],"%d",number);
  1743.     strcpy(zn197_StringBuffer, str); 
  1744.     zn197_ptr->LongInt = *Zones[196];
  1745.     number = *Zones[197];    
  1746.     sprintf(&str[0],"%d",number);
  1747.     strcpy(zn198_StringBuffer, str); 
  1748.     zn198_ptr->LongInt = *Zones[197];
  1749.     number = *Zones[198];    
  1750.     sprintf(&str[0],"%d",number);
  1751.     strcpy(zn199_StringBuffer, str);
  1752.     zn199_ptr->LongInt = *Zones[198];
  1753.     number = *Zones[199];    
  1754.     sprintf(&str[0],"%d",number);
  1755.     strcpy(zn200_StringBuffer, str); 
  1756.     zn200_ptr->LongInt = *Zones[199];
  1757.   }
  1758.  
  1759. VOID resetIterations()
  1760.   {
  1761.     int i;
  1762.     
  1763.     for ( i = 0; i < 10; i++ )
  1764.       {
  1765.          Iterations[i].Flags = CHECKIT|ITEMTEXT|ITEMENABLED|HIGHCOMP;
  1766.          
  1767.       }
  1768.       
  1769.   }
  1770.