/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   F O N C T I O N S   E T   D E   L E U R S   A R G U M E N T S  :                             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                    Dans ce fichier, se trouvent toutes                                                                            */
/*                  les donnees necessaires a la validation                                                                          */
/*                  du nombre des arguments lors de l'appel                                                                          */
/*                  d'une fonction.                                                                                                  */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Contenu :                                                                                                                  */
/*                                                                                                                                   */
/*                    On trouvera donc ici deux types de                                                                             */
/*                  definitions :                                                                                                    */
/*                                                                                                                                   */
/*                  1 - permettant d'atteindre une fonction                                                                          */
/*                  'f' sans valider le nombre d'arguments,                                                                          */
/*                  et ce en utilisant le nom '__f' :                                                                                */
/*                                                                                                                                   */
/*                                      =define   __f       f                                                                        */
/*                                                                                                                                   */
/*                  2 - permettant de valider le nombre                                                                              */
/*                  d'arguments lors d'une utilisation                                                                               */
/*                  quelconque d'une fonction 'f' :                                                                                  */
/*                                                                                                                                   */
/*                                      =define   _f(args)  f(args)                                                                  */
/*                                      #define   f(args)   _f(args)                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xiii/alphabets$ARG' sur 'LACT19' :                                                                             */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20240626121838).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   F O N C T I O N S   E T   D E   L E U R S   A R G U M E N T S  :                             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

=define   __FgLspace                                                                                                                    \
                    FgLspace
=define   _FgLspace(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLspace(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLspace(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLspace(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgLexclamation                                                                                                              \
                    FgLexclamation
=define   _FgLexclamation(                                                                                                              \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLexclamation(                                                                                                     \
                                                                                                                                        \
                                        )
#define   FgLexclamation(                                                                                                               \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLexclamation(                                                                                                    \
                                                                                                                                        \
                                        )

=define   __FgLquote                                                                                                                    \
                    FgLquote
=define   _FgLquote(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLquote(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLquote(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLquote(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgLdiese                                                                                                                    \
                    FgLdiese
=define   _FgLdiese(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLdiese(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLdiese(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLdiese(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgLdollar                                                                                                                   \
                    FgLdollar
=define   _FgLdollar(                                                                                                                   \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLdollar(                                                                                                          \
                                                                                                                                        \
                                        )
#define   FgLdollar(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLdollar(                                                                                                         \
                                                                                                                                        \
                                        )

=define   __FgLpour_cent                                                                                                                \
                    FgLpour_cent
=define   _FgLpour_cent(                                                                                                                \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLpour_cent(                                                                                                       \
                                                                                                                                        \
                                        )
#define   FgLpour_cent(                                                                                                                 \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLpour_cent(                                                                                                      \
                                                                                                                                        \
                                        )

=define   __FgLet                                                                                                                       \
                    FgLet
=define   _FgLet(                                                                                                                       \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLet(                                                                                                              \
                                                                                                                                        \
                                        )
#define   FgLet(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLet(                                                                                                             \
                                                                                                                                        \
                                        )

=define   __FgLapostrophe                                                                                                               \
                    FgLapostrophe
=define   _FgLapostrophe(                                                                                                               \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLapostrophe(                                                                                                      \
                                                                                                                                        \
                                        )
#define   FgLapostrophe(                                                                                                                \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLapostrophe(                                                                                                     \
                                                                                                                                        \
                                        )

=define   __FgLpg                                                                                                                       \
                    FgLpg
=define   _FgLpg(                                                                                                                       \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLpg(                                                                                                              \
                                                                                                                                        \
                                        )
#define   FgLpg(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLpg(                                                                                                             \
                                                                                                                                        \
                                        )

=define   __FgLpd                                                                                                                       \
                    FgLpd
=define   _FgLpd(                                                                                                                       \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLpd(                                                                                                              \
                                                                                                                                        \
                                        )
#define   FgLpd(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLpd(                                                                                                             \
                                                                                                                                        \
                                        )

=define   __FgLetoile                                                                                                                   \
                    FgLetoile
=define   _FgLetoile(                                                                                                                   \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLetoile(                                                                                                          \
                                                                                                                                        \
                                        )
#define   FgLetoile(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLetoile(                                                                                                         \
                                                                                                                                        \
                                        )

=define   __FgLplus                                                                                                                     \
                    FgLplus
=define   _FgLplus(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLplus(                                                                                                            \
                                                                                                                                        \
                                        )
#define   FgLplus(                                                                                                                      \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLplus(                                                                                                           \
                                                                                                                                        \
                                        )

=define   __FgLvirgule                                                                                                                  \
                    FgLvirgule
=define   _FgLvirgule(                                                                                                                  \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLvirgule(                                                                                                         \
                                                                                                                                        \
                                        )
#define   FgLvirgule(                                                                                                                   \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLvirgule(                                                                                                        \
                                                                                                                                        \
                                        )

=define   __FgLmoins                                                                                                                    \
                    FgLmoins
=define   _FgLmoins(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLmoins(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLmoins(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLmoins(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgLpoint                                                                                                                    \
                    FgLpoint
=define   _FgLpoint(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLpoint(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLpoint(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLpoint(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgLslash                                                                                                                    \
                    FgLslash
=define   _FgLslash(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLslash(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLslash(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLslash(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgL0                                                                                                                        \
                    FgL0
=define   _FgL0(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL0(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL0(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL0(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL1                                                                                                                        \
                    FgL1
=define   _FgL1(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL1(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL1(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL1(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL2                                                                                                                        \
                    FgL2
=define   _FgL2(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL2(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL2(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL2(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL3                                                                                                                        \
                    FgL3
=define   _FgL3(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL3(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL3(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL3(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL4                                                                                                                        \
                    FgL4
=define   _FgL4(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL4(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL4(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL4(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL5                                                                                                                        \
                    FgL5
=define   _FgL5(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL5(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL5(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL5(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL6                                                                                                                        \
                    FgL6
=define   _FgL6(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL6(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL6(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL6(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL7                                                                                                                        \
                    FgL7
=define   _FgL7(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL7(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL7(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL7(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL8                                                                                                                        \
                    FgL8
=define   _FgL8(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL8(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL8(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL8(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgL9                                                                                                                        \
                    FgL9
=define   _FgL9(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgL9(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgL9(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgL9(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLdeux_points                                                                                                              \
                    FgLdeux_points
=define   _FgLdeux_points(                                                                                                              \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLdeux_points(                                                                                                     \
                                                                                                                                        \
                                        )
#define   FgLdeux_points(                                                                                                               \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLdeux_points(                                                                                                    \
                                                                                                                                        \
                                        )

=define   __FgLpoint_virgule                                                                                                            \
                    FgLpoint_virgule
=define   _FgLpoint_virgule(                                                                                                            \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLpoint_virgule(                                                                                                   \
                                                                                                                                        \
                                        )
#define   FgLpoint_virgule(                                                                                                             \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLpoint_virgule(                                                                                                  \
                                                                                                                                        \
                                        )

=define   __FgLinferieur                                                                                                                \
                    FgLinferieur
=define   _FgLinferieur(                                                                                                                \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLinferieur(                                                                                                       \
                                                                                                                                        \
                                        )
#define   FgLinferieur(                                                                                                                 \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLinferieur(                                                                                                      \
                                                                                                                                        \
                                        )

=define   __FgLegal                                                                                                                     \
                    FgLegal
=define   _FgLegal(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLegal(                                                                                                            \
                                                                                                                                        \
                                        )
#define   FgLegal(                                                                                                                      \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLegal(                                                                                                           \
                                                                                                                                        \
                                        )

=define   __FgLsuperieur                                                                                                                \
                    FgLsuperieur
=define   _FgLsuperieur(                                                                                                                \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLsuperieur(                                                                                                       \
                                                                                                                                        \
                                        )
#define   FgLsuperieur(                                                                                                                 \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLsuperieur(                                                                                                      \
                                                                                                                                        \
                                        )

=define   __FgLinterrogation                                                                                                            \
                    FgLinterrogation
=define   _FgLinterrogation(                                                                                                            \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLinterrogation(                                                                                                   \
                                                                                                                                        \
                                        )
#define   FgLinterrogation(                                                                                                             \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLinterrogation(                                                                                                  \
                                                                                                                                        \
                                        )

=define   __FgLa_rond                                                                                                                   \
                    FgLa_rond
=define   _FgLa_rond(                                                                                                                   \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLa_rond(                                                                                                          \
                                                                                                                                        \
                                        )
#define   FgLa_rond(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLa_rond(                                                                                                         \
                                                                                                                                        \
                                        )

=define   __FgLA                                                                                                                        \
                    FgLA
=define   _FgLA(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLA(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLA(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLA(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLB                                                                                                                        \
                    FgLB
=define   _FgLB(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLB(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLB(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLB(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLC                                                                                                                        \
                    FgLC
=define   _FgLC(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLC(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLC(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLC(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLD                                                                                                                        \
                    FgLD
=define   _FgLD(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLD(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLD(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLD(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLE                                                                                                                        \
                    FgLE
=define   _FgLE(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLE(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLE(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLE(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLF                                                                                                                        \
                    FgLF
=define   _FgLF(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLF(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLF(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLF(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLG                                                                                                                        \
                    FgLG
=define   _FgLG(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLG(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLG(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLG(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLH                                                                                                                        \
                    FgLH
=define   _FgLH(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLH(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLH(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLH(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLI                                                                                                                        \
                    FgLI
=define   _FgLI(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLI(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLI(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLI(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLJ                                                                                                                        \
                    FgLJ
=define   _FgLJ(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLJ(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLJ(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLJ(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLK                                                                                                                        \
                    FgLK
=define   _FgLK(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLK(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLK(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLK(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLL                                                                                                                        \
                    FgLL
=define   _FgLL(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLL(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLL(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLL(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLM                                                                                                                        \
                    FgLM
=define   _FgLM(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLM(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLM(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLM(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLN                                                                                                                        \
                    FgLN
=define   _FgLN(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLN(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLN(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLN(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLO                                                                                                                        \
                    FgLO
=define   _FgLO(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLO(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLO(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLO(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLP                                                                                                                        \
                    FgLP
=define   _FgLP(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLP(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLP(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLP(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLQ                                                                                                                        \
                    FgLQ
=define   _FgLQ(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLQ(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLQ(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLQ(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLR                                                                                                                        \
                    FgLR
=define   _FgLR(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLR(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLR(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLR(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLS                                                                                                                        \
                    FgLS
=define   _FgLS(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLS(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLS(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLS(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLT                                                                                                                        \
                    FgLT
=define   _FgLT(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLT(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLT(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLT(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLU                                                                                                                        \
                    FgLU
=define   _FgLU(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLU(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLU(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLU(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLV                                                                                                                        \
                    FgLV
=define   _FgLV(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLV(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLV(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLV(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLW                                                                                                                        \
                    FgLW
=define   _FgLW(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLW(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLW(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLW(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLX                                                                                                                        \
                    FgLX
=define   _FgLX(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLX(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLX(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLX(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLY                                                                                                                        \
                    FgLY
=define   _FgLY(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLY(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLY(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLY(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLZ                                                                                                                        \
                    FgLZ
=define   _FgLZ(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLZ(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLZ(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLZ(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLcrochet_gauche                                                                                                           \
                    FgLcrochet_gauche
=define   _FgLcrochet_gauche(                                                                                                           \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLcrochet_gauche(                                                                                                  \
                                                                                                                                        \
                                        )
#define   FgLcrochet_gauche(                                                                                                            \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLcrochet_gauche(                                                                                                 \
                                                                                                                                        \
                                        )

=define   __FgLanti_slash                                                                                                               \
                    FgLanti_slash
=define   _FgLanti_slash(                                                                                                               \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLanti_slash(                                                                                                      \
                                                                                                                                        \
                                        )
#define   FgLanti_slash(                                                                                                                \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLanti_slash(                                                                                                     \
                                                                                                                                        \
                                        )

=define   __FgLcrochet_droit                                                                                                            \
                    FgLcrochet_droit
=define   _FgLcrochet_droit(                                                                                                            \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLcrochet_droit(                                                                                                   \
                                                                                                                                        \
                                        )
#define   FgLcrochet_droit(                                                                                                             \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLcrochet_droit(                                                                                                  \
                                                                                                                                        \
                                        )

=define   __FgLcirconflexe                                                                                                              \
                    FgLcirconflexe
=define   _FgLcirconflexe(                                                                                                              \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLcirconflexe(                                                                                                     \
                                                                                                                                        \
                                        )
#define   FgLcirconflexe(                                                                                                               \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLcirconflexe(                                                                                                    \
                                                                                                                                        \
                                        )

=define   __FgLunder_score                                                                                                              \
                    FgLunder_score
=define   _FgLunder_score(                                                                                                              \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLunder_score(                                                                                                     \
                                                                                                                                        \
                                        )
#define   FgLunder_score(                                                                                                               \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLunder_score(                                                                                                    \
                                                                                                                                        \
                                        )

=define   __FgLanti_quote                                                                                                               \
                    FgLanti_quote
=define   _FgLanti_quote(                                                                                                               \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLanti_quote(                                                                                                      \
                                                                                                                                        \
                                        )
#define   FgLanti_quote(                                                                                                                \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLanti_quote(                                                                                                     \
                                                                                                                                        \
                                        )

=define   __FgLa                                                                                                                        \
                    FgLa
=define   _FgLa(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLa(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLa(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLa(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLb                                                                                                                        \
                    FgLb
=define   _FgLb(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLb(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLb(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLb(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLc                                                                                                                        \
                    FgLc
=define   _FgLc(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLc(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLc(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLc(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLd                                                                                                                        \
                    FgLd
=define   _FgLd(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLd(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLd(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLd(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLe                                                                                                                        \
                    FgLe
=define   _FgLe(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLe(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLe(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLe(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLaigu                                                                                                                     \
                    FgLaigu
=define   _FgLaigu(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLaigu(                                                                                                            \
                                                                                                                                        \
                                        )
#define   FgLaigu(                                                                                                                      \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLaigu(                                                                                                           \
                                                                                                                                        \
                                        )

=define   __FgLgrave                                                                                                                    \
                    FgLgrave
=define   _FgLgrave(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLgrave(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLgrave(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLgrave(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgLf                                                                                                                        \
                    FgLf
=define   _FgLf(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLf(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLf(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLf(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLg                                                                                                                        \
                    FgLg
=define   _FgLg(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLg(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLg(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLg(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLh                                                                                                                        \
                    FgLh
=define   _FgLh(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLh(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLh(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLh(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLi                                                                                                                        \
                    FgLi
=define   _FgLi(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLi(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLi(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLi(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLi_trema                                                                                                                  \
                    FgLi_trema
=define   _FgLi_trema(                                                                                                                  \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLi_trema(                                                                                                         \
                                                                                                                                        \
                                        )
#define   FgLi_trema(                                                                                                                   \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLi_trema(                                                                                                        \
                                                                                                                                        \
                                        )

=define   __FgLj                                                                                                                        \
                    FgLj
=define   _FgLj(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLj(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLj(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLj(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLk                                                                                                                        \
                    FgLk
=define   _FgLk(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLk(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLk(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLk(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLl                                                                                                                        \
                    FgLl
=define   _FgLl(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLl(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLl(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLl(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLm                                                                                                                        \
                    FgLm
=define   _FgLm(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLm(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLm(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLm(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLn                                                                                                                        \
                    FgLn
=define   _FgLn(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLn(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLn(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLn(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLo                                                                                                                        \
                    FgLo
=define   _FgLo(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLo(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLo(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLo(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLp                                                                                                                        \
                    FgLp
=define   _FgLp(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLp(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLp(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLp(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLq                                                                                                                        \
                    FgLq
=define   _FgLq(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLq(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLq(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLq(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLr                                                                                                                        \
                    FgLr
=define   _FgLr(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLr(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLr(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLr(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLs                                                                                                                        \
                    FgLs
=define   _FgLs(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLs(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLs(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLs(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLt                                                                                                                        \
                    FgLt
=define   _FgLt(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLt(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLt(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLt(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLu                                                                                                                        \
                    FgLu
=define   _FgLu(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLu(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLu(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLu(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLv                                                                                                                        \
                    FgLv
=define   _FgLv(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLv(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLv(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLv(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLw                                                                                                                        \
                    FgLw
=define   _FgLw(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLw(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLw(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLw(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLx                                                                                                                        \
                    FgLx
=define   _FgLx(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLx(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLx(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLx(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLy                                                                                                                        \
                    FgLy
=define   _FgLy(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLy(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLy(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLy(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLz                                                                                                                        \
                    FgLz
=define   _FgLz(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLz(                                                                                                               \
                                                                                                                                        \
                                        )
#define   FgLz(                                                                                                                         \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLz(                                                                                                              \
                                                                                                                                        \
                                        )

=define   __FgLag                                                                                                                       \
                    FgLag
=define   _FgLag(                                                                                                                       \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLag(                                                                                                              \
                                                                                                                                        \
                                        )
#define   FgLag(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLag(                                                                                                             \
                                                                                                                                        \
                                        )

=define   __FgLpipe                                                                                                                     \
                    FgLpipe
=define   _FgLpipe(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLpipe(                                                                                                            \
                                                                                                                                        \
                                        )
#define   FgLpipe(                                                                                                                      \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLpipe(                                                                                                           \
                                                                                                                                        \
                                        )

=define   __FgLad                                                                                                                       \
                    FgLad
=define   _FgLad(                                                                                                                       \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLad(                                                                                                              \
                                                                                                                                        \
                                        )
#define   FgLad(                                                                                                                        \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLad(                                                                                                             \
                                                                                                                                        \
                                        )

=define   __FgLtilda                                                                                                                    \
                    FgLtilda
=define   _FgLtilda(                                                                                                                    \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLtilda(                                                                                                           \
                                                                                                                                        \
                                        )
#define   FgLtilda(                                                                                                                     \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLtilda(                                                                                                          \
                                                                                                                                        \
                                        )

=define   __FgLline_feed                                                                                                                \
                    FgLline_feed
=define   _FgLline_feed(                                                                                                                \
                                                                                                                                        \
                              )                                                                                                         \
                    FgLline_feed(                                                                                                       \
                                                                                                                                        \
                                        )
#define   FgLline_feed(                                                                                                                 \
                                                                                                                                        \
                              )                                                                                                         \
                    _FgLline_feed(                                                                                                      \
                                                                                                                                        \
                                        )

=define   __Itexte                                                                                                                      \
                    Itexte
=define   _Itexte(                                                                                                                      \
                              Argument_____chaineA                                                                                      \
                              )                                                                                                         \
                    Itexte(                                                                                                             \
                                        Argument_____chaineA                                                                            \
                                        )
#define   Itexte(                                                                                                                       \
                              Argument_____chaineA                                                                                      \
                              )                                                                                                         \
                    _Itexte(                                                                                                            \
                                        Argument_____chaineA                                                                            \
                                        )

=define   __Imessage                                                                                                                    \
                    Imessage
=define   _Imessage(                                                                                                                    \
                              Argument_____chaineA                                                                                      \
                             ,Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                             ,Argument_____centrer_le_message                                                                           \
                              )                                                                                                         \
                    Imessage(                                                                                                           \
                                        Argument_____chaineA                                                                            \
                                       ,Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                       ,Argument_____centrer_le_message                                                                 \
                                        )
#define   Imessage(                                                                                                                     \
                              Argument_____chaineA                                                                                      \
                             ,Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                             ,Argument_____centrer_le_message                                                                           \
                              )                                                                                                         \
                    _Imessage(                                                                                                          \
                                        Argument_____chaineA                                                                            \
                                       ,Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                       ,Argument_____centrer_le_message                                                                 \
                                        )

=define   __f___                                                                                                                        \
                    f___
=define   _f___(                                                                                                                        \
                              Argument_____imageR                                                                                       \
                             ,Argument_____imageA                                                                                       \
                             ,Argument_____X                                                                                            \
                             ,Argument_____Y                                                                                            \
                              )                                                                                                         \
                    f___(                                                                                                               \
                                        Argument_____imageR                                                                             \
                                       ,Argument_____imageA                                                                             \
                                       ,Argument_____X                                                                                  \
                                       ,Argument_____Y                                                                                  \
                                        )
#define   f___(                                                                                                                         \
                              Argument_____imageR                                                                                       \
                             ,Argument_____imageA                                                                                       \
                             ,Argument_____X                                                                                            \
                             ,Argument_____Y                                                                                            \
                              )                                                                                                         \
                    _f___(                                                                                                              \
                                        Argument_____imageR                                                                             \
                                       ,Argument_____imageA                                                                             \
                                       ,Argument_____X                                                                                  \
                                       ,Argument_____Y                                                                                  \
                                        )

=define   __f_X_                                                                                                                        \
                    f_X_
=define   _f_X_(                                                                                                                        \
                              Argument_____imageR                                                                                       \
                             ,Argument_____imageA                                                                                       \
                             ,Argument_____X                                                                                            \
                             ,Argument_____Y                                                                                            \
                              )                                                                                                         \
                    f_X_(                                                                                                               \
                                        Argument_____imageR                                                                             \
                                       ,Argument_____imageA                                                                             \
                                       ,Argument_____X                                                                                  \
                                       ,Argument_____Y                                                                                  \
                                        )
#define   f_X_(                                                                                                                         \
                              Argument_____imageR                                                                                       \
                             ,Argument_____imageA                                                                                       \
                             ,Argument_____X                                                                                            \
                             ,Argument_____Y                                                                                            \
                              )                                                                                                         \
                    _f_X_(                                                                                                              \
                                        Argument_____imageR                                                                             \
                                       ,Argument_____imageA                                                                             \
                                       ,Argument_____X                                                                                  \
                                       ,Argument_____Y                                                                                  \
                                        )

=define   __Isignature_invisible                                                                                                        \
                    Isignature_invisible
=define   _Isignature_invisible(                                                                                                        \
                              Argument_____imageR                                                                                       \
                             ,Argument_____imageA                                                                                       \
                             ,Argument_____emplacement_de_la_signature_invisible                                                        \
                             ,Argument_____lisible                                                                                      \
                              )                                                                                                         \
                    Isignature_invisible(                                                                                               \
                                        Argument_____imageR                                                                             \
                                       ,Argument_____imageA                                                                             \
                                       ,Argument_____emplacement_de_la_signature_invisible                                              \
                                       ,Argument_____lisible                                                                            \
                                        )
#define   Isignature_invisible(                                                                                                         \
                              Argument_____imageR                                                                                       \
                             ,Argument_____imageA                                                                                       \
                             ,Argument_____emplacement_de_la_signature_invisible                                                        \
                             ,Argument_____lisible                                                                                      \
                              )                                                                                                         \
                    _Isignature_invisible(                                                                                              \
                                        Argument_____imageR                                                                             \
                                       ,Argument_____imageA                                                                             \
                                       ,Argument_____emplacement_de_la_signature_invisible                                              \
                                       ,Argument_____lisible                                                                            \
                                        )

=define   __Isignature                                                                                                                  \
                    Isignature
=define   _Isignature(                                                                                                                  \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    Isignature(                                                                                                         \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )
#define   Isignature(                                                                                                                   \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    _Isignature(                                                                                                        \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )

=define   __Ilactamme                                                                                                                   \
                    Ilactamme
=define   _Ilactamme(                                                                                                                   \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    Ilactamme(                                                                                                          \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )
#define   Ilactamme(                                                                                                                    \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    _Ilactamme(                                                                                                         \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )

=define   __Igsv_lactamme                                                                                                               \
                    Igsv_lactamme
=define   _Igsv_lactamme(                                                                                                               \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    Igsv_lactamme(                                                                                                      \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )
#define   Igsv_lactamme(                                                                                                                \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    _Igsv_lactamme(                                                                                                     \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )

=define   __Idate                                                                                                                       \
                    Idate
=define   _Idate(                                                                                                                       \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    Idate(                                                                                                              \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )
#define   Idate(                                                                                                                        \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    _Idate(                                                                                                             \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )

=define   __Idate_numerique                                                                                                             \
                    Idate_numerique
=define   _Idate_numerique(                                                                                                             \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    Idate_numerique(                                                                                                    \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )
#define   Idate_numerique(                                                                                                              \
                              Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    _Idate_numerique(                                                                                                   \
                                        Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )

=define   __Ititre                                                                                                                      \
                    Ititre
=define   _Ititre(                                                                                                                      \
                              Argument_____titre                                                                                        \
                             ,Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    Ititre(                                                                                                             \
                                        Argument_____titre                                                                              \
                                       ,Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )
#define   Ititre(                                                                                                                       \
                              Argument_____titre                                                                                        \
                             ,Argument_____niveau_fond                                                                                  \
                             ,Argument_____niveau_message                                                                               \
                             ,Argument_____taille_des_caracteres_des_messages                                                           \
                              )                                                                                                         \
                    _Ititre(                                                                                                            \
                                        Argument_____titre                                                                              \
                                       ,Argument_____niveau_fond                                                                        \
                                       ,Argument_____niveau_message                                                                     \
                                       ,Argument_____taille_des_caracteres_des_messages                                                 \
                                        )