konto_check 5.5.0 → 5.8.0

data/ext/konto_check_raw/konto_check.c

@@ -13,7 +13,7 @@
  * #  wurden aus der aktuellen BLZ-Datei der Deutschen Bundesbank           #
  * #  �bernommen.                                                           #
  * #                                                                        #
- * #  Copyright (C) 2002-2014 Michael Plugge <m.plugge@hs-mannheim.de>      #
+ * #  Copyright (C) 2002-2015 Michael Plugge <m.plugge@hs-mannheim.de>      #
  * #                                                                        #
  * #  Dieses Programm ist freie Software; Sie d�rfen es unter den           #
  * #  Bedingungen der GNU Lesser General Public License, wie von der Free   #
@@ -45,12 +45,15 @@
  * # im Internet herunterladen.                                             #
  * ##########################################################################
  */
+#line 332 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 /* Definitionen und Includes  */
 #ifndef VERSION
-#define VERSION "5.5 (final)"
+#define VERSION "5.8 (final)"
+#define VERSION_MAJOR 5
+#define VERSION_MINOR 8
 #endif
-#define VERSION_DATE "2014-09-01"
+#define VERSION_DATE "2015-08-22"
 
 #ifndef INCLUDE_KONTO_CHECK_DE
 #define INCLUDE_KONTO_CHECK_DE 1
@@ -101,8 +104,8 @@ static lzo_align_t __LZO_MMODEL wrkmem[LZO1X_1_MEM_COMPRESS];
 #define KONTO_CHECK_VARS
 #include "konto_check.h"
 
-   /* Flag, um die �nderungen zum 9.6.2014 zu aktivieren */
-static int pz_aenderungen_aktivieren;
+   /* Flag, um die �nderungen zum September 2015 zu aktivieren */
+static int pz_aenderungen_aktivieren_2015_09;
 
    /* falls die Variable verbose_debug gesetzt wird, werden bei einigen
     * Funktionen mittels perror() zus�tzliche Debuginfos ausgegeben. Die
@@ -239,6 +242,7 @@ static int convert_encoding(char **data,UINT4 *len);
 #define free(ptr) efree(ptr)
 #endif
 
+#line 770 "ruby/ext/konto_check_raw/konto_check.lxx"
 
    /* Testwert zur Markierung ung�ltiger Ziffern im BLZ-String (>8 Stellen) */
 #define BLZ_FEHLER 100000000
@@ -374,6 +378,7 @@ static int convert_encoding(char **data,UINT4 *len);
     */
 #define CHECK_RETVAL(fkt) do{if((retval=fkt)!=OK)goto fini;}while(0)     /* es mu� noch aufger�umt werden, daher goto */
 #define CHECK_RETURN(fkt) do{if((retval=fkt)!=OK)return retval;}while(0)
+#line 911 "ruby/ext/konto_check_raw/konto_check.lxx"
 
    /* einige Makros zur Umwandlung zwischen unsigned int und char */
 #define UCP  (unsigned char*)
@@ -493,6 +498,7 @@ int pz=-777;
 
 #define E_START(x)
 #define E_END(x)
+#line 1036 "ruby/ext/konto_check_raw/konto_check.lxx"
 
    /* Variable f�r die Methoden 27, 29 und 69 */
 static const int m10h_digits[4][10]={
@@ -530,7 +536,6 @@ static char *default_buffer,*default_ptr,*default_key[DEFAULT_CNT],*default_val[
 static int default_cnt,default_bufsize,default_val_size[DEFAULT_CNT];
 
 static int kto_check_clear_default(void);
-static int kto_check_blz_x(char *blz,char *kto,int *uk_cnt);
 
 #if DEBUG>0
    /* "aktuelles" Datum f�r die Testumgebung (um einen Datumswechsel zu simulieren) */
@@ -942,6 +947,7 @@ static int create_lutfile_int(char *name, char *prolog, int slots,FILE **lut)
  * ###########################################################################
  */
 
+#line 1485 "ruby/ext/konto_check_raw/konto_check.lxx"
 DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
 {
    char buffer[SLOT_BUFFER],*ptr;
@@ -979,6 +985,7 @@ DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
  * #############################################################################
  */
 
+#line 1523 "ruby/ext/konto_check_raw/konto_check.lxx"
 static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
 {
    char buffer[SLOT_BUFFER],*ptr,*cptr;
@@ -1114,6 +1121,7 @@ static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
  * ###########################################################################
  */
 
+#line 1659 "ruby/ext/konto_check_raw/konto_check.lxx"
 DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **data)
 {
    int retval;
@@ -1136,6 +1144,7 @@ DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **da
  * ###########################################################################
  */
 
+#line 1683 "ruby/ext/konto_check_raw/konto_check.lxx"
 DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
 {
    int retval;
@@ -1157,6 +1166,7 @@ DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
  * ###########################################################################
  */
 
+#line 1706 "ruby/ext/konto_check_raw/konto_check.lxx"
 static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **data)
 {
    char buffer[SLOT_BUFFER],*ptr,*sbuffer,*dbuffer;
@@ -1246,6 +1256,7 @@ static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **
             FREE(sbuffer);
             RETURN(ERROR_MALLOC);
          }
+#line 1811 "ruby/ext/konto_check_raw/konto_check.lxx"
 
          if(fread(sbuffer,1,compressed_len,lut)<compressed_len){
             FREE(sbuffer);
@@ -2838,6 +2849,7 @@ DLL_EXPORT int lut_info_id(char *lut_name,int *info1,int *info2,int *valid1,int
  * ###########################################################################
  */
 
+#line 3404 "ruby/ext/konto_check_raw/konto_check.lxx"
 DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)
 {
    char *ptr,*ptr1,buffer[128];
@@ -2925,6 +2937,7 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
 
       /* Infoblocks lesen: 1. Infoblock */
    if((ret=read_lut_block_int(in,0,LUT2_INFO,&cnt,&ptr))==OK){
+#line 3493 "ruby/ext/konto_check_raw/konto_check.lxx"
       *(ptr+cnt)=0;
       if(valid1){
          for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
@@ -2972,6 +2985,7 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
 
       /* Infoblocks lesen: 2. Infoblock */
    if((ret=read_lut_block_int(in,0,LUT2_2_INFO,&cnt,&ptr))==OK){
+#line 3542 "ruby/ext/konto_check_raw/konto_check.lxx"
       *(ptr+cnt)=0;
       if(valid2){
          for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
@@ -3190,6 +3204,7 @@ DLL_EXPORT int copy_lutfile(char *old_name,char *new_name,int new_slots)
    qsort(slotdir,slot_cnt,sizeof(int),cmp_int);
    for(last_slot=-1,i=0;i<(int)slot_cnt;i++)if((typ=slotdir[i]) && typ!=(UINT4)last_slot){
       read_lut_block_int(lut1,0,typ,&len,&data);
+#line 3762 "ruby/ext/konto_check_raw/konto_check.lxx"
       write_lut_block_int(lut2,typ,len,data);
       FREE(data);
       last_slot=typ;
@@ -3419,6 +3434,7 @@ DLL_EXPORT int lut_init(char *lut_name,int required,int set)
  * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
  * ###########################################################################
  */
+#line 3992 "ruby/ext/konto_check_raw/konto_check.lxx"
 DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,int incremental)
 {
    char *ptr,*dptr,*data,*eptr,*prolog,*info,*user_info,*hs=NULL,*info1,*info2,*ci=NULL,name_buffer[LUT_PATH_LEN];
@@ -3646,6 +3662,7 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
          typ1=typ;
       if(lut2_block_status[typ]==OK)continue;   /* jeden Block nur einmal einlesen */
       retval=read_lut_block_int(lut,0,typ,&len,&data);
+#line 4221 "ruby/ext/konto_check_raw/konto_check.lxx"
 
       switch(retval){
          case LUT_CRC_ERROR:
@@ -3733,6 +3750,7 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
             if(typ==LUT2_2_NAME || typ==LUT2_2_NAME_KURZ){
                FREE(data);
                i=read_lut_block_int(lut,0,LUT2_2_NAME_NAME_KURZ,&len,&data);
+#line 4313 "ruby/ext/konto_check_raw/konto_check.lxx"
                if(i==OK){  /* was gefunden; Typ �ndern, dann weiter wie bei OK */
                   typ=LUT2_2_NAME_NAME_KURZ;
                   typ1=LUT2_NAME_NAME_KURZ;
@@ -4328,6 +4346,7 @@ DLL_EXPORT int lut_blocks_id(int mode,int *lut_filename,int *lut_blocks_ok,int *
  * ###########################################################################
  */
 
+#line 4909 "ruby/ext/konto_check_raw/konto_check.lxx"
 DLL_EXPORT const char *current_lutfile_name(int *set,int *level,int *retval)
 {
    if(init_status<7 || !current_lutfile){
@@ -4727,7 +4746,6 @@ DLL_EXPORT int lut_pan_i(int b,int zweigstelle,int *retval)
 
 DLL_EXPORT const char *lut_bic(char *b,int zweigstelle,int *retval)
 {
-#if USE_IBAN_RULES
    char blz2[12],kto2[12];
    const char *bic,*bic_neu;
    int ret,regel;
@@ -4752,9 +4770,6 @@ DLL_EXPORT const char *lut_bic(char *b,int zweigstelle,int *retval)
        * Falls der BIC durch die Regel modifiziert wird, wird das nur durch retval angezeigt.
        */
    return bic;
-#else
-   return lut_bic_int(b,zweigstelle,retval);
-#endif
 }
 
 static const char *lut_bic_int(char *b,int zweigstelle,int *retval)
@@ -4815,36 +4830,18 @@ DLL_EXPORT const char *lut_bic_h(char *b,int zweigstelle,int *retval)
     */
 DLL_EXPORT const char *lut_bic_i(int b,int zweigstelle,int *retval)
 {
-#if !USE_IBAN_RULES
-   int idx;
-
-   if(!bic)INVALID_C(LUT2_BIC_NOT_INITIALIZED);
-   if((idx=lut_index_i(b))<0)INVALID_C(idx);
-   CHECK_OFFSET_S;
-   return bic[startidx[idx]+zweigstelle];
-#else
    char b_a[9];
 
    snprintf(b_a,9,"%08d",b);
    return lut_bic(b_a,zweigstelle,retval);
-#endif
 }
 
 DLL_EXPORT const char *lut_bic_hi(int b,int zweigstelle,int *retval)
 {
-#if !USE_IBAN_RULES
-   int idx;
-
-   if(!bic_h)INVALID_C(LUT2_BIC_NOT_INITIALIZED);
-   if((idx=lut_index_i(b))<0)INVALID_C(idx);
-   CHECK_OFFSET_S;
-   return bic_h[startidx[idx]+zweigstelle];
-#else
    char b_a[9];
 
    snprintf(b_a,9,"%08d",b);
    return lut_bic_h(b_a,zweigstelle,retval);
-#endif
 }
 
 /* Funktion lut_nr() +���2 */
@@ -5103,11 +5100,11 @@ static int iban_init(void)
  * ###########################################################################
  */
 
-#if USE_IBAN_RULES
+#line 5663 "ruby/ext/konto_check_raw/konto_check.lxx"
 static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_version,RETVAL *retvals)
 {
    char tmp_buffer[16];
-   int regel,version,b,b_alt,b_neu,k1,k2,k3,not_ok,i,ret,loesch,idx,pz_methode,uk_cnt,tmp;
+   int regel,version,b,b_alt,b_neu,k1,k2,k3,not_ok,i,ret,loesch,idx,pz_methode,tmp;
 
       /* pr�fen, ob bereits initialisiert wurde */
    INITIALIZE_WAIT;
@@ -5123,56 +5120,6 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
    *bicp=NULL;
    ret=OK;
 
-      /* zun�chst einige Sonderf�lle (weggelassene Unterkonten) f�r Regel 0 behandeln;
-       * diese sind auch wichtig, falls die IBAN-Regeln nicht in der LUT-Datei enthalten sind.
-       * Die R�ckgabe differenziert allerdings nicht mehr nach der Art der Unterkonten; diese
-       * werden nur stillschweigend eingef�gt (wie im "SEPA Account Converter").
-       */
-   if(regel==0){  /* in den anderen Regeln wird die Verschiebung bei Bedarf ebenfalls gemacht */
-      if(((ret=kto_check_blz_x(blz,kto,&uk_cnt))<=0))return ret;  /* Fehler bei Regel 0: zur�ckgeben, keine Berechnung */
-      switch(uk_cnt){
-         case 1:
-            ret=OK_UNTERKONTO_ATTACHED;
-            kto[0]=kto[1];
-            kto[1]=kto[2];
-            kto[2]=kto[3];
-            kto[3]=kto[4];
-            kto[4]=kto[5];
-            kto[5]=kto[6];
-            kto[6]=kto[7];
-            kto[7]=kto[8];
-            kto[8]=kto[9];
-            kto[9]='0';
-            break;
-         case 2:
-            ret=OK_UNTERKONTO_ATTACHED;
-            kto[0]=kto[2];
-            kto[1]=kto[3];
-            kto[2]=kto[4];
-            kto[3]=kto[5];
-            kto[4]=kto[6];
-            kto[5]=kto[7];
-            kto[6]=kto[8];
-            kto[7]=kto[9];
-            kto[8]=kto[9]='0';
-            break;
-         case 3:
-            ret=OK_UNTERKONTO_ATTACHED;
-            kto[0]=kto[3];
-            kto[1]=kto[4];
-            kto[2]=kto[5];
-            kto[3]=kto[6];
-            kto[4]=kto[7];
-            kto[5]=kto[8];
-            kto[6]=kto[9];
-            kto[7]=kto[8]=kto[9]='0';
-            break;
-         default:
-            break;
-      }
-   }
-
-
       /* erstmal Konto und BLZ nach Integer umwandeln */
    k1=b2[I kto[0]]+b1[I kto[1]];
    k2=b8[I kto[2]]+b7[I kto[3]]+b6[I kto[4]]+b5[I kto[5]]+b4[I kto[6]]+b3[I kto[7]]+b2[I kto[8]]+b1[I kto[9]];
@@ -8829,8 +8776,8 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
          return IBAN_RULE_UNKNOWN;
    }
 }
-#endif
 
+#line 9340 "ruby/ext/konto_check_raw/konto_check.lxx"
 /* Funktion lut_multiple() +���2 */
 /* ###########################################################################
  * # lut_multiple(): Universalfunktion, um zu einer gegebenen Bankleitzahl   #
@@ -9098,6 +9045,7 @@ DLL_EXPORT int lut_cleanup(void)
    FREE(sort_pz_f);
    FREE(sort_plz);
    FREE(sort_iban_regel);
+#line 9602 "ruby/ext/konto_check_raw/konto_check.lxx"
    if(name_raw && name_data!=name_raw)
       FREE(name_raw);
    else
@@ -9166,6 +9114,7 @@ DLL_EXPORT int lut_cleanup(void)
       lut_cleanup(); /* neuer Versuch, aufzur�umen */
       RETURN(INIT_FATAL_ERROR);
    }
+#line 9676 "ruby/ext/konto_check_raw/konto_check.lxx"
    init_status&=1;
    init_in_progress=0;
    return OK;
@@ -9339,8 +9288,8 @@ static void init_atoi_table(void)
    unsigned long l;
 
 #if 1
-      /* �nderungen zum 9.6.2014 aktivieren */
-   if(time(NULL)>1410127200)pz_aenderungen_aktivieren=1;
+      /* �nderungen zum 07.09.2015 aktivieren */
+   if(time(NULL)>1441576800 ||0)pz_aenderungen_aktivieren_2015_09=1;
 #endif
 
    /* ung�ltige Ziffern; Blanks und Tabs werden ebenfalls als ung�ltig
@@ -9606,6 +9555,7 @@ static void init_atoi_table(void)
    lut_block_name2[126]="2. IBAN Regel idx";
    lut_block_name2[127]="2. BIC Hauptst.idx";
    lut_blocklen_max=453;
+#line 9918 "ruby/ext/konto_check_raw/konto_check.lxx"
    init_status|=1;
 }
 
@@ -9665,6 +9615,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
 
    switch(pz_methode){
 
+#line 9981 "ruby/ext/konto_check_raw/konto_check.lxx"
 /* Berechnungsmethoden 00 bis 09 +���3
    Berechnung nach der Methode 00 +���4 */
 /*
@@ -9975,8 +9926,36 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             retvals->pz_methode=8;
          }
 #endif
-         if(strcmp(kto,"0000060000")<0)  /* Kontonummern unter 60 000: keine Pr�fzifferberechnung oder falsch??? */
-            RETURN(INVALID_KTO);
+
+           /* Kontonummern unter 60 000: keine Pr�fzifferberechnung oder falsch???
+            *
+            * Die Beschreibung in der PDF-Datei sagt nichts dar�ber aus, was mit Kontonummern
+            * unter 60 000 ist. Ich bekam jetzt zwei Emails, bei denen reale Konten in diesem
+            * Bereich existieren; ein kleiner Test mit verschiedenen "Konkurrenzprodukten"
+            * ergibt folgendes Bild:
+            *
+            *    ckonto.de: ok
+            *    ktoblzcheck: ok
+            *    kontonummern.de: ok, ohne Pr�fzifferberechnung
+            *    iban-rechner.de: ok, ohne Pr�fzifferberechnung
+            *    VR-IBAN-Konverter: ok
+            *    SEPA-Account-Konverter (Sparkasse): ok
+            *
+            *    BAV: falsch
+            *    bankleitzahlen.de: Pr�ffehler.
+            *    bankdatencheck.de: nicht g�ltig
+            *
+            * Die Mehrheit der Programme sieht die Konten als richtig an (bzw. ohne
+            * Pr�fzifferberechnung als g�ltig). Daher - und vor allem auch aufgrund der vorhandenen
+            * realen Konten - wird der R�ckgabewert f�r diesen Kontenkreis von INVALID_KTO auf
+            * OK_NO_CHK ge�ndert.
+            *
+            * Markus Malkusch hat nach einer kurzen R�ckfrage auch den BAV umgestellt, da� die Konten
+            * ohne Pr�fung als richtig angesehen werden.
+            */
+
+         if(strcmp(kto,"0000060000")<0)RETURN(OK_NO_CHK);
+
 #ifdef __ALPHA
          pz = ((kto[0]<'5') ? (kto[0]-'0')*2 : (kto[0]-'0')*2-9)
             +  (kto[1]-'0')
@@ -10300,14 +10279,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
                 * zur�ckgegeben.
                 */
                return FALSE;
-#if 0
-                  /* alte Version */
-#if BAV_KOMPATIBEL
-               return BAV_FALSE;
-#else
-               pz=0;
-#endif
-#endif
          }
          CHECK_PZ10;
 
@@ -10861,29 +10832,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             pz=0;
          else
             pz=11-pz;
-         CHECK_PZX8;
-            /* evl. wurde eine Unterkontonummer weggelassen => nur 8-stellige
-             * Kontonummer; neuer Versuch mit den Stellen ab der 3. Stelle
-             */
-         if(kto_len==8){
-            pz = (kto[2]-'0') * 8
-               + (kto[3]-'0') * 7
-               + (kto[4]-'0') * 6
-               + (kto[5]-'0') * 5
-               + (kto[6]-'0') * 4
-               + (kto[7]-'0') * 3
-               + (kto[8]-'0') * 2;
-
-            MOD_11_176;   /* pz%=11 */
-            if(pz<=1)
-               pz=0;
-            else
-               pz=11-pz;
-            CHECK_PZ10;
-         }
-         else
-            return FALSE;
-
+         CHECK_PZ8;
 
 /*  Berechnung nach der Methode 29 +���4 */
 /*
@@ -11105,29 +11054,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             pz=0;
          else
             pz=11-pz;
-         CHECK_PZX8;
-
-            /* evl. wurde eine Unterkontonummer weggelassen => nur 8-stellige
-             * Kontonummer; neuer Versuch mit den Stellen ab der 3. Stelle
-             */
-         if(kto_len==8){
-            pz = (kto[2]-'0') * 7
-               + (kto[3]-'0') * 9
-               + (kto[4]-'0') * 10
-               + (kto[5]-'0') * 5
-               + (kto[6]-'0') * 8
-               + (kto[7]-'0') * 4
-               + (kto[8]-'0') * 2;
-
-            MOD_11_352;   /* pz%=11 */
-            if(pz<=1)
-               pz=0;
-            else
-               pz=11-pz;
-            CHECK_PZ10;
-         }
-         else
-            return FALSE;
+         CHECK_PZ8;
 
 /*  Berechnung nach der Methode 35 +���4 */
 /*
@@ -11545,7 +11472,37 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             pz=0;
          else
             pz=11-pz;
-         CHECK_PZ10;
+         CHECK_PZX10;
+
+            /* Noch ein Sonderfall aus der IBAN-Regel 49 (WGZ-Bank, diese Pr�fziffermethode
+             * wird nur von der Bank verwendet). Bei Konten mit einer '9' an der 5. Stelle
+             * oder 10-stellige Konten die mit '9' beginnen (diese sind schon herumgedreht)
+             * wird die Ausnahme aus IBAN-Regel 49 angewendet:
+             *
+             *    F�r Kontonummern mit einer '9' an der 5. Stelle muss die
+             *    Kontonummer, auf deren Basis die IBAN ermittelt wird, abweichend
+             *    berechnet werden. Die ersten 4 Stellen (inkl. aufgef�llter
+             *    Nullen) m�ssen ans Ende gestellt werden, so dass die Kontonummer
+             *    dann immer mit der '9' anf�ngt.
+             *    
+             *    Beispiel:
+             *    
+             *    Kontonummer alt:	0001991182
+             *    Kontonummer f�r die Berechnung der IBAN:	9911820001
+             *    
+             *    Diese neu ermittelte Kontonummer hat keine Pr�fziffer, die
+             *    daher auch nicht gepr�ft werden darf. Ansonsten kann mit
+             *    dieser Kontonummer die IBAN mit der Standard-IBAN-Regel
+             *    ermittelt werden. 
+             *
+             * Das Verhalten mit der f�hrenden '9' ist nicht in der IBAN-Regel angegeben,
+             * wurde aber aufgrund realer Kontodaten gefunden und durch eine Nachfrage bei
+             * der Bank best�tigt (Vielen Dank an Stefan Banse f�r den Hinweis).
+             */
+         if(*kto=='9' || *(kto+4)=='9')
+            return OK_NO_CHK;
+         else
+            return FALSE;
 
 /*  Berechnung nach der Methode 45 +���4 */
 /*
@@ -11993,6 +11950,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * ######################################################################
  */
 
+#line 11992 "ruby/ext/konto_check_raw/konto_check.lxx"
       case 51:
          if(*(kto+2)=='9'){   /* Ausnahme */
 
@@ -12254,6 +12212,8 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          else
             return FALSE;
 
+#line 12206 "ruby/ext/konto_check_raw/konto_check.lxx"
+#line 12208 "ruby/ext/konto_check_raw/konto_check.lxx"
 /*  Berechnung nach der Methode 53 +���4 */
 /*
  * ######################################################################
@@ -12552,6 +12512,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # bewerten.                                                          #
  * ######################################################################
  */
+#line 12477 "ruby/ext/konto_check_raw/konto_check.lxx"
       case 57:
 #if DEBUG>0
          if(retvals){
@@ -13197,6 +13158,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # Pr�fzifferberechnung)                                              #
  * ######################################################################
  */
+#line 13057 "ruby/ext/konto_check_raw/konto_check.lxx"
       case 66:
 #if DEBUG>0
       case 2066:
@@ -15092,8 +15054,18 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
 /*  Berechnung nach der Methode 87 +���4 */
 /*
  * ######################################################################
- * #          Berechnung nach der Methode 87 (ge�ndert zum 6.9.04)      #
+ * #          Berechnung nach der Methode 87 (ge�ndert zum 7.9.15)      #
  * ######################################################################
+ * #                                                                    #
+ * # Die Kontonummer ist durch linksb�ndige Nullenauff�llung 10-stellig #
+ * # darzustellen. Der zur Pr�fzifferberechnung heranzuziehende Teil    #
+ * # befindet sich bei der Methode A und D in den Stellen 4 bis 9 der   #
+ * # Kontonummer und bei den Methoden B und C in Stellen 5 - 9, die     #
+ * # Pr�fziffer in Stelle 10 der Kontonummer. Ergibt die erste          #
+ * # Berechnung der Pr�fziffer nach der Methode A einen Pr�fziffer-     #
+ * # fehler, so sind weitere Berechnungen mit den anderen Methoden      #
+ * # vorzunehmen.                                                       #
+ * #                                                                    #
  * # Ausnahme:                                                          #
  * # Ist nach linksb�ndiger Auff�llung mit Nullen auf 10 Stellen die    #
  * # 3. Stelle der Kontonummer = 9 (Sachkonten), so erfolgt die         #
@@ -15126,18 +15098,28 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # verbleibende Rest wird vom Divisor (7) subtrahiert. Das            #
  * # Ergebnis ist die Pr�fziffer. Verbleibt nach der Division kein      #
  * # Rest, ist die Pr�fziffer = 0.                                      #
+ * #                                                                    #
+ * # Methode D:                                                         #
+ * # Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7                            #
+ * # Die Stellen 4 bis 9 werden von rechts nach links mit den Ziffern   #
+ * # 2, 3, 4, 5, 6, 7 multipliziert. Die weitere Berechnung und         #
+ * # m�gliche Ergebnisse entsprechen dem Verfahren 06.                  #
  * ######################################################################
  */
 
       case 87:
 
-                /* Ausnahme, Variante 1 */
+                /* Ausnahme, Variante 1
+                 * Die Untermethoden f�r die Sachkonten verschieben sich mit
+                 * der �nderung zum September 2015 (Einf�hrung von Methode D)
+                 * leider auf E und F (statt vorher D und E).
+                 */
          if(*(kto+2)=='9'){   /* Berechnung wie in Verfahren 51 */
 #if DEBUG>0
-      case 4087:
+      case 5087:
          if(retvals){
-            retvals->methode="87d";
-            retvals->pz_methode=4087;
+            retvals->methode="87e";
+            retvals->pz_methode=5087;
          }
 #endif
             pz =         9 * 8
@@ -15157,10 +15139,10 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
 
             /* Ausnahme, Variante 2 */
 #if DEBUG>0
-      case 5087:
+      case 6087:
          if(retvals){
-            retvals->methode="87e";
-            retvals->pz_methode=5087;
+            retvals->methode="87f";
+            retvals->pz_methode=6087;
          }
 #endif
                pz = (kto[0]-'0') * 10
@@ -15326,10 +15308,31 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             retvals->pz_pos=10;
          }
 #endif
-         if(pz==*(kto+9)-'0')
-            return OK;
+         if(pz==*(kto+9)-'0')return OK;
+
+#if DEBUG>0
+      case 4087:
+         if(retvals){
+            retvals->methode="87d";
+            retvals->pz_methode=4087;
+         }
+#endif
+            /* die neue Untermethode wird erst ab 7. September 2015 g�ltig */
+         if(!pz_aenderungen_aktivieren_2015_09)return UNDEFINED_SUBMETHOD;
+
+         pz = (kto[3]-'0') * 7
+            + (kto[4]-'0') * 6
+            + (kto[5]-'0') * 5
+            + (kto[6]-'0') * 4
+            + (kto[7]-'0') * 3
+            + (kto[8]-'0') * 2;
+
+         MOD_11_176;   /* pz%=11 */
+         if(pz<=1)
+            pz=0;
          else
-            return FALSE;
+            pz=11-pz;
+         CHECK_PZ10;
 
 
 /*  Berechnung nach der Methode 88 +���4 */
@@ -15564,8 +15567,8 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # Methode A:                                                         #
  * # Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7                            #
  * # Stellennr.: 1 2 3 4 5 6 7 8 9 A (A = 10)                           #
- * # Kontonr.: x x x K K K K K K P                                      #
- * # Gewichtung: 7 6 5 4 3 2                                            #
+ * # Kontonr.:   x x x K K K K K K P                                    #
+ * # Gewichtung:       7 6 5 4 3 2                                      #
  * #                                                                    #
  * # Die Berechnung und m�gliche Ergebnisse entsprechen dem Verfahren   #
  * # 06.                                                                #
@@ -15573,8 +15576,8 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # Methode B                                                          #
  * # Modulus 11, Gewichtung 2, 3, 4, 5, 6                               #
  * # Stellennr.: 1 2 3 4 5 6 7 8 9 A (A = 10)                           #
- * # Kontonr.: x x x x K K K K K P                                      #
- * # Gewichtung: 6 5 4 3 2                                              #
+ * # Kontonr.:   x x x x K K K K K P                                    #
+ * # Gewichtung:         6 5 4 3 2                                      #
  * #                                                                    #
  * # Die Berechnung und die m�glichen Ergebnisse entsprechen dem        #
  * # Verfahren 06.                                                      #
@@ -15582,8 +15585,8 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # Methode C                                                          #
  * # Modulus 7, Gewichtung 2, 3, 4, 5, 6                                #
  * # Stellennr.: 1 2 3 4 5 6 7 8 9 A (A = 10)                           #
- * # Kontonr.: x x x x K K K K K P                                      #
- * # Gewichtung: 6 5 4 3 2                                              #
+ * # Kontonr.:   x x x x K K K K K P                                    #
+ * # Gewichtung:         6 5 4 3 2                                      #
  * #                                                                    #
  * # Die einzelnen Stellen der Kontonummer sind von rechts nach links   #
  * # mit den Gewichten zu multiplizieren. Die jeweiligen Produkte       #
@@ -15785,30 +15788,16 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
             retvals->pz_methode=7090;
          }
 #endif
-         if(pz_aenderungen_aktivieren){
-            pz = (kto[3]-'0')
-               + (kto[4]-'0') * 2
-               + (kto[5]-'0')
-               + (kto[6]-'0') * 2
-               + (kto[7]-'0')
-               + (kto[8]-'0') * 2;
+         pz = (kto[3]-'0')
+            + (kto[4]-'0') * 2
+            + (kto[5]-'0')
+            + (kto[6]-'0') * 2
+            + (kto[7]-'0')
+            + (kto[8]-'0') * 2;
 
-            MOD_7_56;    /* pz%=7 */
-            if(pz)pz=7-pz;
-            CHECK_PZ10;
-         }
-         else{
-#if DEBUG>0
-            if(!pz_aenderungen_aktivieren){  /* switch-code derzeit noch nicht g�ltig */
-               if(untermethode==7)return UNDEFINED_SUBMETHOD;
-               if(retvals){ /* Methode zur�cksetzen, nicht definiert */
-                  retvals->methode="90e";
-                  retvals->pz_methode=5090;
-               }
-            }
-#endif
-            return FALSE;
-         }
+         MOD_7_56;    /* pz%=7 */
+         if(pz)pz=7-pz;
+         CHECK_PZ10;
 
 /*  Berechnung nach der Methode 91 +���4 */
 /*
@@ -19222,9 +19211,9 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * #       1. Stelle von links   Zahl (Konstante)                       #
  * #        der 10-stelligen                                            #
  * #        Kontonummer                                                 #
- * #                 0                  4363380                         #                                                                                                   #
- * #                 1                  4363381                         #                                                                                           #
- * #                 2                  4363382                         #                                                                                           #
+ * #                 0                  4363380                         #
+ * #                 1                  4363381                         #
+ * #                 2                  4363382                         #
  * #                 3                  4363383                         #
  * #                 4                  4363384                         #
  * #                 5                  4363385                         #
@@ -20220,6 +20209,83 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          if(pz==10)return FALSE;
          CHECK_PZ10;
 
+/* Berechnung nach der Methode E2 +���4 */
+/*
+ * ######################################################################
+ * #               Berechnung nach der Methode E2                       #
+ * ######################################################################
+ * # Modulus 10, Gewichtung 1, 2, 1, 2, 1, 2, 1, 2                      #
+ * #                                                                    #
+ * # Die Kontonummer ist 10-stellig, ggf. ist die Kontonummer f�r die   #
+ * # Pr�fzifferberechnung durch linksb�ndige Auff�llung mit Nullen      #
+ * # 10-stellig darzustellen. Die 10. Stelle der Kontonummer ist die    #
+ * # Pr�fziffer.                                                        #
+ * #                                                                    #
+ * # Kontonummern, die an der 1. Stelle von links der 10-stelligen      #
+ * # Kontonummer den Wert 6, 7, 8 oder 9 beinhalten, sind falsch.       #
+ * #                                                                    #
+ * # Kontonummern, die an der 1. Stelle von links der 10-stelligen      #
+ * # Kontonummer den Wert 0, 1, 2, 3, 4 oder 5 beinhalten, sind wie     #
+ * # folgt zu pr�fen:                                                   #
+ * #                                                                    #
+ * # F�r die Berechnung der Pr�fziffer werden die Stellen 2 bis 9 der   #
+ * # Kontonummer von links verwendet. Diese Stellen sind links um       #
+ * # eine Zahl (Konstante) gem�� der folgenden Tabelle zu erg�nzen.     #
+ * #                                                                    #
+ * #   1. Stelle von links   Zahl (Konstante)                           #
+ * #    der 10-stelligen                                                #
+ * #    Kontonummer                                                     #
+ * #         0               4383200                                    #
+ * #         1               4383201                                    #
+ * #         2               4383202                                    #
+ * #         3               4383203                                    #
+ * #         4               4383204                                    #
+ * #         5               4383205                                    #
+ * #                                                                    #
+ * # Die Berechnung und m�gliche Ergebnisse entsprechen der             #
+ * # Methode 00.                                                        #
+ * ######################################################################
+ * # Anmerkung zur Berechnung (MP): Die Methode entspricht (bis auf     #
+ * # die Konstante und die zugelassenen Anfangsziffern) genau der       #
+ * # Methode D1. die Berechnung ist daher auch analog. Die              #
+ * # zus�tzliche feste Konstante wird im voraus berechnet und als       #
+ * # Initialwert f�r die Quersumme verwendet. Die Berechnung beginnt    #
+ * # allerdings - entgegen der Beschreibung - mit der ersten Stelle     #
+ * # der Kontonummer, da diese in der Konstanten enthalten ist.         #
+ * ######################################################################
+ */
+
+      case 142:
+#if DEBUG>0
+         if(retvals){
+            retvals->methode="E2";
+            retvals->pz_methode=142;
+         }
+#endif
+         if(*kto>'5')return INVALID_KTO;
+         pz=25;
+
+#ifdef __ALPHA
+         pz+= ((kto[0]<'5') ? (kto[0]-'0')*2 : (kto[0]-'0')*2-9)
+            +  (kto[1]-'0')
+            + ((kto[2]<'5') ? (kto[2]-'0')*2 : (kto[2]-'0')*2-9)
+            +  (kto[3]-'0')
+            + ((kto[4]<'5') ? (kto[4]-'0')*2 : (kto[4]-'0')*2-9)
+            +  (kto[5]-'0')
+            + ((kto[6]<'5') ? (kto[6]-'0')*2 : (kto[6]-'0')*2-9)
+            +  (kto[7]-'0')
+            + ((kto[8]<'5') ? (kto[8]-'0')*2 : (kto[8]-'0')*2-9);
+#else
+         pz+=(kto[1]-'0')+(kto[3]-'0')+(kto[5]-'0')+(kto[7]-'0');
+         if(kto[0]<'5')pz+=(kto[0]-'0')*2; else pz+=(kto[0]-'0')*2-9;
+         if(kto[2]<'5')pz+=(kto[2]-'0')*2; else pz+=(kto[2]-'0')*2-9;
+         if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
+         if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
+         if(kto[8]<'5')pz+=(kto[8]-'0')*2; else pz+=(kto[8]-'0')*2-9;
+#endif
+         MOD_10_80;   /* pz%=10 */
+         if(pz)pz=10-pz;
+         CHECK_PZ10;
 
 /* nicht abgedeckte F�lle +���3 */
 /*
@@ -20238,6 +20304,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          return NOT_IMPLEMENTED;
    }
 }
+#line 19060 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 /*
  * ######################################################################
@@ -20335,7 +20402,7 @@ DLL_EXPORT int kto_check_blz(char *blz,char *kto)
 #if DEBUG>0    /* es werden einige Funktionen benutzt, die nur in der Debug-Variante enthalten sind */
 DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,const char **bic,int *regel,RETVAL *retvals)
 {
-#if USE_IBAN_RULES
+#line 19158 "ruby/ext/konto_check_raw/konto_check.lxx"
    char *blz_o,buffer[32],kto_o[16],*blz_n,*kto_n,*ptr,*dptr;
    const char *bicp;
    int ret,ret_regel,r;
@@ -20383,11 +20450,7 @@ DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,con
    }
    else  /* BLZ und Kto gleich */
       return ret;
-#else
-   if(regel)*regel=0;
-   if(retvals)*retvals=NULL;
-   return kto_check_regel(blz,kto);
-#endif
+#line 19206 "ruby/ext/konto_check_raw/konto_check.lxx"
 }
 
 #else   /* !DEBUG */
@@ -20396,7 +20459,6 @@ DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,con
 
 DLL_EXPORT int kto_check_regel(char *blz,char *kto)
 {
-#if USE_IBAN_RULES
    char *blz_o,blz_n[10],kto_o[16],kto_n[16],*ptr,*dptr;
    const char *bicp;
    int ret,ret_regel,regel;
@@ -20424,9 +20486,6 @@ DLL_EXPORT int kto_check_regel(char *blz,char *kto)
    }
    else  /* BLZ und Kto gleich */
       return ret;
-#else
-   return kto_check_blz(blz,kto);
-#endif
 }
 
 /* Funktion kto_check_pz() +���1 */
@@ -20471,288 +20530,6 @@ DLL_EXPORT int kto_check_pz(char *pz,char *kto,char *blz)
 #endif
 }
 
-/* Funktion kto_check_blz_x() +���1 */
-/* ###########################################################################
- * # Die Funktion kto_check_blz_x() ist eine Hilfsfunktion f�r die Funktion  #
- * # iban_gen(). Diese Funktion bestimmt, ob f�r ein angegebenes Konto evl.  #
- * # ein Unterkonto weggelassen wurde (betrifft die Methode 13, 26, 50, 63,  #
- * # 76 und C7; ansonsten entspricht sie der Funktion kto_check_blz().       #
- * #                                                                         #
- * # Parameter:                                                              #
- * #    blz:        Bankleitzahl (immer 8-stellig)                           #
- * #    kto:        Kontonummer                                              #
- * #    uk_cnt:     R�ckgabewert: Anzahl weggelassener Unterkontostellen     #
- * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
- * ###########################################################################
- */
-
-static int kto_check_blz_x(char *blz,char *kto,int *uk_cnt)
-{
-   char *ptr,*dptr,xkto[32];
-   int i,p1=0,kto_len,pz,fuehrende_nullen;
-   int idx,pz_methode,untermethode=0;
-   RETVAL *retvals=NULL;
-
-   if(!blz || !kto)return MISSING_PARAMETER;
-   *uk_cnt=0;
-   if(init_status!=7){
-      if(init_status&24)INITIALIZE_WAIT;
-      if(init_status<7)return LUT2_NOT_INITIALIZED;
-   }
-   if((idx=lut_index(blz))<0)return idx;
-   pz_methode=pz_methoden[idx];
-
-   memset(xkto,'0',12);
-   for(ptr=kto;*ptr=='0' || *ptr==' ' || *ptr=='\t';ptr++);
-   for(kto_len=0;*ptr && *ptr!=' ' && *ptr!='\t';kto_len++,ptr++);
-   dptr=xkto+10;
-   *dptr--=0;
-   if(kto_len<1 || kto_len>10)return INVALID_KTO_LENGTH;
-   for(ptr--,i=kto_len;i-->0;*dptr--= *ptr--);
-   kto=xkto;
-   for(fuehrende_nullen=i=0;i<3;i++)if(kto[i]=='0')fuehrende_nullen++; else break;
-
-   switch(pz_methode){
-      case 13:
-            /* Methode 13a */
-         pz =(kto[1]-'0')+(kto[3]-'0')+(kto[5]-'0');
-         if(kto[2]<'5')pz+=(kto[2]-'0')*2; else pz+=(kto[2]-'0')*2-9;
-         if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
-         if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
-         MOD_10_80;   /* pz%=10 */
-         if(pz)pz=10-pz;
-         CHECK_PZX8;
-         if(fuehrende_nullen<2)return FALSE;   /* Methode 13b nur m�glich, falls 1. und 2. Stelle '0' sind */
-
-            /* Methode 13b: 2-stelliges Unterkonto weggelassen */
-         *uk_cnt=2;
-         pz =(kto[3]-'0')+(kto[5]-'0')+(kto[7]-'0');
-         if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
-         if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
-         if(kto[8]<'5')pz+=(kto[8]-'0')*2; else pz+=(kto[8]-'0')*2-9;
-
-         MOD_10_80;   /* pz%=10 */
-         if(pz)pz=10-pz;
-         CHECK_PZ10;
-
-      case 26:
-         if(fuehrende_nullen>=2){
-               /* Unterkontonummer ausgelassen */
-            *uk_cnt=2;
-            pz = (kto[2]-'0') * 2
-               + (kto[3]-'0') * 7
-               + (kto[4]-'0') * 6
-               + (kto[5]-'0') * 5
-               + (kto[6]-'0') * 4
-               + (kto[7]-'0') * 3
-               + (kto[8]-'0') * 2;
-
-            MOD_11_176;   /* pz%=11 */
-            if(pz<=1)
-               pz=0;
-            else
-               pz=11-pz;
-            CHECK_PZ10;
-         }
-         else{
-            *uk_cnt=-1; /* Unterkonto angegeben */
-            pz = (kto[0]-'0') * 2
-               + (kto[1]-'0') * 7
-               + (kto[2]-'0') * 6
-               + (kto[3]-'0') * 5
-               + (kto[4]-'0') * 4
-               + (kto[5]-'0') * 3
-               + (kto[6]-'0') * 2;
-
-            MOD_11_176;   /* pz%=11 */
-            if(pz<=1)
-               pz=0;
-            else
-               pz=11-pz;
-            CHECK_PZ8;
-         }
-
-      case 50:
-            /* Methode 50a */
-         pz = (kto[0]-'0') * 7
-            + (kto[1]-'0') * 6
-            + (kto[2]-'0') * 5
-            + (kto[3]-'0') * 4
-            + (kto[4]-'0') * 3
-            + (kto[5]-'0') * 2;
-
-         MOD_11_176;   /* pz%=11 */
-         if(pz<=1)
-            pz=0;
-         else
-            pz=11-pz;
-         CHECK_PZX7;
-
-            /* Methode 50b 
-             *
-             * es ist eine reale Kontonummer bekannt, bei der rechts nur eine
-             * Null weggelassen wurde; daher wird die Berechnung f�r die
-             * Methode 50b leicht modifiziert, so da� eine, zwei oder drei
-             * Stellen der Unterkontonummer 000 weggelassen werden k�nnen.
-             */
-         if(kto[0]=='0' && kto[1]=='0' && kto[2]=='0'){
-            *uk_cnt=3;
-            pz = (kto[3]-'0') * 7
-               + (kto[4]-'0') * 6
-               + (kto[5]-'0') * 5
-               + (kto[6]-'0') * 4
-               + (kto[7]-'0') * 3
-               + (kto[8]-'0') * 2;
-
-            MOD_11_176;   /* pz%=11 */
-            if(pz<=1)
-               pz=0;
-            else
-               pz=11-pz;
-            CHECK_PZ10;
-         }
-         else if(kto[0]=='0' && kto[1]=='0' && kto[9]=='0'){
-            *uk_cnt=2;
-            pz = (kto[2]-'0') * 7
-               + (kto[3]-'0') * 6
-               + (kto[4]-'0') * 5
-               + (kto[5]-'0') * 4
-               + (kto[6]-'0') * 3
-               + (kto[7]-'0') * 2;
-
-            MOD_11_176;   /* pz%=11 */
-            if(pz<=1)
-               pz=0;
-            else
-               pz=11-pz;
-            CHECK_PZ9;
-         }
-         else if(kto[0]=='0' && kto[8]=='0' && kto[9]=='0'){
-            *uk_cnt=1;
-            pz = (kto[1]-'0') * 7
-               + (kto[2]-'0') * 6
-               + (kto[3]-'0') * 5
-               + (kto[4]-'0') * 4
-               + (kto[5]-'0') * 3
-               + (kto[6]-'0') * 2;
-
-            MOD_11_176;   /* pz%=11 */
-            if(pz<=1)
-               pz=0;
-            else
-               pz=11-pz;
-            CHECK_PZ8;
-         }
-         return FALSE;
-
-      case 63:
-         if(*kto!='0')return INVALID_KTO;
-         if(*(kto+1)=='0' && *(kto+2)=='0'){ /* wahrscheinlich Unterkonto weggelassen */
-            *uk_cnt=2;
-            pz=(kto[3]-'0')+(kto[5]-'0')+(kto[7]-'0');
-            if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
-            if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
-            if(kto[8]<'5')pz+=(kto[8]-'0')*2; else pz+=(kto[8]-'0')*2-9;
-            MOD_10_80;   /* pz%=10 */
-            if(pz)pz=10-pz;
-            CHECK_PZX10;
-         }
-         pz=(kto[1]-'0')+(kto[3]-'0')+(kto[5]-'0');
-         if(kto[2]<'5')pz+=(kto[2]-'0')*2; else pz+=(kto[2]-'0')*2-9;
-         if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
-         if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
-         MOD_10_80;   /* pz%=10 */
-         if(pz)pz=10-pz;
-         CHECK_PZ8;
-
-      case 76:
-               /* Methode 76a */
-         if((p1= *kto)=='1' || p1=='2' || p1=='3' || p1=='5')return INVALID_KTO;
-         pz = (kto[1]-'0') * 7
-            + (kto[2]-'0') * 6
-            + (kto[3]-'0') * 5
-            + (kto[4]-'0') * 4
-            + (kto[5]-'0') * 3
-            + (kto[6]-'0') * 2;
-
-         MOD_11_176;   /* pz%=11 */
-         CHECK_PZX8;
-
-               /* Methode 76b */
-         if(kto[0]!='0' || kto[1]!='0')return FALSE;
-         if((p1=kto[2])=='1' || p1=='2' || p1=='3' || p1=='5')return INVALID_KTO;
-         *uk_cnt=2;
-         pz = (kto[3]-'0') * 7
-            + (kto[4]-'0') * 6
-            + (kto[5]-'0') * 5
-            + (kto[6]-'0') * 4
-            + (kto[7]-'0') * 3
-            + (kto[8]-'0') * 2;
-
-         MOD_11_176;   /* pz%=11 */
-         if(pz==10)return INVALID_KTO;
-         CHECK_PZ10;
-
-      case 127:
-         if(*kto=='0'){ /* bei Methode 63 sind 10-stellige Kontonummern falsch */
-            if(*(kto+1)=='0' && *(kto+2)=='0'){
-
-               /* Methode C7c */
-
-               /* wahrscheinlich Unterkonto weggelassen; das kommt wohl eher
-                * vor als 7-stellige Nummern (Hinweis T.F.); stimmt auch mit
-                * http://www.kontonummern.de/check.php �berein.
-               */
-               *uk_cnt=2;
-               pz=(kto[3]-'0')+(kto[5]-'0')+(kto[7]-'0');
-               if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
-               if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
-               if(kto[8]<'5')pz+=(kto[8]-'0')*2; else pz+=(kto[8]-'0')*2-9;
-               MOD_10_80;   /* pz%=10 */
-               if(pz)pz=10-pz;
-               CHECK_PZX10;
-               *uk_cnt=0; /* Bedingung nicht erf�llt, Unterkto. zur�cksetzen */
-            }
-               /* Methode C7a */
-            pz=(kto[1]-'0')+(kto[3]-'0')+(kto[5]-'0');
-            if(kto[2]<'5')pz+=(kto[2]-'0')*2; else pz+=(kto[2]-'0')*2-9;
-            if(kto[4]<'5')pz+=(kto[4]-'0')*2; else pz+=(kto[4]-'0')*2-9;
-            if(kto[6]<'5')pz+=(kto[6]-'0')*2; else pz+=(kto[6]-'0')*2-9;
-            MOD_10_80;   /* pz%=10 */
-            if(pz)pz=10-pz;
-            CHECK_PZX8;
-         }
-
-            /* Methode C7b */
-            /* Variante 2 */
-         pz = (kto[0]-'0') * 4
-            + (kto[1]-'0') * 3
-            + (kto[2]-'0') * 2
-            + (kto[3]-'0') * 7
-            + (kto[4]-'0') * 6
-            + (kto[5]-'0') * 5
-            + (kto[6]-'0') * 4
-            + (kto[7]-'0') * 3
-            + (kto[8]-'0') * 2;
-
-         MOD_11_176;   /* pz%=11 */
-         if(pz<=1)
-            pz=0;
-         else
-            pz=11-pz;
-         CHECK_PZ10;
-
-      default:
-         *uk_cnt=-2;
-#if DEBUG>0
-         return kto_check_int(blz,pz_methode,kto,untermethode,NULL);
-#else
-         return kto_check_int(blz,pz_methode,kto);
-#endif
-   }
-}
-
 /* Funktion kto_check_blz_dbg() +���1 */
 /* ###########################################################################
  * # Die Funktion kto_check_blz_dbg() ist die Debug-Version von              #
@@ -20823,6 +20600,7 @@ DLL_EXPORT int kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)
  * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
  * ###########################################################################
  */
+#line 19356 "ruby/ext/konto_check_raw/konto_check.lxx"
 DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals)
 {
    int untermethode,pz_methode;
@@ -21058,6 +20836,7 @@ DLL_EXPORT int get_lut_info2_b(char *lutname,int *version,char **prolog_p,char *
    }
    else
       **user_info_p=0;
+#line 19577 "ruby/ext/konto_check_raw/konto_check.lxx"
    FREE(prolog);
    return OK;
 }
@@ -21193,19 +20972,23 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
          return __DATE__ ", " __TIME__;    /* Compilierdatum und -zeit */
       case 4:                              /* Datum der Pr�fziffermethode */
 #if 1
-         if(pz_aenderungen_aktivieren)
-            return "08.09.2014";
+         if(pz_aenderungen_aktivieren_2015_09)
+            return "07.09.2015";
          else
-            return "09.06.2014 (Aenderungen vom 08.09.2014 enthalten aber noch nicht aktiviert)";
+            return "08.06.2015 (Aenderungen vom 07.09.2015 enthalten aber noch nicht aktiviert)";
 #else
-         return "08.09.2014";
+         return "07.09.2015";
 #endif
       case 5:
-        return "08.09.2014";
+        return "07.09.2015";
       case 6:
-        return "1. September 2014";            /* Klartext-Datum der Bibliotheksversion */
+        return "22. August 2015";            /* Klartext-Datum der Bibliotheksversion */
       case 7:
-        return "final";            /* Versions-Typ der Bibliotheksversion (development, beta, final) */
+        return "final";              /* Versions-Typ der Bibliotheksversion (development, beta, final) */
+      case 8:
+        return "5";             /* Hauptversionszahl */
+      case 9:
+        return "8";             /* Unterversionszahl */
    }
 }
 
@@ -21351,6 +21134,7 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
       default:
          break;
    }
+#line 19814 "ruby/ext/konto_check_raw/konto_check.lxx"
    fputc('\n',out);
    while(--i)fputc('=',out);
    fputc('\n',out);
@@ -21485,10 +21269,7 @@ DLL_EXPORT int rebuild_blzfile(char *inputname,char *outputname,UINT4 set)
       if(ret<=0)RETURN(ret);
    }
    else  /* set-Parameter 1 oder 2: LUT-Datei als Eingabedatei */
-      if(set<0)   /* set darf nur 0, 1 oder 2 sein; 0 wurde schon behandelt */
-         set=1;
-      else if(set>2)
-         set=2;
+      if(set>2)set=2;   /* set darf nur 0, 1 oder 2 sein; 0 wurde schon behandelt, negative Werte gibt es nicht (UINT4 Parameter) */
       if((ret=kto_check_init_p(inputname,9,set,0))<=0)RETURN(ret);
 
    if(!(out=fopen(outputname,"w"))){
@@ -21621,7 +21402,7 @@ DLL_EXPORT const char *iban2bic(char *iban,int *retval,char *blz,char *kto)
        * iban_bic_gen() genommen, ansonsten der aus lut_bic().
        */
    if(retval)*retval=OK;
-   if((j=lut_index(blz2))<=0){
+   if((j=lut_index(blz2))<0){
       if(retval)*retval=j;
       return "";
    }
@@ -21678,6 +21459,7 @@ DLL_EXPORT const char *iban2bic_id(char *iban,int *retval,int *blz,int *kto)
    return iban2bic(iban,retval,b,k);
 }
 
+#line 20139 "ruby/ext/konto_check_raw/konto_check.lxx"
 /* Funktion iban_gen(), iban_bic_gen() und iban_bic_gen1 +���1 */
 /* ###########################################################################
  * # Die Funktion iban_gen generiert aus Bankleitzahl und Kontonummer eine   #
@@ -21812,9 +21594,6 @@ DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,c
    char c,check[128],iban[128],kto_n[16],blz_n[12],*ptr,*dptr;
    const char *bic;
    int j,ret,ret_regel,blz_i,flags,regel;
-#if !USE_IBAN_RULES
-   int uk_cnt=-1;
-#endif
    UINT4 zahl,rest;
 
    if(bicp)*bicp=NULL;
@@ -21845,7 +21624,6 @@ DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,c
    blz_i=b8[I blz[0]]+b7[I blz[1]]+b6[I blz[2]]+b5[I blz[3]]+b4[I blz[4]]+b3[I blz[5]]+b2[I blz[6]]+b1[I blz[7]];
 
       /* BLZ und Kontonummer in eigenen Speicherbereich kopieren, Konto links mit Nullen f�llen */
-#if USE_IBAN_RULES
    for(ptr=blz,dptr=blz_n;(*dptr++=*ptr++););
    for(ptr=kto;*ptr;ptr++);   /* Ende von kto suchen */
    ptr--;
@@ -21886,16 +21664,6 @@ DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,c
       ret_regel=OK;
    }
    if(ret_regel==OK_IBAN_WITHOUT_KC_TEST || ret_regel==OK_KTO_REPLACED_NO_PZ)flags|=1; /* kein Test der Bankverbindung */
-#else
-   ret_regel=OK;
-   if(!(flags&2) && own_iban){
-         /* testen, ob die BLZ in der "Verbotsliste" steht */
-      if(bsearch(&blz_i,own_iban,own_iban_cnt,sizeof(int),cmp_int)){
-         if(retval)*retval=NO_OWN_IBAN_CALCULATION;
-         return NULL;
-      }
-   }
-#endif
 
       /* IBAN-Regel 0000 00: BLZ durch Nachfolge-BLZ ersetzen, falls eine
        * solche existiert. F�r einige Konten wird die BLZ auch in den
@@ -21934,53 +21702,10 @@ DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,c
 
       /* erstmal das Konto testen */
    if(!(flags&1)){  /* Test der Bankverbindung */
-#if USE_IBAN_RULES
       if((ret=kto_check_blz(blz,kto))<=0){   /* Konto fehlerhaft */
          if(retval)*retval=ret;
          return NULL;
       }
-#else
-      if((ret=kto_check_blz_x(blz,kto,&uk_cnt))<=0){  /* Konto fehlerhaft */
-         if(retval)*retval=ret;
-         return NULL;
-      }
-
-         /* bei einigen Methoden (13, 26, 50, 63, 76 und C7) kann u.U. ein
-          * Unterkonto weggelassen worden sein. N�heres dazu in der Funktion
-          * kto_check_blz_x().
-          *
-          * *** (alter Code, mit den IBAN-Regeln ist dieser Kommentar nicht mehr aktuell) ***
-          * Falls dies der Fall war (uk_cnt>0) wird es hier wieder an der
-          * richtigen Stelle eingef�gt; es wird allerdings als Fehler angesehen
-          * (mit dem Fehlercode OK_UNTERKONTO_ATTACHED). Falls ein Unterkonto
-          * m�glich bzw. angegeben ist, ist das normalerweise ein Zeichen daf�r
-          * da� das betreffende Institut einer Selbstberechnung nicht zugestimmt
-          * hat; es wird dann nur eine Warnung ausgegeben (OK_UNTERKONTO_POSSIBLE
-          * bzw. OK_UNTERKONTO_GIVEN), aber diese Werte sind gr��er als 0 und
-          * werden insofern nicht als Fehler gerechnet. Das Ergebnis kann
-          * allerdings u.U. falsch sein und sollte mit Vorsicht benutzt werden.
-          */
-      if(uk_cnt>0){
-         for(ptr=kto,dptr=kto_n;(*dptr=*ptr++);dptr++);
-         *dptr++='0';
-         if(uk_cnt>1)*dptr++='0';
-         if(uk_cnt>2)*dptr++='0';
-         *dptr=0;
-         if((ret=kto_check_blz(blz,kto_n))>0){   /* Unterkonto mu� angeh�ngt werden */
-            kto=kto_n;
-            ret_regel=OK_UNTERKONTO_ATTACHED;
-         }
-      }
-      else if(!uk_cnt){
-         ret_regel=OK_UNTERKONTO_POSSIBLE;
-      }
-      else if(uk_cnt==-1){
-         ret_regel=OK_UNTERKONTO_GIVEN;
-      }
-      else{ /* uk_cnt==-2 */
-         ret_regel=OK;
-      }
-#endif
    }
    else
       if(ret_regel!=OK_IBAN_WITHOUT_KC_TEST && ret_regel!=OK_KTO_REPLACED_NO_PZ)ret_regel=LUT2_KTO_NOT_CHECKED;
@@ -22341,7 +22066,7 @@ DLL_EXPORT int iban_check(char *iban,int *retval)
              * falls nicht, Fehlermeldung/Warnung.
              */
          j=lut_index(blz2);
-         if(j>0){
+         if(j>=0){
             if((ret=iban_init())<OK)return ret;  /* alle notwendigen Blocks kontrollieren, evl. nachladen */
             uk=uk_pz_methoden[pz_methoden[j]];
             nachfolge=nachfolge_blz[startidx[j]];
@@ -22567,6 +22292,7 @@ DLL_EXPORT int ipi_check(char *zweck)
  * # Copyright (C) 2009,2011 Michael Plugge <m.plugge@hs-mannheim.de>        #
  * ###########################################################################
  */
+#line 20972 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 /* Funktion volltext_zeichen() +���2 */
 /* Diese Funktion gibt f�r Zeichen die bei der Volltextsuche g�ltig sind
@@ -23412,6 +23138,7 @@ static int qcmp_bic_h(const void *ap,const void *bp)
       return a-b;
 }
 
+#line 21818 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 /* Funktion qcmp_bic() +���3 */
 static int qcmp_bic(const void *ap,const void *bp)
@@ -23516,6 +23243,7 @@ static int qcmp_iban_regel(const void *ap,const void *bp)
    else 
       return a-b;
 }
+#line 21833 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 /* Funktion init_blzf() +���2
  * Diese Funktion initialisiert das Array mit den Bankleitzahlen f�r alle
@@ -23583,6 +23311,7 @@ DLL_EXPORT int konto_check_idx2blz(int idx,int *zweigstelle,int *retval)
 }
 
 /* Funktion suche_int1() +���2 */
+#line 21901 "ruby/ext/konto_check_raw/konto_check.lxx"
 static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstellen_base,int **blz_base,
       int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int cnt,int such_idx)
 {
@@ -23633,6 +23362,7 @@ static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstell
 }
 
 /* Funktion suche_int2() +���2 */
+#line 21952 "ruby/ext/konto_check_raw/konto_check.lxx"
 static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstellen_base,int **blz_base,
       int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int such_idx,int pz_suche)
 {
@@ -24020,6 +23750,7 @@ DLL_EXPORT int lut_suche(int such_id,char *such_cmd,UINT4 *such_cnt,UINT4 **fili
       if(ret==KEY_NOT_FOUND)key_not_found=1;
    }
    for(s=s1=s2=NULL,typ=SUCHE_STD,ptr=such_cmd;*ptr;ptr++){
+
       if(*ptr=='+'){
          if(typ==SUCHE_STD)
             s=lut_suche_multiple_or(s,&s1,NULL);
@@ -24210,6 +23941,7 @@ static int cmp_suche_sort(const void *ap,const void *bp)
 DLL_EXPORT int lut_suche_sort1(int anzahl,int *blz_base,int *zweigstellen_base,int *idx,int *anzahl_o,int **idx_op,int **cnt_op,int uniq)
 {
    int i,j,last_idx,*idx_a,*cnt_o;
+#line 22532 "ruby/ext/konto_check_raw/konto_check.lxx"
 
    if(idx_op)*idx_op=NULL;
    if(cnt_op)*cnt_op=NULL;
@@ -24291,6 +24023,7 @@ DLL_EXPORT int lut_suche_sort2(int anzahl,int *blz,int *zweigstellen,int *anzahl
    return OK;
 }
 
+#line 22615 "ruby/ext/konto_check_raw/konto_check.lxx"
 /* Funktion lut_suche_volltext() +���2 */
 DLL_EXPORT int lut_suche_volltext(char *such_wort,int *anzahl,int *base_name_idx,char ***base_name,
       int *zweigstellen_anzahl,int **start_idx,int **zweigstellen_base,int **blz_base)
@@ -24420,7 +24153,7 @@ DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int
    return suche_int1(such1,such2,anzahl,start_idx,zweigstellen_base,blz_base,&blz_f,&sort_blz,qcmp_blz,cnt,0);
 }
 
-#line 23085 "konto_check.lxx"
+#line 22765 "ruby/ext/konto_check_raw/konto_check.lxx"
 /* Funktion lut_suche_bic() +���2 */
 DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,
       char ***base_name,int **blz_base)
@@ -24474,6 +24207,7 @@ DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int
 {
    int retval;
 
+
    if(anzahl)*anzahl=0;
    if(such2 && such1>such2)return INVALID_SEARCH_RANGE;
    if((init_status&7)<7)return LUT2_NOT_INITIALIZED;
@@ -24487,6 +24221,7 @@ DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int
 /* Funktion lut_suche_plz() +���2 */
 DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base)
 {
+
    if(anzahl)*anzahl=0;
    if(such2 && such1>such2)return INVALID_SEARCH_RANGE;
    if((init_status&7)<7)return LUT2_NOT_INITIALIZED;
@@ -24499,6 +24234,7 @@ DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int
 /* Funktion lut_suche_regel() +���2 */
 DLL_EXPORT int lut_suche_regel(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base)
 {
+
    if(anzahl)*anzahl=0;
    if(such2 && such1>such2)return INVALID_SEARCH_RANGE;
    if((init_status&7)<7)return LUT2_NOT_INITIALIZED;
@@ -24508,6 +24244,7 @@ DLL_EXPORT int lut_suche_regel(int such1,int such2,int *anzahl,int **start_idx,i
    return suche_int2(such1*100,such2*100+99,anzahl,start_idx,zweigstellen_base,blz_base,&iban_regel,&sort_iban_regel,qcmp_iban_regel,LUT2_IBAN_REGEL_SORT,0);
 }
 
+#line 22798 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 /* Funktion lut_suche_bic_h() +���2 */
 DLL_EXPORT int lut_suche_bic_h(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,
@@ -24893,6 +24630,7 @@ DLL_EXPORT const char *iban_ort(char *iban,int filiale,int*retval)
 {
    return iban_fkt_s(iban,filiale,retval,lut_ort);
 }
+#line 22887 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 static int bic_fkt_c(char *bic1,int mode,int filiale,int *retval,char *base,int error)
 {
@@ -25837,7 +25575,7 @@ static int convert_encoding(char **data,UINT4 *len)
 DLL_EXPORT const char *pz2str(int pz,int *ret)
 {
    if(ret){
-      if(pz%1000>=142)
+      if(pz%1000>=143)
          *ret=NOT_DEFINED;
       else
          *ret=OK;
@@ -25985,6 +25723,7 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
       case 139: return "D9";
       case 140: return "E0";
       case 141: return "E1";
+      case 142: return "E2";
       case 1013: return "13a";
       case 1049: return "49a";
       case 1050: return "50a";
@@ -26165,11 +25904,13 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
       case 5090: return "90e";
       case 5104: return "A4e";
       case 6051: return "51f";
+      case 6087: return "87f";
       case 6090: return "90f";
       case 7090: return "90g";
       default:   return "???";
    }
 }
+#line 23842 "ruby/ext/konto_check_raw/konto_check.lxx"
 
 /* Funktion lut_keine_iban_berechnung() +���1 */
 /*
@@ -26284,7 +26025,7 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
 /* Funktion pz_aenderungen_enable() +���1 */
 /* ###########################################################################
  * # Die Funktion pz_aenderungen_enable() dient dazu, den Status des Flags   #
- * # pz_aenderungen_aktivieren abzufragen bzw. zu setzen. Falls die Variable #
+ * # pz_aenderungen_aktivieren_2015_09 abzufragen bzw. zu setzen. Falls die Variable #
  * # set 1 ist, werden die �nderungen aktiviert, falls sie 0 ist, werden     #
  * # die �nderungen deaktiviert. Bei allen anderen Werten wird das aktuelle  #
  * # Flag nicht ver�ndert, sondern nur der Status zur�ckgegeben.             #
@@ -26300,8 +26041,8 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
 
 DLL_EXPORT int pz_aenderungen_enable(int set)
 {
-   if(set==0 || set==1)pz_aenderungen_aktivieren=set;
-   return pz_aenderungen_aktivieren;
+   if(set==0 || set==1)pz_aenderungen_aktivieren_2015_09=set;
+   return pz_aenderungen_aktivieren_2015_09;
 }
 
 #if DEBUG>0
@@ -26333,6 +26074,7 @@ DLL_EXPORT char *kto_check_test_vars(char *txt,UINT4 i)
 #endif
 
 
+#line 24006 "ruby/ext/konto_check_raw/konto_check.lxx"
 /* Funktionen *_id() +���1 */
 /* ###########################################################################
  * # Die folgenden Funktionen sind die id-Varianten von Funktionen, die      #