home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PROGRAMS / UTILS / MOUSE / MSMOUSE1.ZIP / C&QC.ZIP / PENCIL.C < prev   
Encoding:
C/C++ Source or Header  |  1989-02-10  |  21.1 KB  |  531 lines
  1. /*
  2.     PROGRAM: PENCIL
  3.      AUTHOR: MS PSS HW: Greg Lee
  4.        DATE: 11/16/88
  5. DESCRIPTION: Example of a simple drawing program using calls to the
  6.              mouse driver. This example demonstrates use of the
  7.              following mouse functions:
  8.                0  - Mouse Reset and Status
  9.                1  - Show Cursor
  10.                2  - Hide Cursor
  11.                7  - Set Minimum and Maximum Horizontal Cursor Position
  12.                8  - Set Minimum and Maximum Vertical Cursor Position
  13.                9  - Set Graphics Cursor Block
  14.                20 - Swap Interrupt Subroutines
  15. External Routines:   MASM routine to update mouse variables during a
  16.                      mouse interrupt specified by a condition mask.
  17.  
  18. Microsoft C 5.1:
  19.                masm /Ml m20sub;
  20.                cl /AM pencil.c m20sub.obj -link mouse
  21.  
  22. Microsoft QuickC:
  23.                masm /Ml m20sub;
  24.                Program List: pencil.c, m20sub.obj, mouse.lib
  25.  
  26. NOTE: Program assumes mouse driver is installed
  27. */
  28.  
  29. #include <stdio.h>
  30. #include <graph.h>
  31. #include <dos.h>
  32. #include <malloc.h>
  33.  
  34. #define MouseInterrupt  0x33            /* Mouse interrupt */
  35. #define LeftButton  1                   /* Left mouse button pressed */
  36. #define RightButton  2                  /* Right mouse button pressed */
  37. #define ButtonChangeMask 30             /* Button condition bits set */
  38. #define CursorChangeMask 1              /* Cursor condition bits set */
  39. #define RightButtonReleaseMask 16       /* Right button release bit set */
  40. #define LeftButtonReleaseMask 4         /* Left button release bit set */
  41. #define PencilMenu 0                    /* Pencil menu selected */
  42. #define EraserMenu 1                    /* Eraser menu selected */
  43. #define Quit 2                          /* Quit selected */
  44. #define InverseColor 0                  /* Inverse color of menu */
  45. #define NormalColor 1                   /* Normal color of menu */
  46. #define WHITE 7
  47. #define BLACK 0
  48. #define PencilCursor  0                 /* Use pencil cursor */
  49. #define EraserCursor  1                 /* Use eraser cursor */
  50. #define MouseCursor   2                 /* Use mouse cursor */
  51.  
  52. /* Mouse Function 20 Swap Interrupt Subroutine */
  53.  
  54. unsigned int ButtonState;               /* Mouse button state */
  55. unsigned int HorizCursCoord;            /* Horizontal cursor coordinates */
  56. unsigned int VertCursCoord;             /* Vertical cursor coordinates */
  57. unsigned int MouseConditionBits;        /* Mouse condition bits set   */
  58. extern void far NewMouseHardwareSub();  /* New mouse hardware routine */
  59. char far *graphicsbuffer;               /* Graphics buffer to restore screen */
  60. int MouseEvent;                         /* Mouse Event result */
  61. int videomode;                          /* Video mode */
  62.                                         /* Menu coordinates */
  63. int menuselector,xmax, ymax, pencilmenuborderxmin, pencilmenuborderxmax;
  64. int erasermenuborderxmin, erasermenuborderxmax, menuborderyaxis;
  65. int pencilmenuxmax, erasermenuxmin, erasermenuxmax, quitmenuxmin;
  66.  
  67. main(argc,argv)
  68. int *argv[];
  69. {
  70. int m1, m2, m3, m4, viderror;           /* Mouse parameters */
  71. struct videoconfig vioconfig;           /* Graphics environment structure */
  72.     if (argc == 2)
  73.         {
  74.         if ((char) * (argv[1]) == 'h')  /* Hercules selection */
  75.             {
  76.  
  77.             *((int far *)0x00400049L) = 6; /* Set Hercules page 0 */
  78.  
  79.             m1 = 0;                     /* Reset mouse */
  80.             cmousem(&m1, &m2, &m3, &m4);
  81.  
  82.             if (m1 == 0)                /* If mouse driver not installed */
  83.                 {
  84.                 printf("Microsoft Mouse not found");
  85.                 exit(-1);
  86.                 }
  87.  
  88.             viderror = _setvideomode(_HERCMONO); /* Set to Hercules mono */
  89.  
  90.             if (viderror == 0)          /* Couldn't set video */
  91.                 {
  92.                 printf("Couldn't set video mode \n");
  93.                 exit(-1);
  94.                 }
  95.             }
  96.  
  97.         else
  98.  
  99.             {                           /* Non-Hercules selection */
  100.             videomode = atoi(argv[1]);
  101.             viderror = _setvideomode(videomode); /* Set video mode */
  102.  
  103.             if (viderror == 0)          /* Couldn't set video */
  104.                 {
  105.                 printf("Couldn't set video mode \n");
  106.                 exit(-1);
  107.                 }
  108.  
  109.             m1 = 0;                     /* Reset mouse */
  110.             cmousem(&m1, &m2, &m3, &m4);
  111.  
  112.             if (m1 == 0)                /* If mouse driver not installed */
  113.                 {
  114.                 printf("Microsoft Mouse not found");
  115.                 exit(-1);
  116.                 }
  117.             }
  118.         }
  119.  
  120.     else
  121.         {
  122.         printf(" USAGE: pencil <video mode selection> \n\n");
  123.         printf("  Adapter        Video mode selection  \n" );
  124.         printf("  -----------    --------------------\n");
  125.         printf("  CGA 320x200             5\n" );
  126.         printf("  CGA 640x200             6\n" );
  127.         printf("  EGA 640x350             16\n");
  128.         printf("  VGA 640x480             18\n");
  129.         printf("  Herc 720x348            h (assuming MSHERC.COM loaded \n\n");
  130.         printf("  For example: pencil 6\n");
  131.         exit();
  132.         }
  133.  
  134.     _getvideoconfig(&vioconfig) ;       /* Get video environment variables */
  135.                                         /* Graphics buffer for menu */
  136.     xmax = vioconfig.numxpixels;
  137.     ymax = vioconfig.numypixels;
  138.                                         /* Menu  coordinates */
  139.     pencilmenuborderxmax = xmax / 3 ;
  140.     erasermenuborderxmin = (xmax / 3) + 1;
  141.     erasermenuborderxmax = (xmax / 3) * 2;
  142.     menuborderyaxis = ymax / 10;
  143.     pencilmenuxmax = (xmax / 3) - 1;
  144.     erasermenuxmin = (xmax / 3) + 1;
  145.     erasermenuxmax = ((xmax / 3) * 2) - 1;
  146.     quitmenuxmin = ((xmax / 3) * 2) + 1;
  147.  
  148.                                         /* Allocate memory for buffer */
  149.     graphicsbuffer = (char far *)malloc((unsigned int)_imagesize(1,1,xmax-1,menuborderyaxis));
  150.  
  151.     m1 = 7;                             /* Set horizontal limits */
  152.     m3 = 2;                             /* Minimum */
  153.     m4 = (xmax == 320) ? 635 : xmax - 5; /* Maximum */
  154.     cmousem(&m1, &m2, &m3, &m4);
  155.  
  156.     m1 = 8;                             /* Set vertical limits */
  157.     m3 = 2;                             /* Minimum */
  158.     m4 = ymax - 3;                      /* Maximum */
  159.     cmousem(&m1, &m2, &m3, &m4);
  160.  
  161.     DrawScreen();                       /* Draw first screen */
  162.     DrawCursor(MouseCursor);            /* Draw mouse cursor */
  163.  
  164.     m1 = 1;                             /* Show cursor */
  165.     cmousem(&m1, &m2, &m3, &m4);
  166.                                         /* Run hardware routine if right button
  167.                                             released */
  168.     SetMouseCallMask(RightButtonReleaseMask);
  169.     do
  170.         {                               /* Check if right button released */
  171.         if ((MouseEvent = (MouseConditionBits & RightButtonReleaseMask) )
  172.         == RightButtonReleaseMask)
  173.             {
  174.             CallMenu();                 /* Call menu routine */
  175.             }
  176.         } while(1);
  177. }                                       /* End of main */
  178.  
  179.  
  180. /*----------------------------------------------------------------------*/
  181. DrawScreen()                            /* Draw a double border */
  182. {
  183.     _setcolor(WHITE);
  184.     _rectangle(_GBORDER,0,0,xmax - 1,ymax - 1);
  185.     _rectangle(_GBORDER,2,2,xmax - 3,ymax - 3);
  186.     _setcolor(BLACK);
  187.                                         /* Clear drawing area */
  188.     _rectangle(_GFILLINTERIOR,3,3,xmax - 4,ymax - 4);
  189. }
  190.  
  191.  
  192. /*----------------------------------------------------------------------*/
  193. void PopUpMenu(menuselect,attribute)    /* Routine to pop up a menu */
  194. int menuselect,attribute;               /* Select a menu and display
  195.                                            with attribute */
  196. {
  197.     int textcolor,fillcolor,xtextpos;   /* Text color and fill color */
  198.                                         /* X coordinate text position */
  199.     fillcolor = (attribute == InverseColor) ? WHITE : BLACK  ;
  200.     textcolor = WHITE  ;
  201.     _setcolor(fillcolor);
  202.     _settextcolor(textcolor);
  203.                                         /* Select menu to display */
  204.     switch(menuselect)
  205.     {
  206.     case PencilMenu:                    /* Pencil menu displayed */
  207.     xtextpos = (xmax == 320) ? 5 : 11;  /* In 320 x 200 mode ? */
  208.     _rectangle(_GFILLINTERIOR, 1,1,pencilmenuxmax,(menuborderyaxis - 1));
  209.     _settextposition(2,xtextpos);
  210.     _outtext("Pencil");
  211.      break;
  212.  
  213.     case EraserMenu:                    /* Eraser menu displayed */
  214.     xtextpos = (xmax == 320) ? 18 : 37;
  215.     _rectangle(_GFILLINTERIOR,erasermenuxmin,1,erasermenuxmax,
  216.                (menuborderyaxis - 1));
  217.     _settextposition(2,xtextpos);
  218.     _outtext("Eraser");
  219.     break;
  220.  
  221.     case Quit:                          /* Quit menu displayed */
  222.     xtextpos = (xmax == 320) ? 32 : 65 ;
  223.     _rectangle(_GFILLINTERIOR, quitmenuxmin,1,xmax - 2,menuborderyaxis - 1);
  224.     _settextposition(2,xtextpos);
  225.     _outtext("QUIT");
  226.     break;
  227.  
  228.     default:
  229.     xtextpos = (xmax == 320) ? 32 : 65 ;
  230.     _rectangle(_GFILLINTERIOR, quitmenuxmin,1,xmax - 2,menuborderyaxis - 1);
  231.     _settextposition(2,xtextpos);
  232.     _outtext("QUIT");
  233.  
  234.     break;
  235.     }
  236. }                                       /* End of PopUpMenu */
  237.  
  238.  
  239. /*----------------------------------------------------------------------*/
  240. SetMouseCallMask(conditionmask)         /* Setup hardware routine */
  241. int conditionmask;                      /* When to call hardware MASM
  242.                                            routine NewMouseHardwareSub */
  243. {
  244. union REGS inregs, outregs;             /* Declare int86x variables */
  245. struct SREGS segregs;
  246. void (far *Func_Addr) ();               /* Far pointer to a function */
  247.  
  248.     Func_Addr = NewMouseHardwareSub;    /* Point to new mouse hardware
  249.                                            subroutine*/
  250.     inregs.x.ax = 20;                   /* Swap Interrupt Routine */
  251.     inregs.x.dx = FP_OFF(Func_Addr);    /* Get offset */
  252.     inregs.x.bx = FP_SEG(Func_Addr);    /* Get segment */
  253.     segregs.es = FP_SEG(Func_Addr);     /* Get segment */
  254.     inregs.x.cx = conditionmask;        /* Set condition when to run routine */
  255.     int86x(MouseInterrupt,&inregs,&outregs,&segregs);
  256. }                                       /* End of SetMouseCallMask */
  257.  
  258.  
  259. /*----------------------------------------------------------------------*/
  260. CallMenu()                              /* Menu routine */
  261. {                                       /* Mouse parameters, current menu
  262.                                            selection and previous selection */
  263. int m1, m2, m3, m4, xcoord, menuselector,lastmenuselector;
  264.     m1 = 2;                             /* Hide cursor */
  265.     cmousem(&m1,&m2,&m3,&m4);
  266.     SaveScreen();                       /* Save the area under menu */
  267.     lastmenuselector = -1;              /* Initialize last menu selection */
  268.     MouseConditionBits = 0;             /* Initialize condition bits */
  269.     DrawMenuBorders();                  /* Draw menu border */
  270.     PopUpMenu(PencilMenu,NormalColor);  /* Draw pencil menu */
  271.     PopUpMenu(EraserMenu,NormalColor);  /* Draw eraser menu */
  272.     PopUpMenu(Quit,NormalColor);        /* Draw quit menu */
  273.                                         /* Run hardware routine if a button
  274.                                            is pressed or cursor is moved */
  275.     SetMouseCallMask((ButtonChangeMask + CursorChangeMask));
  276.     do
  277.         {
  278.         xcoord = (xmax == 320) ? HorizCursCoord/2 : HorizCursCoord;
  279.         menuselector = ( xcoord / (xmax / 3)); /* Check horizontal position */
  280.                                         /* Check if left button released */
  281.         if ((MouseEvent = (MouseConditionBits &  LeftButtonReleaseMask))
  282.         == LeftButtonReleaseMask)
  283.             {
  284.             RestoreScreen();            /* Restore area under the menu */
  285.             switch(menuselector)        /* Run routine selected */
  286.                 {
  287.                 case PencilMenu:
  288.                 pencil();               /* Run pencil routine */
  289.                 return;
  290.                 break;
  291.  
  292.                 case EraserMenu:
  293.                 eraser();               /* Run eraser routine */
  294.                 return;
  295.                 break;
  296.  
  297.                 case Quit:              /* Quit program */
  298.                 _setvideomode(_DEFAULTMODE); /* Reset video mode */
  299.                 m1 = 0;                      /* Reset mouse */
  300.                 cmousem(&m1,&m2,&m3,&m4);
  301.                 exit();                      /* Quit */
  302.                 }
  303.             }
  304.  
  305.         /* Move menu selection if horizontal position moved to next */
  306.         if (menuselector != lastmenuselector)
  307.             {
  308.                                         /* Restore last selection */
  309.             PopUpMenu(lastmenuselector,NormalColor);
  310.                                         /* Draw new selection */
  311.             PopUpMenu(menuselector,InverseColor);
  312.                                         /* Reassign last selection */
  313.             lastmenuselector = menuselector;
  314.             }
  315.         }
  316.  
  317.         while((MouseEvent = (MouseConditionBits & RightButtonReleaseMask))
  318.            != RightButtonReleaseMask);  /* While right button not released */
  319.         MouseConditionBits = 0;         /* Reset condition bits */
  320.         RestoreScreen();                /* Restore area under menu */
  321.         DrawCursor(MouseCursor);        /* Draw mouse cursor */
  322. }                                       /* End of CallMenu */
  323.  
  324.  
  325. /*----------------------------------------------------------------------*/
  326. DrawMenuBorders()                       /* Draw menu borders */
  327. {
  328.     _setcolor(WHITE);
  329.     _rectangle(_GBORDER, 0,0,pencilmenuborderxmax,menuborderyaxis);
  330.     _rectangle(_GBORDER,erasermenuborderxmin,0,erasermenuborderxmax,
  331.                menuborderyaxis);
  332.     _rectangle(_GBORDER,quitmenuxmin,0,(xmax-1),menuborderyaxis);
  333. }                                       /* End of DrawMenuBorders */
  334.  
  335.  
  336. /*----------------------------------------------------------------------*/
  337. pencil()                                /* Pencil drawing routine */
  338. {
  339.     int m1,m2,m3,m4,xcoord;             /* Mouse parameters */
  340.  
  341.     _setcliprgn(3,3,xmax - 4,ymax - 4); /* Set drawing area limit */
  342.     _setcolor(WHITE);                   /* Set drawing color */
  343.     DrawCursor(PencilCursor);           /* Draw pencil cursor */
  344.     MouseConditionBits = 0;             /* Initialize mouse condition bits */
  345.     do
  346.         {
  347.         if (ButtonState == LeftButton)  /* If left button pressed start drawing */
  348.             {                           /* 320 x 200 ? */
  349.             xcoord = (xmax == 320) ? HorizCursCoord/2 : HorizCursCoord;
  350.             _moveto(xcoord,VertCursCoord);
  351.             m1 = 2;                     /* Hide cursor */
  352.             cmousem(&m1,&m2,&m3,&m4);
  353.  
  354.             do
  355.                 {                       /* 320 x 200 ? */
  356.                 xcoord = (xmax == 320) ? HorizCursCoord/2 : HorizCursCoord;
  357.                 _lineto(xcoord,VertCursCoord); /* Draw */
  358.                 } while(ButtonState == LeftButton); /* Draw until LB released */
  359.  
  360.             m1 = 1;                     /* Show cursor */
  361.             cmousem(&m1,&m2,&m3,&m4);
  362.             }
  363.         } while((MouseEvent = (MouseConditionBits & RightButtonReleaseMask))
  364.           != RightButtonReleaseMask);   /* Check if right button released */
  365.     _setcliprgn(0,0,xmax - 1,ymax - 1); /* Reset drawing area limits */
  366.     CallMenu();                         /* Call menu */
  367. }                                       /* End of PENCIL.C */
  368.  
  369.  
  370. /*----------------------------------------------------------------------*/
  371. DrawCursor(cursormask)
  372. int cursormask;
  373. {
  374.     int m1,m2,m3,m4;
  375.     unsigned short cursor[32];          /* Graphics cursor */
  376.     union REGS inregs,outregs;          /* int86x data registers */
  377.     struct SREGS segregs;               /* int86x segment registers */
  378.  
  379.     /* set screen mask */
  380.     cursor[0]=0xFFFF;
  381.     cursor[1]=0xFFFF;
  382.     cursor[2]=0xFFFF;
  383.     cursor[3]=0xFFFF;
  384.     cursor[4]=0xFFFF;
  385.     cursor[5]=0xFFFF;
  386.     cursor[6]=0xFFFF;
  387.     cursor[7]=0xFFFF;
  388.     cursor[8]=0xFFFF;
  389.     cursor[9]=0xFFFF;
  390.     cursor[10]=0xFFFF;
  391.     cursor[11]=0xFFFF;
  392.     cursor[12]=0xFFFF;
  393.     cursor[13]=0xFFFF;
  394.     cursor[14]=0xFFFF;
  395.     cursor[15]=0xFFFF;
  396.  
  397.     switch(cursormask)                  /* Select cursor mask */
  398.         {
  399.         case PencilCursor:
  400.                                         /* Pencil mask */
  401.         cursor[16]=0x0;
  402.         cursor[17]=0x0;
  403.         cursor[18]=0x0;
  404.         cursor[19]=0x0020;
  405.         cursor[20]=0x0050;
  406.         cursor[21]=0x0088;
  407.         cursor[22]=0x0150;
  408.         cursor[23]=0x0220;
  409.         cursor[24]=0x0440;
  410.         cursor[25]=0x0880;
  411.         cursor[26]=0x1100;
  412.         cursor[27]=0x2200;
  413.         cursor[28]=0x4400;
  414.         cursor[29]=0x8800;
  415.         cursor[30]=0xD000;
  416.         cursor[31]=0xE000;
  417.         break;
  418.  
  419.         case EraserCursor:
  420.                                         /* Draw eraser */
  421.         cursor[16]=0xFFC0;
  422.         cursor[17]=0x8040;
  423.         cursor[18]=0x8040;
  424.         cursor[19]=0x8040;
  425.         cursor[20]=0x8040;
  426.         cursor[21]=0x8040;
  427.         cursor[22]=0x8040;
  428.         cursor[23]=0x8040;
  429.         cursor[24]=0x8040;
  430.         cursor[25]=0x8040;
  431.         cursor[26]=0xFFC0;
  432.         cursor[27]=0x0;
  433.         cursor[28]=0x0;
  434.         cursor[29]=0x0;
  435.         cursor[30]=0x0;
  436.         cursor[31]=0x0;
  437.         break;
  438.  
  439.         case MouseCursor:
  440.                                         /* Draw mouse cursor */
  441.         cursor[16]=0x0660;
  442.         cursor[17]=0x0E70;
  443.         cursor[18]=0x0E70;
  444.         cursor[19]=0x0E70;
  445.         cursor[20]=0x0E70;
  446.         cursor[21]=0x0;
  447.         cursor[22]=0x0FF0;
  448.         cursor[23]=0x0FF0;
  449.         cursor[24]=0x0FF0;
  450.         cursor[25]=0x0FF0;
  451.         cursor[26]=0x0FF0;
  452.         cursor[27]=0x07E0;
  453.         cursor[28]=0x0;
  454.         cursor[29]=0x0;
  455.         cursor[30]=0x0;
  456.         cursor[31]=0x0;
  457.         break;
  458.  
  459.         default:
  460.         break;
  461.         }                               /*End switch */
  462.  
  463.     /* Use int86x instead of cmouse (to pass segment register) */
  464.     inregs.x.ax = 9;                    /* Set graphics cursor */
  465.     inregs.x.bx = 0;
  466.                                         /* Change hot spot */
  467.     inregs.x.cx = (cursormask == PencilCursor) ? 16 : 0;
  468.                                         /* Offset of array */
  469.     inregs.x.dx = (unsigned int)&cursor[0];
  470.     segread(&segregs);
  471.     segregs.es = segregs.ds;            /* Set ES = DS */
  472.     int86x(MouseInterrupt,&inregs,&outregs,&segregs);
  473.     segread(&segregs);
  474.  
  475.     m1 = 1;                             /* Show cursor */
  476.     cmousem(&m1,&m2,&m3,&m4);
  477. }                                       /* End of DrawCursor */
  478.  
  479.  
  480. /*----------------------------------------------------------------------*/
  481. SaveScreen()                            /* Save area under menu */
  482. {
  483.     _getimage(1,1,(xmax - 1),menuborderyaxis,graphicsbuffer);
  484. }                                       /* End of SaveScreen */
  485.  
  486.  
  487. /*----------------------------------------------------------------------*/
  488. RestoreScreen()                         /* Restore area under menu */
  489. {
  490.     _putimage(1,1,graphicsbuffer,_GPSET);
  491. }                                       /* End of RestoreScreen */
  492.  
  493.  
  494. /*----------------------------------------------------------------------*/
  495. eraser()                                /* Eraser routine */
  496. {
  497.     int flag,m1,m2,m3,m4,xcoord,ycoord; /* Mouse parameters and
  498.                                            x/y coordinates);
  499.  
  500.     MouseConditionBits = 0;             /* Initialize condition bits */
  501.     _setcliprgn(3,3,xmax - 4,ymax - 4); /* Set drawing area */
  502.     DrawCursor(EraserCursor);           /* Draw eraser cursor */
  503.     do
  504.         {
  505.         if (ButtonState == LeftButton)  /* Check if left button pressed */
  506.             {
  507.             m1 = 2;                     /* Hide cursor */
  508.             cmousem(&m1,&m2,&m3,&m4);
  509.             do
  510.                 {           /* Check if CGA 320 x 200 and get horizontal coord */
  511.  
  512.                 xcoord = (xmax == 320) ? HorizCursCoord / 2 : HorizCursCoord;
  513.                 ycoord = VertCursCoord; /* Get vertical coordinate */
  514.                 _setcolor(WHITE);       /* Set color to white */
  515.                 _rectangle(_GBORDER,xcoord,ycoord,xcoord + 9,
  516.                         ycoord + 10);   /* Draw eraser */
  517.                 _setcolor(BLACK);       /* Set color to black */
  518.                 _rectangle(_GFILLINTERIOR,xcoord,ycoord,xcoord + 9,
  519.                         ycoord + 10);   /* Erase */
  520.                 } while(ButtonState == LeftButton); /* While left button pressed */
  521.             m1 = 1;                     /* Show cursor */
  522.             cmousem(&m1,&m2,&m3,&m4);
  523.             }
  524.         }
  525.     while((MouseEvent = (MouseConditionBits & RightButtonReleaseMask))
  526.     != RightButtonReleaseMask);         /* While right button not released */
  527.  
  528.     _setcliprgn(0,0,xmax - 1,ymax - 1); /* Restore drawing region */
  529.     CallMenu();                         /* Call menu */
  530. }                                       /* End of eraser */
  531.