#*************************************************************************************************************************
#
#Copyright or © or Copr.[DGFIP][2017]
#
#Ce logiciel a été initialement développé par la Direction Générale des 
#Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2012 
#au titre des revenus percus en 2011. La présente version a permis la 
#génération du moteur de calcul des chaînes de taxation des rôles d'impôt 
#sur le revenu de ce millésime.
#
#Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 
#et respectant les principes de diffusion des logiciels libres. Vous pouvez 
#utiliser, modifier et/ou redistribuer ce programme sous les conditions de 
#la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA  sur 
#le site "http://www.cecill.info".
#
#Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 
#connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes.
#
#**************************************************************************************************************************
regle corrective base_stratemajo 120:
application :  oceans, iliad ;
MAJOIR07TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPIR_A)) * MAJOIR07TARDIF_D 
		  + positif(PROPIR_A) * MAJOIR07TARDIF_P) ;
MAJOIR08TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPIR_A)) * MAJOIR08TARDIF_D 
		  + positif(PROPIR_A) * MAJOIR08TARDIF_P) ;
MAJOIR17_1TARD_DEF = FLAG_RETARD * 
		((1 - positif(PROPIR_A)) * MAJOIR17_1TARDIF_D 
		  + positif(PROPIR_A) * MAJOIR17_1TARDIF_P) ;
MAJOIR17_2TARD_DEF = FLAG_RETARD * 
		((1 - positif(PROPIR_A)) * MAJOIR17_2TARDIF_D 
		  + positif(PROPIR_A) * MAJOIR17_2TARDIF_P) ;
MAJOIRTARDIF_DEF = positif(FLAG_TRTARDIF) * positif(FLAG_RETARD) 
			* (somme(x = 07,08 : MAJOIR0xTARDIF_DEF)
		    + MAJOIR17_1TARD_DEF + MAJOIR17_2TARD_DEF)
		    + (1 - positif(FLAG_TRTARDIF) * positif(FLAG_RETARD))
		    * MAJOIRTARDIF_REF ;
MAJOCS07TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPCS_A)) * MAJOCS07TARDIF_D 
		  + positif(PROPCS_A) * MAJOCS07TARDIF_P) ;
MAJOCS08TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPCS_A)) * MAJOCS08TARDIF_D 
		  + positif(PROPCS_A) * MAJOCS08TARDIF_P) ;
MAJOCS17TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPCS_A)) * MAJOCS17TARDIF_D 
		  + positif(PROPCS_A) * MAJOCS17TARDIF_P) ;
MAJOCSTARDIF_DEF = somme(x = 07,08,17 : MAJOCSxTARDIF_DEF);
MAJOPS07TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPPS_A)) * MAJOPS07TARDIF_D 
		  + positif(PROPPS_A) * MAJOPS07TARDIF_P) ;
MAJOPS08TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPPS_A)) * MAJOPS08TARDIF_D 
		  + positif(PROPPS_A) * MAJOPS08TARDIF_P) ;
MAJOPS17TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPPS_A)) * MAJOPS17TARDIF_D 
		  + positif(PROPPS_A) * MAJOPS17TARDIF_P) ;
MAJOPSTARDIF_DEF = somme(x = 07,08,17 : MAJOPSxTARDIF_DEF);
MAJORD07TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPRD_A)) * MAJORD07TARDIF_D 
		  + positif(PROPRD_A) * MAJORD07TARDIF_P) ;
MAJORD08TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPRD_A)) * MAJORD08TARDIF_D 
		  + positif(PROPRD_A) * MAJORD08TARDIF_P) ;
MAJORD17TARDIF_DEF = FLAG_RETARD * 
		((1 - positif(PROPRD_A)) * MAJORD17TARDIF_D 
		  + positif(PROPRD_A) * MAJORD17TARDIF_P) ;
MAJORDTARDIF_DEF = somme(x = 07,08,17 : MAJORDxTARDIF_DEF);
MAJOSA07TARDIF_DEF = FLAG_RETARD * MAJOCSAL07TARDIF_D;

MAJOSA08TARDIF_DEF = FLAG_RETARD * MAJOCSAL08TARDIF_D;
MAJOSA17TARDIF_DEF = FLAG_RETARD * MAJOCSAL17TARDIF_D;
MAJOSATARDIF_DEF = somme(x = 07,08,17 : MAJOSAxTARDIF_DEF);
MAJOGA07TARDIF_DEF = FLAG_RETARD * MAJOGAIN07TARDIF_D;

MAJOGA08TARDIF_DEF = FLAG_RETARD * MAJOGAIN08TARDIF_D;
MAJOGA17TARDIF_DEF = FLAG_RETARD * MAJOGAIN17TARDIF_D;
MAJOGAINTARDIF_DEF = somme(x = 07,08,17 : MAJOGAxTARDIF_DEF);
MAJOCDIS07TARD_DEF = FLAG_RETARD * MAJOCDIS07TARDIF_D;
MAJOCDIS08TARD_DEF = FLAG_RETARD * MAJOCDIS08TARDIF_D;
MAJOCDIS17TARD_DEF = FLAG_RETARD * MAJOCDIS17TARDIF_D;
MAJOCDISTARDIF_DEF = somme(x = 07,08,17 : MAJOCDISxTARD_DEF);
MAJORSE107TARD_DEF = FLAG_RETARD * MAJORSE107TARDIF_D;
MAJORSE108TARD_DEF = FLAG_RETARD * MAJORSE108TARDIF_D;
MAJORSE117TARD_DEF = FLAG_RETARD * MAJORSE117TARDIF_D;
MAJORSE1TARDIF_DEF = somme(x = 07,08,17 : MAJORSE1xTARD_DEF);
MAJORSE207TARD_DEF = FLAG_RETARD * MAJORSE207TARDIF_D;
MAJORSE208TARD_DEF = FLAG_RETARD * MAJORSE208TARDIF_D;
MAJORSE217TARD_DEF = FLAG_RETARD * MAJORSE217TARDIF_D;
MAJORSE2TARDIF_DEF = somme(x = 07,08,17 : MAJORSE2xTARD_DEF);
MAJORSE307TARD_DEF = FLAG_RETARD * MAJORSE307TARDIF_D;
MAJORSE308TARD_DEF = FLAG_RETARD * MAJORSE308TARDIF_D;
MAJORSE317TARD_DEF = FLAG_RETARD * MAJORSE317TARDIF_D;
MAJORSE3TARDIF_DEF = somme(x = 07,08,17 : MAJORSE3xTARD_DEF);
MAJORSE407TARD_DEF = FLAG_RETARD * MAJORSE407TARDIF_D;
MAJORSE408TARD_DEF = FLAG_RETARD * MAJORSE408TARDIF_D;
MAJORSE417TARD_DEF = FLAG_RETARD * MAJORSE417TARDIF_D;
MAJORSE4TARDIF_DEF = somme(x = 07,08,17 : MAJORSE4xTARD_DEF);
MAJOTA07TARDIF_DEF = FLAG_RETARD * MAJOTAXA07TARDIF_D;
MAJOTA08TARDIF_DEF = FLAG_RETARD * MAJOTAXA08TARDIF_D;
MAJOTA17_1TARD_DEF = FLAG_RETARD * MAJOTA17_1TARDIF_D; 
MAJOTA17_2TARD_DEF = FLAG_RETARD * MAJOTA17_2TARDIF_D; 
MAJOTAXATARDIF_DEF = somme(x = 07,08 : MAJOTA0xTARDIF_DEF)
		+ MAJOTA17_1TARD_DEF + MAJOTA17_2TARD_DEF;
MAJOHR07TARDIF_DEF = FLAG_RETARD * MAJOHR07TARDIF_D;
MAJOHR08TARDIF_DEF = FLAG_RETARD * MAJOHR08TARDIF_D;
MAJOHR17_1TARD_DEF = FLAG_RETARD * MAJOHR17_1TARDIF_D; 
MAJOHR17_2TARD_DEF = FLAG_RETARD * MAJOHR17_2TARDIF_D; 
MAJOHRTARDIF_DEF = somme(x = 07,08 : MAJOHR0xTARDIF_DEF)
		+ MAJOHR17_1TARD_DEF + MAJOHR17_2TARD_DEF;
MAJOCP07TARDIF_DEF = FLAG_RETARD * MAJOCAP07TARDIF_D;
MAJOCP08TARDIF_DEF = FLAG_RETARD * MAJOCAP08TARDIF_D;
MAJOCP17_1TARD_DEF = FLAG_RETARD * MAJOCP17_1TARDIF_D; 
MAJOCP17_2TARD_DEF = FLAG_RETARD * MAJOCP17_2TARDIF_D; 
MAJOCAPTARDIF_DEF = somme(x = 07,08 : MAJOCP0xTARDIF_DEF)
		+ MAJOCP17_1TARD_DEF + MAJOCP17_2TARD_DEF;
PROPIR_DEF = PROPIR;
PROPCS_DEF = PROPCS;
PROPPS_DEF = PROPPS;
PROPRD_DEF = PROPRD;
IRBASE_DEF = positif(FLAG_TRTARDIF) * positif(FLAG_RETARD) * IRBASE
		+ (1 - positif(FLAG_TRTARDIF)) * IRBASE_REF;
IRNINTARDIF_DEF = max(0,FLAG_RETARD *
		  (FLAG_TRTARDIF * IRBASE
		  + FLAG_TRTARDIF_R * SUPIR[00]
                  + FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRBASE) 
		    * (positif(FLAG_RECTIF) * min(SUPIR[2],IRBASE)
		      + (1 - positif(FLAG_RECTIF)) * min(IRBASE,IRBASE_REF))
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRBASE))
		      * (positif(FLAG_RECTIF) * min(SUPIR[00],IRBASE)
                     + (1 - positif(FLAG_RECTIF)) * IRBASE_REF)
		      )
                  + (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
                            * (positif(FLAG_RECTIF) * SUPIR[00]
                               + (1 - positif(FLAG_RECTIF)) * IRNINTARDIF_A)
		  ));
CSGTARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * CSBASE
		+ FLAG_TRTARDIF_R * SUPCS[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPCS[2],CSG)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPCS[00],CSG)
		   + (1 - positif(FLAG_RECTIF)) * CSGTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
		          * (positif(FLAG_RECTIF) * SUPCS[00]
		            + (1 - positif(FLAG_RECTIF)) * CSGTARDIF_A)
		    ));
PRSTARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * PSBASE
		+ FLAG_TRTARDIF_R * SUPPS[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPPS[2],PRS)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPPS[00],PRS)
		    + (1 - positif(FLAG_RECTIF)) * PRSTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPPS[00]
			  + (1 - positif(FLAG_RECTIF)) * PRSTARDIF_A)
		));
RDSTARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * RDBASE
		+ FLAG_TRTARDIF_R * SUPRD[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPRD[2],RDSN)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPRD[00],RDSN)
		     + (1 - positif(FLAG_RECTIF)) * RDSTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPRD[00]
			  + (1 - positif(FLAG_RECTIF)) * RDSTARDIF_A)
		));
CSALTARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * CSALBASE
		+ FLAG_TRTARDIF_R * SUPCSAL[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPCSAL[2],CSAL)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPCSAL[00],CSAL)
		     + (1 - positif(FLAG_RECTIF)) * CSALTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPCSAL[00]
			  + (1 - positif(FLAG_RECTIF)) * CSALTARDIF_A)
		));
CDISTARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * CDISBASE
		+ FLAG_TRTARDIF_R * SUPCDIS[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPCDIS[2],CDIS)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPCDIS[00],CDIS)
		     + (1 - positif(FLAG_RECTIF)) * CDISTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPCDIS[00]
			  + (1 - positif(FLAG_RECTIF)) * CDISTARDIF_A)
		));
TAXATARDIF_DEF = max(0,FLAG_RETARD *
		  (FLAG_TRTARDIF * TAXABASE_MAJO
		+ FLAG_TRTARDIF_R * SUPTAXA[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(TAXATARDIF_A - TAXABASE_MAJO) * min(SUPTAXA[2],TAXASSUR)
		    + (1 - positif(TARDIFEVT2) * positif(TAXATARDIF_A - TAXABASE_MAJO)) 
		      * (positif(FLAG_RECTIF) * min(SUPTAXA[00],TAXASSUR)
		    + (1 - positif(FLAG_RECTIF)) * TAXATARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPTAXA[00]
			  + (1 - positif(FLAG_RECTIF)) * TAXATARDIF_A)
		  ));
GAINTARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * GAINBASE
		+ FLAG_TRTARDIF_R * SUPGAIN[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPGAIN[2],GAINSAL)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPGAIN[00],CSAL)
		     + (1 - positif(FLAG_RECTIF)) * GAINTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPGAIN[00]
			  + (1 - positif(FLAG_RECTIF)) * GAINTARDIF_A)
		));
CAPTARDIF_DEF = max(0,FLAG_RETARD *
		  (FLAG_TRTARDIF * CAPBASE_MAJO
		+ FLAG_TRTARDIF_R * SUPCAP[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(CAPTARDIF_A - CAPBASE_MAJO) * min(SUPCAP[2],IPCAPTAXT)
		    + (1 - positif(TARDIFEVT2) * positif(CAPTARDIF_A - CAPBASE_MAJO)) 
		      * (positif(FLAG_RECTIF) * min(SUPCAP[00], IPCAPTAXT)
		    + (1 - positif(FLAG_RECTIF)) * CAPTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPCAP[00]
			  + (1 - positif(FLAG_RECTIF)) * CAPTARDIF_A)
		  ));
HRTARDIF_DEF = max(0,FLAG_RETARD *
		  (FLAG_TRTARDIF * HRBASE_MAJO
		+ FLAG_TRTARDIF_R * SUPHR[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(HRTARDIF_A - HRBASE_MAJO) * min(SUPHR[2],IHAUTREVT)
		    + (1 - positif(TARDIFEVT2) * positif(HRTARDIF_A - HRBASE_MAJO)) 
		      * (positif(FLAG_RECTIF) * min(SUPHR[00],IHAUTREVT)
		    + (1 - positif(FLAG_RECTIF)) * HRTARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPHR[00]
			  + (1 - positif(FLAG_RECTIF)) * HRTARDIF_A)
		  ));
RSE1TARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * RSE1BASE
		+ FLAG_TRTARDIF_R * SUPRSE1[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPRSE1[2],RSE1)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPRSE1[00],RSE1)
		     + (1 - positif(FLAG_RECTIF)) * RSE1TARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPRSE1[00]
			  + (1 - positif(FLAG_RECTIF)) * RSE1TARDIF_A)
		));
RSE2TARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * RSE2BASE
		+ FLAG_TRTARDIF_R * SUPRSE2[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPRSE2[2],RSE2)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPRSE2[00],RSE2)
		     + (1 - positif(FLAG_RECTIF)) * RSE2TARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPRSE2[00]
			  + (1 - positif(FLAG_RECTIF)) * RSE1TARDIF_A)
		));
RSE3TARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * RSE3BASE
		+ FLAG_TRTARDIF_R * SUPRSE3[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPRSE3[2],RSE3)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPRSE3[00],RSE3)
		     + (1 - positif(FLAG_RECTIF)) * RSE3TARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPRSE3[00]
			  + (1 - positif(FLAG_RECTIF)) * RSE3TARDIF_A)
		));
RSE4TARDIF_DEF = max(0,FLAG_RETARD *
		(FLAG_TRTARDIF * RSE4BASE
		+ FLAG_TRTARDIF_R * SUPRSE4[00]
		+ FLAG_TRTARDIF_F *
                    (positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN) * min(SUPRSE4[2],RSE4)
		    + (1 - positif(TARDIFEVT2) * positif(IRNINTARDIF_A - IRNIN)) 
		      * (positif(FLAG_RECTIF) * min(SUPRSE4[00],RSE4)
		     + (1 - positif(FLAG_RECTIF)) * RSE4TARDIF_A)
		      )
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
			* (positif(FLAG_RECTIF) * SUPRSE4[00]
			  + (1 - positif(FLAG_RECTIF)) * RSE4TARDIF_A)
		));
IRNINMAJOP_DEF = max(IRNIN_MAJOP,IRNINMAJOP_A);
CSGMAJOP_DEF = max(CSG_MAJOP,CSGMAJOP_A);
RDSMAJOP_DEF =  max(RDS_MAJOP,RDSMAJOP_A);
PRSMAJOP_DEF =  max(PRS_MAJOP,PRSMAJOP_A);
regle corrective base_stratemajo 12000:
application :  iliad ;


MAJOISF07TARD_DEF = FLAG_RETARD * MAJOISF07TARDIF_D;
MAJOISF08TARD_DEF = FLAG_RETARD * MAJOISF08TARDIF_D;
MAJOISF17TARD_DEF = FLAG_RETARD * MAJOISF17TARDIF_D;
MAJOISFTARDIF_DEF = somme(x = 07,08,17 : MAJOISFxTARD_DEF);

ISFTARDIF_DEF = max(0,FLAG_RETARD *
                (FLAG_TRTARDIF * ISF4BASE
		+ FLAG_TRTARDIF_R * SUPISF[00]
		+ FLAG_TRTARDIF_F *
		(positif(TARDIFEVT2) * positif(ISFINTARDIF_A - ISFIN) * min(SUPISF[2],ISFNET)
		+ (1 - positif(TARDIFEVT2) * positif(ISFINTARDIF_A - ISFIN))
		* (positif(FLAG_RECTIF) * min(SUPISF[00],ISFNET)
		+ (1 - positif(FLAG_RECTIF)) * ISFTARDIF_A)
		)
		+ (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
		* (positif(FLAG_RECTIF) * SUPISF[00]
		+ (1 - positif(FLAG_RECTIF)) * ISFTARDIF_A)
		));

ISFBASE_DEF = positif(FLAG_TRTARDIF) * positif(FLAG_RETARD) * ISF4BASE
               + (1 - positif(FLAG_TRTARDIF)) * ISFBASE_REF;
ISFINTARDIF_DEF = max(0,FLAG_RETARD *
(FLAG_TRTARDIF * ISF4BASE
+ FLAG_TRTARDIF_R * SUPISF[00]
 + FLAG_TRTARDIF_F *
 (positif(TARDIFEVT2) * positif(ISFINTARDIF_A - ISF4BASE)
 * (positif(FLAG_RECTIF) * min(SUPISF[2],ISF4BASE)
 + (1 - positif(FLAG_RECTIF)) * min(ISF4BASE,ISFBASE_REF))
 + (1 - positif(TARDIFEVT2) * positif(ISFINTARDIF_A - ISF4BASE))
  * (positif(FLAG_RECTIF) * min(SUPISF[00],ISF4BASE)
  + (1 - positif(FLAG_RECTIF)) * ISFBASE_REF)
  )
  + (1 - positif(FLAG_TRTARDIF+FLAG_TRTARDIF_R+FLAG_TRTARDIF_F+FLAG_TRMAJOP))
  * (positif(FLAG_RECTIF) * SUPISF[00]
  + (1 - positif(FLAG_RECTIF)) * ISFINTARDIF_A)
    ));



regle corrective base_stratemajo 121:
application :  oceans, iliad ;
pour x = 07,08,11,31:
MAJOPIRx_DEF = max(MAJOIR_Px,MAJOPIRx_A);
MAJOPIR10_1DEF = max(MAJOIR_P10_1,MAJOPIR10_1A);
MAJOPIR10_2DEF = max(MAJOIR_P10_2,MAJOPIR10_2A);
MAJOPIR17_1DEF = max(MAJOIR_P17_1,MAJOPIR17_1A);
MAJOPIR17_2DEF = max(MAJOIR_P17_2,MAJOPIR17_2A);
MAJOPIR_DEF = max(MAJOPIR_TOT,MAJOPIR_A);
pour x = 07,08,10,11,17,31:
MAJOPCSx_DEF = max(MAJOCS_Px,MAJOPCSx_A);
MAJOPCS_DEF = max(MAJOPCS_TOT,MAJOPCS_A);
pour x = 07,08,10,11,17,31:
MAJOPRDx_DEF = max(MAJORD_Px,MAJOPRDx_A);
MAJOPRD_DEF = max(MAJOPRD_TOT,MAJOPRD_A);
pour x = 07,08,10,11,17,31:
MAJOPPSx_DEF = max(MAJOPS_Px,MAJOPPSx_A);
MAJOPPS_DEF = max(MAJOPPS_TOT,MAJOPPS_A);
regle corrective base_stratemajo 122:
application :  oceans, iliad ;
MAJOIRST_DEF = MAJOIR_ST ;
MAJOCSST_DEF = MAJOCS_ST;
MAJORDST_DEF = MAJORD_ST;
MAJOPSST_DEF = MAJOPS_ST;
MAJOCSALST_DEF = MAJOCSAL_ST;
MAJOCDISST_DEF = MAJOCDIS_ST;
MAJOTAXAST_DEF = MAJOTAXA_ST;


MAJOGAINST_DEF = MAJOGAIN_ST;
MAJORSE1ST_DEF = MAJORSE1_ST;
MAJORSE2ST_DEF = MAJORSE2_ST;
MAJORSE3ST_DEF = MAJORSE3_ST;
MAJORSE4ST_DEF = MAJORSE4_ST;
MAJOCAPST_DEF = MAJOCAP_ST;
MAJOHRST_DEF = MAJOHR_ST;
TNAPCR[X] = NAPCRINR;

TIRBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(IRBASE,TIRBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(IRBASE,IRNIN_P))
            + (1 - null(X)) * max(IRBASE,TIRBASE[FLAG_DERSTTR]);
TIRBASEDEF[X] = IRBASE;
TCSBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(CSBASE,TCSBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(CSBASE,CSG_P))
           + (1 - null(X)) * max(CSBASE,TCSBASE[FLAG_DERSTTR]);
TRDBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(RDBASE,TRDBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(RDBASE,RDS_P))
           + (1 - null(X)) * max(RDBASE,TRDBASE[FLAG_DERSTTR]);
TPSBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(PSBASE,TPSBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(PSBASE,PRS_P))
           + (1 - null(X)) * max(PSBASE,TPSBASE[FLAG_DERSTTR]);
TCSALBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(CSALBASE,TCSALBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(CSALBASE,CSAL_P))
           + (1 - null(X)) * max(CSALBASE,TCSALBASE[FLAG_DERSTTR]);
TGAINBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(GAINBASE,TGAINBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(GAINBASE,GAIN_P))
           + (1 - null(X)) * max(GAINBASE,TGAINBASE[FLAG_DERSTTR]);
TCDISBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(CDISBASE,TCDISBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(CDISBASE,CDIS_P))
           + (1 - null(X)) * max(CDISBASE,TCDISBASE[FLAG_DERSTTR]);
TRSE1BASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(RSE1BASE,TRSE1BASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(RSE1BASE,RSE1_P))
           + (1 - null(X)) * max(RSE1BASE,TRSE1BASE[FLAG_DERSTTR]);
TRSE2BASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(RSE2BASE,TRSE2BASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(RSE2BASE,RSE2_P))
           + (1 - null(X)) * max(RSE2BASE,TRSE2BASE[FLAG_DERSTTR]);
TRSE3BASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(RSE3BASE,TRSE3BASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(RSE3BASE,RSE3_P))
           + (1 - null(X)) * max(RSE3BASE,TRSE3BASE[FLAG_DERSTTR]);
TRSE4BASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(RSE4BASE,TRSE4BASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(RSE4BASE,RSE4_P))
           + (1 - null(X)) * max(RSE4BASE,TRSE4BASE[FLAG_DERSTTR]);
TPCAPBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(CAPBASE_MAJO,TPCAPBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(CAPBASE_MAJO,PCAPBRUT_P))
           + (1 - null(X)) * max(CAPBASE_MAJO,TPCAPBASE[FLAG_DERSTTR]);
TPCAPBASEDEF[X] = CAPBASE_MAJO;
TCHRBASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(HRBASE_MAJO,TCHRBASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(HRBASE_MAJO,CHRBRUT_P))
           + (1 - null(X)) * max(HRBASE_MAJO,TCHRBASE[FLAG_DERSTTR]);
TCHRBASEDEF[X] = HRBASE_MAJO;
TTAXABASE[X] = null(X) * 
	    ( positif(FLAG_RETARD) * positif(FLAG_RECTIF)* max(TAXABASE_MAJO,TTAXABASE[FLAG_DERSTTR]) 
	     + (1 - positif(FLAG_RETARD) * positif(FLAG_RECTIF)) * max(TAXABASE_MAJO,TAXABRUT_P))
           + (1 - null(X)) * max(TAXABASE_MAJO,TTAXABASE[FLAG_DERSTTR]);
TTAXABASEDEF[X] = TAXABASE_MAJO;
MAJOIR01 = TMAJOIR[22] * STR_TR22
	   + TMAJOIR[01] * null(CSTRATE1 - 1);
MAJOIR02_1 = TMAJOIR[20] * STR_TR20 
	   + TMAJOIR[01] * null(CSTRATE1 - 2);
MAJOIR02_1_NTL = T2MAJOIR[17] * STR_TR17
	   + T2MAJOIR[01] * null(CSTRATE1 - 2);
MAJOIR02_2_NTL = T2MAJOIR[18] * STR_TR18 * (1 - positif(TIRBASE[18]-TIRBASE[20]) * positif(TIRBASE[20])) * (1 - IND_RJLJ)
               + positif(TIRBASE[18] - TIRBASE[20]) * (1 - IND_RJLJ) * positif(TIRBASE[20])
                * arr(max(0,(TIRBASE[18] - TIRBASE[0] - (TIRBASE[18] - TIRBASEDEF[20]))) * TX1758A/100) * STR_TR18
               + T2MAJOIR[01] * null(CSTRATE1 - 2);
MAJOIR02_1_TL = T2MAJOIR[19] * STR_TR19;
MAJOIR02_2_TL = T2MAJOIR[20] * STR_TR20;
MAJOIR02_2 = MAJOIR02_2_TL + MAJOIR02_2_NTL;
MAJOIR03 = TMAJOIR[13] * STR_TR13 
	   + TMAJOIR[01] * null(CSTRATE1 - 3);
MAJOIR04 = TMAJOIR[08] * STR_TR08 
	   + TMAJOIR[01] * null(CSTRATE1 - 4);
MAJOIR05 = TMAJOIR[07] * STR_TR07 
	   + TMAJOIR[01] * null(CSTRATE1 - 5);
MAJOIR06 = TMAJOIR[03] * STR_TR03
	   + TMAJOIR[01] * null(CSTRATE1 - 6);
MAJOIR07 = TMAJOIR[16] * STR_TR16 
	   + TMAJOIR[01] * null(CSTRATE1 - 7)
	   + max(0,MAJOIR07TARDIF_DEF) ;
MAJOIR08 = TMAJOIR[11] * STR_TR11 
	   + TMAJOIR[01] * null(CSTRATE1 - 8)
	   + max(0,MAJOIR08TARDIF_DEF) ;
MAJOIR10_1 = TMAJOIR[14] * STR_TR14 
	   + TMAJOIR[01] * null(CSTRATE1 - 10);
MAJOIR10_2 = T2MAJOIR[14] * STR_TR14
	   + T2MAJOIR[01] * null(CSTRATE1 - 10);
MAJOIR11 = TMAJOIR[10] * STR_TR10 
	   + TMAJOIR[01] * null(CSTRATE1 - 11);
MAJOIR17_1 = TMAJOIR[15] * STR_TR15  
	   + TMAJOIR[01] * null(CSTRATE1 - 17)
	   + max(0,MAJOIR17_1TARD_DEF);
MAJOIR17_2 = T2MAJOIR[15] * STR_TR15
	   + T2MAJOIR[01] * null(CSTRATE1 - 17)
	   + max(0,MAJOIR17_2TARD_DEF);
MAJOIR22 = TMAJOIR[21] * STR_TR21 
	   + TMAJOIR[01] * null(CSTRATE1 - 22);
MAJOIR30 = TMAJOIR[09] * STR_TR09 
	   + TMAJOIR[01] * null(CSTRATE1 - 30);
MAJOIR31 = TMAJOIR[06] * STR_TR06 
	   + TMAJOIR[01] * null(CSTRATE1 - 31);
MAJOIR32 = TMAJOIR[05] * STR_TR05 
	   + TMAJOIR[01] * null(CSTRATE1 - 32);
MAJOIR55 = TMAJOIR[12] * STR_TR12
	   + TMAJOIR[01] * null(CSTRATE1 - 55);
MAJOIR99 = (TMAJOIR[00] * STR_TR00 
	   + TMAJOIR[01] * null(CSTRATE1 - 99)) * (1 - positif(CSTRATE99)) ;
MAJOPS01 = TMAJOPS[22] * STR_TR22 
	   + TMAJOPS[01] * null(CSTRATE1 - 1);
MAJOPS02 = TMAJOPS[20] * STR_TR20 
	   + TMAJOPS[01] * null(CSTRATE1 - 2);
MAJOPS03 = TMAJOPS[13] * STR_TR13 
	   + TMAJOPS[01] * null(CSTRATE1 - 3);
MAJOPS04 = TMAJOPS[08] * STR_TR08 
	   + TMAJOPS[01] * null(CSTRATE1 - 4);
MAJOPS05 = TMAJOPS[07] * STR_TR07 
	   + TMAJOPS[01] * null(CSTRATE1 - 5);
MAJOPS06 = TMAJOPS[03] * STR_TR03
	   + TMAJOPS[01] * null(CSTRATE1 - 6);
MAJOPS07 = TMAJOPS[16] * STR_TR16 
	   + TMAJOPS[01] * null(CSTRATE1 - 7)
           + max(0,MAJOPS07TARDIF_DEF) ;
MAJOPS08 = TMAJOPS[11] * STR_TR11 
	   + TMAJOPS[01] * null(CSTRATE1 - 8)
           + max(0,MAJOPS08TARDIF_DEF) ;
MAJOPS10 = TMAJOPS[14] * STR_TR14 
	   + TMAJOPS[01] * null(CSTRATE1 - 10);
MAJOPS11 = TMAJOPS[10] * STR_TR10 
	   + TMAJOPS[01] * null(CSTRATE1 - 11);
MAJOPS17 = TMAJOPS[15] * STR_TR15 
	   + TMAJOPS[01] * null(CSTRATE1 - 17)
           + max(0,MAJOPS17TARDIF_DEF) ;
MAJOPS22 = TMAJOPS[21] * STR_TR21 
	   + TMAJOPS[01] * null(CSTRATE1 - 22);
MAJOPS30 = TMAJOPS[09] * STR_TR09 
	   + TMAJOPS[01] * null(CSTRATE1 - 30);
MAJOPS31 = TMAJOPS[06] * STR_TR06 
	   + TMAJOPS[01] * null(CSTRATE1 - 31);
MAJOPS55 = TMAJOPS[12] * STR_TR12 
	   + TMAJOPS[01] * null(CSTRATE1 - 55);
MAJOPS99 = (TMAJOPS[00] * STR_TR00 
	   + TMAJOPS[01] * null(CSTRATE1 - 99)) * (1 - positif(CSTRATE99));
MAJOCS01 = TMAJOCS[22] * STR_TR22 
	   + TMAJOCS[01] * null(CSTRATE1 - 1);
MAJOCS02 = TMAJOCS[20] * STR_TR20 
	   + TMAJOCS[01] * null(CSTRATE1 - 2);
MAJOCS03 = TMAJOCS[13] * STR_TR13 
	   + TMAJOCS[01] * null(CSTRATE1 - 3);
MAJOCS04 = TMAJOCS[08] * STR_TR08 
	   + TMAJOCS[01] * null(CSTRATE1 - 4);
MAJOCS05 = TMAJOCS[07] * STR_TR07 
	   + TMAJOCS[01] * null(CSTRATE1 - 5);
MAJOCS06 = TMAJOCS[03] * STR_TR03
	   + TMAJOCS[01] * null(CSTRATE1 - 6);
MAJOCS07 = TMAJOCS[16] * STR_TR16 
	   + TMAJOCS[01] * null(CSTRATE1 - 7)
           + max(0,MAJOCS07TARDIF_DEF) ;
MAJOCS08 = TMAJOCS[11] * STR_TR11 
	   + TMAJOCS[01] * null(CSTRATE1 - 8)
           + max(0,MAJOCS08TARDIF_DEF) ;
MAJOCS10 = TMAJOCS[14] * STR_TR14 
	   + TMAJOCS[01] * null(CSTRATE1 - 10);
MAJOCS11 = TMAJOCS[10] * STR_TR10 
	   + TMAJOCS[01] * null(CSTRATE1 - 11);
MAJOCS17 = TMAJOCS[15] * STR_TR15 
	   + TMAJOCS[01] * null(CSTRATE1 - 17)
           + max(0,MAJOCS17TARDIF_DEF) ;
MAJOCS22 = TMAJOCS[21] * STR_TR21 
	   + TMAJOCS[01] * null(CSTRATE1 - 22);
MAJOCS30 = TMAJOCS[09] * STR_TR09 
	   + TMAJOCS[01] * null(CSTRATE1 - 30);
MAJOCS31 = TMAJOCS[06] * STR_TR06 
	   + TMAJOCS[01] * null(CSTRATE1 - 31);
MAJOCS32 = TMAJOCS[05] * STR_TR05 
	   + TMAJOCS[01] * null(CSTRATE1 - 32);
MAJOCS55 = TMAJOCS[12] * STR_TR12 
	   + TMAJOCS[01] * null(CSTRATE1 - 55);
MAJOCS99 = (TMAJOCS[00] * STR_TR00 
	   + TMAJOCS[01] * null(CSTRATE1 - 99)) * (1 - positif(CSTRATE99));
MAJORD01 = TMAJORD[22] * STR_TR22 
	   + TMAJORD[01] * null(CSTRATE1 - 1);
MAJORD02 = TMAJORD[20] * STR_TR20 
	   + TMAJORD[01] * null(CSTRATE1 - 2);
MAJORD03 = TMAJORD[13] * STR_TR13 
	   + TMAJORD[01] * null(CSTRATE1 - 3);
MAJORD04 = TMAJORD[08] * STR_TR08 
	   + TMAJORD[01] * null(CSTRATE1 - 4);
MAJORD05 = TMAJORD[07] * STR_TR07 
	   + TMAJORD[01] * null(CSTRATE1 - 5);
MAJORD06 = TMAJORD[03] * STR_TR03
	   + TMAJORD[01] * null(CSTRATE1 - 6);
MAJORD07 = TMAJORD[16] * STR_TR16 
	   + TMAJORD[01] * null(CSTRATE1 - 7)
           + max(0,MAJORD07TARDIF_DEF) ;
MAJORD08 = TMAJORD[11] * STR_TR11 
	   + TMAJORD[01] * null(CSTRATE1 - 8)
           + max(0,MAJORD08TARDIF_DEF) ;
MAJORD10 = TMAJORD[14] * STR_TR14 
	   + TMAJORD[01] * null(CSTRATE1 - 10);
MAJORD11 = TMAJORD[10] * STR_TR10 
	   + TMAJORD[01] * null(CSTRATE1 - 11);
MAJORD17 = TMAJORD[15] * STR_TR15 
	   + TMAJORD[01] * null(CSTRATE1 - 17)
           + max(0,MAJORD17TARDIF_DEF) ;
MAJORD22 = TMAJORD[21] * STR_TR21 
	   + TMAJORD[01] * null(CSTRATE1 - 22);
MAJORD30 = TMAJORD[09] * STR_TR09 
	   + TMAJORD[01] * null(CSTRATE1 - 30);
MAJORD31 = TMAJORD[06] * STR_TR06 
	   + TMAJORD[01] * null(CSTRATE1 - 31);
MAJORD32 = TMAJORD[05] * STR_TR05 
	   + TMAJORD[01] * null(CSTRATE1 - 32);
MAJORD55 = TMAJORD[12] * STR_TR12 
	   + TMAJORD[01] * null(CSTRATE1 - 55);
MAJORD99 = (TMAJORD[00] * STR_TR00 
	   + TMAJORD[01] * null(CSTRATE1 - 99)) * (1 - positif(CSTRATE99));
MAJOCSAL01 = TMAJOCSAL[22] * STR_TR22 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 1);
MAJOCSAL02 = TMAJOCSAL[20] * STR_TR20 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 2);
MAJOCSAL03 = TMAJOCSAL[13] * STR_TR13 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 3);
MAJOCSAL04 = TMAJOCSAL[08] * STR_TR08 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 4);
MAJOCSAL05 = TMAJOCSAL[07] * STR_TR07 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 5);
MAJOCSAL06 = TMAJOCSAL[03] * STR_TR03
	   + TMAJOCSAL[01] * null(CSTRATE1 - 6);
MAJOCSAL07 = TMAJOCSAL[16] * STR_TR16 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 7)
           + max(0,MAJOSA07TARDIF_DEF) ;
MAJOCSAL08 = TMAJOCSAL[11] * STR_TR11 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 8)
           + max(0,MAJOSA08TARDIF_DEF) ;
MAJOCSAL10 = TMAJOCSAL[14] * STR_TR14 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 10);
MAJOCSAL11 = TMAJOCSAL[10] * STR_TR10 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 11);
MAJOCSAL17 = TMAJOCSAL[15] * STR_TR15 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 17)
           + max(0,MAJOSA17TARDIF_DEF) ;
MAJOCSAL22 = TMAJOCSAL[21] * STR_TR21 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 22);
MAJOCSAL30 = TMAJOCSAL[09] * STR_TR09 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 30);
MAJOCSAL31 = TMAJOCSAL[06] * STR_TR06 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 31);
MAJOCSAL55 = TMAJOCSAL[12] * STR_TR12 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 55);
MAJOCSAL99 = (TMAJOCSAL[00] * STR_TR00 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 99)) * (1 - positif(CSTRATE99));
MAJOGAIN01 = TMAJOGAIN[22] * STR_TR22 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 1);
MAJOGAIN02 = TMAJOGAIN[20] * STR_TR20 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 2);
MAJOGAIN03 = TMAJOGAIN[13] * STR_TR13 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 3);
MAJOGAIN04 = TMAJOGAIN[08] * STR_TR08 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 4);
MAJOGAIN05 = TMAJOGAIN[07] * STR_TR07 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 5);
MAJOGAIN06 = TMAJOGAIN[03] * STR_TR03
	   + TMAJOGAIN[01] * null(CSTRATE1 - 6);
MAJOGAIN07 = TMAJOGAIN[16] * STR_TR16 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 7)
           + max(0,MAJOGA07TARDIF_DEF) ;
MAJOGAIN08 = TMAJOGAIN[11] * STR_TR11 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 8)
           + max(0,MAJOGA08TARDIF_DEF) ;
MAJOGAIN10 = TMAJOGAIN[14] * STR_TR14 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 10);
MAJOGAIN11 = TMAJOGAIN[10] * STR_TR10 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 11);
MAJOGAIN17 = TMAJOGAIN[15] * STR_TR15 
	   + TMAJOCSAL[01] * null(CSTRATE1 - 17)
           + max(0,MAJOGA17TARDIF_DEF) ;
MAJOGAIN22 = TMAJOGAIN[21] * STR_TR21 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 22);
MAJOGAIN30 = TMAJOGAIN[09] * STR_TR09 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 30);
MAJOGAIN31 = TMAJOGAIN[06] * STR_TR06 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 31);
MAJOGAIN55 = TMAJOGAIN[12] * STR_TR12 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 55);
MAJOGAIN99 = (TMAJOGAIN[00] * STR_TR00 
	   + TMAJOGAIN[01] * null(CSTRATE1 - 99)) * (1 - positif(CSTRATE99));
MAJOCDIS01 = TMAJOCDIS[22] * STR_TR22 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 1);
MAJOCDIS02 = TMAJOCDIS[20] * STR_TR20 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 2);
MAJOCDIS03 = TMAJOCDIS[13] * STR_TR13 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 3);
MAJOCDIS04 = TMAJOCDIS[08] * STR_TR08 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 4);
MAJOCDIS05 = TMAJOCDIS[07] * STR_TR07 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 5);
MAJOCDIS06 = TMAJOCDIS[03] * STR_TR03
	   + TMAJOCDIS[01] * null(CSTRATE1 - 6);
MAJOCDIS07 = TMAJOCDIS[16] * STR_TR16 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 7)
           + max(0,MAJOCDIS07TARD_DEF) ;
MAJOCDIS08 = TMAJOCDIS[11] * STR_TR11 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 8)
           + max(0,MAJOCDIS08TARD_DEF) ;
MAJOCDIS10 = TMAJOCDIS[14] * STR_TR14 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 10);
MAJOCDIS11 = TMAJOCDIS[10] * STR_TR10 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 11);
MAJOCDIS17 = TMAJOCDIS[15] * STR_TR15 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 17)
           + max(0,MAJOCDIS17TARD_DEF) ;
MAJOCDIS22 = TMAJOCDIS[21] * STR_TR21 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 22);
MAJOCDIS30 = TMAJOCDIS[09] * STR_TR09 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 30);
MAJOCDIS31 = TMAJOCDIS[06] * STR_TR06 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 31);
MAJOCDIS55 = TMAJOCDIS[12] * STR_TR12 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 55);
MAJOCDIS99 = (TMAJOCDIS[00] * STR_TR00 
	   + TMAJOCDIS[01] * null(CSTRATE1 - 99)) * (1 - positif(CSTRATE99));
MAJORSE101 = TMAJORSE1[22] * STR_TR22 
	   + TMAJORSE1[01] * null(CSTRATE1 - 1);
MAJORSE102 = TMAJORSE1[20] * STR_TR20 
	   + TMAJORSE1[01] * null(CSTRATE1 - 2);
MAJORSE103 = TMAJORSE1[13] * STR_TR13 
	   + TMAJORSE1[01] * null(CSTRATE1 - 3);
MAJORSE104 = TMAJORSE1[08] * STR_TR08 
	   + TMAJORSE1[01] * null(CSTRATE1 - 4);
MAJORSE105 = TMAJORSE1[07] * STR_TR07 
	   + TMAJORSE1[01] * null(CSTRATE1 - 5);
MAJORSE106 = TMAJORSE1[03] * STR_TR03
	   + TMAJORSE1[01] * null(CSTRATE1 - 6);
MAJORSE107 = TMAJORSE1[16] * STR_TR16 
	   + TMAJORSE1[01] * null(CSTRATE1 - 7)
           + max(0,MAJORSE107TARD_DEF) ;
MAJORSE108 = TMAJORSE1[11] * STR_TR11 
	   + TMAJORSE1[01] * null(CSTRATE1 - 8)
           + max(0,MAJORSE108TARD_DEF) ;
MAJORSE110 = TMAJORSE1[14] * STR_