konto_check 6.08.0 → 6.15.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-2019 Michael Plugge <m.plugge@hs-mannheim.de>      #
+ * #  Copyright (C) 2002-2023 Michael Plugge <konto_check@yahoo.com>        #
  * #                                                                        #
  * #  Dieses Programm ist freie Software; Sie d�rfen es unter den           #
  * #  Bedingungen der GNU Lesser General Public License, wie von der Free   #
@@ -45,15 +45,14 @@
  * # im Internet herunterladen.                                             #
  * ##########################################################################
  */
-#line 332 "konto_check.lxx"
 
 /* Definitionen und Includes  */
 #ifndef VERSION
-#define VERSION "6.08 (final)"
+#define VERSION "6.15 (final)"
 #define VERSION_MAJOR 6
-#define VERSION_MINOR 08
+#define VERSION_MINOR 15
 #endif
-#define VERSION_DATE "2019-03-19"
+#define VERSION_DATE "2023-04-13"
 
 #ifndef INCLUDE_KONTO_CHECK_DE
 #define INCLUDE_KONTO_CHECK_DE 1
@@ -93,6 +92,7 @@ static lzo_align_t __LZO_MMODEL wrkmem[LZO1X_1_MEM_COMPRESS];
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <unistd.h>
 #if COMPRESS>0
 #include <zlib.h>
 #endif
@@ -104,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 Dezember 2018 zu aktivieren */
-static int pz_aenderungen_aktivieren_2018_12;
+   /* Flag, um die �nderungen zum Dezember 2019 zu aktivieren */
+static int pz_aenderungen_aktivieren_2019_12;
 
    /* falls die Variable verbose_debug gesetzt wird, werden bei einigen
     * Funktionen mittels perror() zus�tzliche Debuginfos ausgegeben. Die
@@ -207,8 +207,8 @@ static char **sortc_buf;
 static int *sorti_buf;
 
    /* Variablen f�r das SCL-Verzeichnis */
-static char *scl_info_block,*scl_bic_block,*scl_name_block,*scl_flags_block,
-            **scl_bic_array,**scl_name_array,**scl_flags_array,
+static char *scl_info_block,*scl_bic_block,*scl_name_block,*scl_flags_block,*scl_flags_block_orig,
+            **scl_bic_array,**scl_name_array,**scl_flags_array,**scl_flags_array_o,
             scl_gueltigkeit[16],scl_gueltigkeit_iso[16];
 static int scl_cnt;
 long scl_ts;
@@ -217,6 +217,7 @@ long scl_ts;
 DLL_EXPORT const char *(*retval_enc)(int)=NULL;
 
 static int convert_encoding(char **data,UINT4 *len);
+static int scl_idx(const char *bic,int *retval,int *raw);
 
 
 /* das Makro RETURN(r) gibt Debug-Meldungen zu Fehler-R�ckgabewerten (zur Fehlersuche) */
@@ -249,7 +250,6 @@ static int convert_encoding(char **data,UINT4 *len);
 #define free(ptr) efree(ptr)
 #endif
 
-#line 777 "konto_check.lxx"
 
    /* Testwert zur Markierung ung�ltiger Ziffern im BLZ-String (>8 Stellen) */
 #define BLZ_FEHLER 100000000
@@ -385,7 +385,6 @@ 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 918 "konto_check.lxx"
 
    /* einige Makros zur Umwandlung zwischen unsigned int und char */
 #define UCP  (unsigned char*)
@@ -505,7 +504,6 @@ int pz=-777;
 
 #define E_START(x)
 #define E_END(x)
-#line 1043 "konto_check.lxx"
 
    /* Variable f�r die Methoden 27, 29 und 69 */
 static const int m10h_digits[4][10]={
@@ -812,7 +810,7 @@ static UINT4 adler32a(UINT4 adler,const char *buf,unsigned int len)
  * # was einen Sortierlauf vor der Generierung der Tabelle bedingt.          #
  * # Die Funktion wird von qsort() (aus der libc) aufgerufen.                #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -839,7 +837,7 @@ static int sort_cmp(const void *ap,const void *bp)
  * # Diese Funktion dient als Vergleichsfunktion f�r zwei Integerwerte f�r   #
  * # die Quicksort-Bibliotheksfunktion.                                      #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -892,7 +890,7 @@ DLL_EXPORT int set_default_compression(int mode)
  * # Funktion create_lutfile_int() (ohne den FILE-Pointer). Die generierte   #
  * # Datei wird nach dem Aufruf geschlossen.                                 #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -913,7 +911,7 @@ DLL_EXPORT int create_lutfile(char *filename, char *prolog, int slots)
  * # des Inhaltsverzeichnisses mit 0-Bytes. Diese Datei kann dann mit der    #
  * # Funktion write_lut_block() (bzw. write_lut_block_int()) gef�llt werden. #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -950,11 +948,10 @@ static int create_lutfile_int(char *name, char *prolog, int slots,FILE **lut)
  * # einige grundlegende Tests gemacht, um sicherzustellen, da� es sich auch #
  * # um eine LUT2-Datei handelt (hier und sp�ter in write_block_int()).      #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
-#line 1492 "konto_check.lxx"
 DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
 {
    char buffer[SLOT_BUFFER],*ptr;
@@ -988,11 +985,10 @@ DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
  * # meldung LUT2_NO_SLOT_FREE zur�ckgegeben, aber nichts geschrieben.         #
  * # Vor dem Schreiben wird der Block mittels der ZLIB komprimiert.            #
  * #                                                                           #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>               #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>                 #
  * #############################################################################
  */
 
-#line 1530 "konto_check.lxx"
 static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
 {
    char buffer[SLOT_BUFFER],*ptr,*cptr;
@@ -1124,11 +1120,10 @@ static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
  * # mehrere Blocks des angegebenen Typs enthalten sind, wird der letze      #
  * # zur�ckgeliefert.                                                        #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
-#line 1666 "konto_check.lxx"
 DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **data)
 {
    int retval;
@@ -1147,11 +1142,10 @@ DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **da
  * # Blocks eines bestimmeten Typs enthalten sind, auch alte Blocks gelesen  #
  * # werden.                                                                 #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
-#line 1690 "konto_check.lxx"
 DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
 {
    int retval;
@@ -1169,11 +1163,10 @@ DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
  * # lesen; sie wird von vielen internen Funktionen benutzt. Die LUT-Datei   #
  * # wird als FILE-Pointer �bergeben und nicht geschlossen.                  #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
-#line 1713 "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;
@@ -1263,7 +1256,6 @@ static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **
             FREE(sbuffer);
             RETURN(ERROR_MALLOC);
          }
-#line 1818 "konto_check.lxx"
 
          if(fread(sbuffer,1,compressed_len,lut)<compressed_len){
             FREE(sbuffer);
@@ -1428,7 +1420,7 @@ static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **
  * # gegeben. Falls eine Variable nicht ben�tigt wird, kann f�r sie auch       #
  * # NULL �bergeben werden; die entsprechende Variable wird dann ignoriert.    #
  * #                                                                           #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>               #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>                 #
  * #############################################################################
  */
 
@@ -1597,7 +1589,7 @@ static int lut_dir(FILE *lut,int id,UINT4 *slot_cnt,UINT4 *typ,UINT4 *len,
  * # dieser Buffer wird dann mittels der Funktion write_lut_block_int()      #
  * # komprimiert und in die LUT-Datei geschrieben.                           #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -2169,7 +2161,7 @@ static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char
  * # generate_lut2(), aber die Funktionalit�t reicht in der Praxis normaler- #
  * # weise gut aus.                                                          #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -2221,7 +2213,7 @@ DLL_EXPORT int generate_lut2_p(char *inputname,char *outputname,char *user_info,
  * # f�r einige Pr�fziffermethoden (52, 53, B6) ben�tigt werden (sie sind in #
  * # den Beispielen enthalten, haben aber keine reale Entsprechung).         #
  * #                                                                         #
- * # Copyright (C) 2007, 2013 Michael Plugge <m.plugge@hs-mannheim.de>       #
+ * # Copyright (C) 2007, 2013 Michael Plugge <konto_check@yahoo.com>         #
  * ###########################################################################
  */
 
@@ -2601,7 +2593,7 @@ fini:
  * # Die Funktion lut_dir_dump_str() allokiert f�r die Ausgabe Speicher;     #
  * # dieser mu� von dre aufrufenden Funktion wieder freigegeben werden.      #
  * #                                                                         #
- * # Copyright (C) 2007-2010 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2007-2010 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -2711,7 +2703,7 @@ DLL_EXPORT int lut_dir_dump_str(char *lutname,char **dptr)
  * #    LUT2_NO_VALID_DATE:     Der Datenblock enth�lt kein G�ltigkeitsdatum #
  * #    LUT2_NOT_INITIALIZED:   die library wurde noch nicht initialisiert   #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_valid(void)
@@ -2742,6 +2734,38 @@ DLL_EXPORT int lut_valid(void)
       RETURN(LUT2_NO_LONGER_VALID);
 }
 
+DLL_EXPORT int lut_valid_date(char *lut_name,int *v11,int *v12,int *v21,int *v22)
+{
+   char *ptr,*info1,*info2;
+   int retval,v1,v2;
+
+   *v11=*v12=*v21=*v22=0;
+   if((retval=lut_info(lut_name,&info1,&info2,&v1,&v2))!=OK)return retval;
+   if(info1){
+      for(ptr=info1;*ptr && *ptr!='\n' && !isdigit(*ptr);ptr++);
+      if(*ptr && *ptr!='\n'){
+         *v11=strtoul(ptr,NULL,10);             /* Anfangsdatum der G�ltigkeit */
+         if(*ptr && *ptr!='\n'){
+            while(*ptr && *ptr!='\n' && *ptr++!='-'); /* Endedatum suchen */
+            if(*ptr)*v12=strtoul(ptr,NULL,10);  /* Endedatum der G�ltigkeit */
+         }
+      }
+      free(info1);
+   }
+   if(info2){
+      for(ptr=info2;*ptr && *ptr!='\n' && !isdigit(*ptr);ptr++);
+      if(*ptr && *ptr!='\n'){
+         *v21=strtoul(ptr,NULL,10);             /* Anfangsdatum der G�ltigkeit */
+         if(*ptr && *ptr!='\n'){
+            while(*ptr && *ptr!='\n' && *ptr++!='-'); /* Endedatum suchen */
+            if(*ptr)*v22=strtoul(ptr,NULL,10);  /* Endedatum der G�ltigkeit */
+         }
+      }
+      free(info2);
+   }
+   return OK;
+}
+
 
 /* Funktion lut_info_b() +���1 */
 /* ###########################################################################
@@ -2751,7 +2775,7 @@ DLL_EXPORT int lut_valid(void)
  * # und info2; danach wird der Speicher der von lut_info() allokiert wurde, #
  * # wieder freigegeben.                                                     #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -2784,7 +2808,7 @@ DLL_EXPORT int lut_info_b(char *lut_name,char **info1,char **info2,int *valid1,i
  * # mittels der Funktion kc_id2ptr() in einen String umgewandelt, sowie mit #
  * # der Funktion kc_id_free() wieder freigegeben werden kann.               #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -2852,11 +2876,10 @@ DLL_EXPORT int lut_info_id(char *lut_name,int *info1,int *info2,int *valid1,int
  * #    LUT2_NO_VALID_DATE:     Der Datenblock enth�lt kein G�ltigkeitsdatum #
  * #    LUT2_BLOCK_NOT_IN_FILE: Die LUT-Datei enth�lt den Infoblock nicht    #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
-#line 3411 "konto_check.lxx"
 DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)
 {
    char *ptr,*ptr1,buffer[128];
@@ -2944,7 +2967,6 @@ 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 3500 "konto_check.lxx"
       *(ptr+cnt)=0;
       if(valid1){
          for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
@@ -2992,7 +3014,6 @@ 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 3549 "konto_check.lxx"
       *(ptr+cnt)=0;
       if(valid2){
          for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
@@ -3070,7 +3091,7 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
  * #    info_p:    Variablenpointer f�r R�ckgabe des Info-Strings            #
  * #    user_info_p: Variablenpointer f�r R�ckgabe des User-Info-Strings     #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -3181,7 +3202,7 @@ DLL_EXPORT int get_lut_info2(char *lut_name,int *version_p,char **prolog_p,char
  * # Au�erdem kann die Anzahl Slots ver�ndert (vergr��ert oder verkleinert)  #
  * # werden.                                                                 #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -3211,7 +3232,6 @@ 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 3769 "konto_check.lxx"
       write_lut_block_int(lut2,typ,len,data);
       FREE(data);
       last_slot=typ;
@@ -3229,7 +3249,7 @@ DLL_EXPORT int copy_lutfile(char *old_name,char *new_name,int new_slots)
  * # Sets geladen. Der R�ckgabewert ist daher oft -38 (nicht alle Blocks     #
  * # geladen), da die LUT-Datei nicht unbedingt alle Blocks enth�lt :-).     #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -3247,7 +3267,7 @@ DLL_EXPORT int kto_check_init2(char *lut_name)
  * # unterschiedlichen Blocks definiert (lut_set_0 ... lut_set_9), die �ber  #
  * # einen skalaren Parameter ausgew�hlt werden k�nnen.                      #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -3287,7 +3307,7 @@ DLL_EXPORT int kto_check_init_p(char *lut_name,int required,int set,int incremen
  * # testen, ob ein bestimmter Block initialisiert wurde, und welcher        #
  * # R�ckgabewert dabei auftrat.                                             #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -3309,7 +3329,7 @@ DLL_EXPORT int *lut2_status(void)
  * # Der Parameter id sollte auf einen Speicherbereich von mindestens 33 Byte#
  * # zeigen. Die Datei-ID wird in diesen Speicher geschrieben.               #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -3407,7 +3427,7 @@ DLL_EXPORT int get_lut_id(char *lut_name,int set,char *id)
  * # inkrementelle Initialisierung, um noch ben�tigte Blocks nachzuladen.    #
  * # Falls schon alle gew�nschten Blocks geladen sind, wird nichts gemacht.  #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -3438,10 +3458,9 @@ DLL_EXPORT int lut_init(char *lut_name,int required,int set)
  * # Probleme; daher gibt es noch einige andere Initialisierungsfunktionen   #
  * # mit einfacherem Aufrufinterface, wie lut_init() oder kto_check_init_p().#
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
-#line 3999 "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];
@@ -3669,7 +3688,6 @@ 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 4228 "konto_check.lxx"
 
       switch(retval){
          case LUT_CRC_ERROR:
@@ -3757,7 +3775,6 @@ 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 4320 "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;
@@ -4254,7 +4271,7 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
  * #   LUT2_BLOCKS_MISSING   bei einigen Blocks traten Fehler auf             #
  * #   OK                    alle Blocks erfolgreich geladen                  #
  * #                                                                          #
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>              #
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com>                #
  * ############################################################################
  */
 DLL_EXPORT int lut_blocks(int mode,char **lut_filename,char **lut_blocks_ok,char **lut_blocks_fehler)
@@ -4328,7 +4345,7 @@ DLL_EXPORT int lut_blocks(int mode,char **lut_filename,char **lut_blocks_ok,char
  * # Variablen lut_filename, lut_blocks_ok und lut_blocks_fehler m�ssen immer #
  * # angegeben werden; eine �bergabe von NULL f�hrt zu einer access violation.#
  * #                                                                          #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>              #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                #
  * ############################################################################
  */
 DLL_EXPORT int lut_blocks_id(int mode,int *lut_filename,int *lut_blocks_ok,int *lut_blocks_fehler)
@@ -4359,11 +4376,10 @@ DLL_EXPORT int lut_blocks_id(int mode,int *lut_filename,int *lut_blocks_ok,int *
  * # benutzt, ist aber auch als Info interessant, falls f�r die LUT-Datei    # 
  * # die Default-Werte benutzt wurden (Pfad und Dateiname).                  #
  * #                                                                         #
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
-#line 4926 "konto_check.lxx"
 DLL_EXPORT const char *current_lutfile_name(int *set,int *level,int *retval)
 {
    if(init_status<7 || !current_lutfile){
@@ -4382,7 +4398,7 @@ DLL_EXPORT const char *current_lutfile_name(int *set,int *level,int *retval)
 /* ###########################################################################
  * # lut_index(): Index einer BLZ in den internen Arrays bestimmen           #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4431,7 +4447,7 @@ static int lut_index(char *b)
  * #                Diese Funktion ist nicht so optimiert wie lut_index(),   #
  * #                da sie nicht in zeitkritischen Routinen benutzt wird.    #
  * #                                                                         #
- * # Copyright (C) 2009 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2009 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4500,7 +4516,7 @@ static int lut_index_i(int b)
  * #               wird. Falls f�r retval NULL �bergeben wird, wird der      #
  * #               R�ckgabewert verworfen.                                   #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4511,7 +4527,7 @@ static int lut_index_i(int b)
  * # Diese Funktion testet, ob eine BLZ (und Zweigstelle, falls gew�nscht)   #
  * # existiert und g�ltig ist.                                               #
  * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4542,7 +4558,7 @@ DLL_EXPORT int lut_blz_i(int b,int zweigstelle)
  * # lut_filialen(): Anzahl der Filialen zu einer gegebenen Bankleitzahl     #
  * # bestimmen.                                                              #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4570,7 +4586,7 @@ DLL_EXPORT int lut_filialen_i(int b,int *retval)
 /* ###########################################################################
  * # lut_name(): Banknamen (lange Form) bestimmen                            #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4605,7 +4621,7 @@ DLL_EXPORT const char *lut_name_i(int b,int zweigstelle,int *retval)
  * # der deutschen Kreditwirtschaft ist die L�nge der Angaben f�r die        #
  * # Bezeichnung des Kreditinstituts begrenzt.                               #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4633,7 +4649,7 @@ DLL_EXPORT const char *lut_name_kurz_i(int b,int zweigstelle,int *retval)
 /* ###########################################################################
  * # lut_plz(): Postleitzahl bestimmen                                       #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4661,7 +4677,7 @@ DLL_EXPORT int lut_plz_i(int b,int zweigstelle,int *retval)
 /* ###########################################################################
  * # lut_ort(): Sitz einer Bank bestimmen                                    #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4701,7 +4717,7 @@ DLL_EXPORT const char *lut_ort_i(int b,int zweigstelle,int *retval)
  * # den Stellen der Deutschen Bundesbank stets die Institutsgruppennummer   #
  * # 2 zugewiesen worden.                                                    #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4757,7 +4773,7 @@ DLL_EXPORT int lut_pan_i(int b,int zweigstelle,int *retval)
  * # korrekte Wert l��t sich in diesem Fall durch die Funktion iban_bic_gen()#
  * # ermitteln.                                                              #
  * #                                                                         #
- * # Copyright (C) 2007,2013 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2007,2013 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -4869,7 +4885,7 @@ DLL_EXPORT const char *lut_bic_hi(int b,int zweigstelle,int *retval)
  * # automatisiert eine eindeutige Nummer vergeben. Eine einmal verwendete   #
  * # Nummer wird nicht noch einmal vergeben.                                 #
  * #                                                                         #
- * # Copyright (C) 2009 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2009 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4898,7 +4914,7 @@ DLL_EXPORT int lut_nr_i(int b,int zweigstelle,int *retval)
  * # lut_pz(): Pr�fzifferverfahren f�r eine Bankleitzahl. Das Verfahren wird #
  * # numerisch zur�ckgegeben, also z.B. 108 f�r die Methode A8.              #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4931,7 +4947,7 @@ DLL_EXPORT int lut_pz_i(int b,int zweigstelle,int *retval)
  * # G�ltigkeitstermin der Bankleitzahlendatei im Zahlungsverkehr nicht mehr #
  * # zu verwenden.                                                           #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -4971,7 +4987,7 @@ DLL_EXPORT int lut_aenderung_i(int b,int zweigstelle,int *retval)
  * # Das Feld enth�lt das Merkmal 0 (keine Angabe) oder 1 (BLZ im Feld 1     #
  * # ist zur L�schung vorgesehen). Die R�ckgabe erfolgt als ASCII '0' '1'.   #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -5004,7 +5020,7 @@ DLL_EXPORT int lut_loeschung_i(int b,int zweigstelle,int *retval)
  * # wurde (lut_loeschung()==1) oder die Bankleitzahl zum aktuellen G�ltig-  #
  * # keitstermin gel�scht wird (lut_aenderung()=='D').                       #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -5038,7 +5054,7 @@ DLL_EXPORT int lut_nachfolge_blz_i(int b,int zweigstelle,int *retval)
  * # aus einer vierstelligen Nummer und einer zweistelligen Versionszahl;    #
  * # sie wird in konto_check als eine sechsstellige Nummer dargestellt.      #
  * #                                                                         #
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -5073,7 +5089,7 @@ DLL_EXPORT int lut_iban_regel_i(int b,int zweigstelle,int *retval)
  * # Berechnung notwendig sind, schon geladen wurden; falls nicht, werden    #
  * # die fehlenden Daten (per inkrementeller Initialisierung) nachgeladen.   #
  * #                                                                         #
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -5114,11 +5130,10 @@ static int iban_init(void)
  * # Der R�ckgabewert gibt n�here Aufschl�sse �ber die Anwendung der Regeln  #
  * # und ob eine IBAN berechnet werden darf.                                 #
  * #                                                                         #
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
-#line 5681 "konto_check.lxx"
 static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_version,RETVAL *retvals)
 {
    char tmp_buffer[16];
@@ -5219,7 +5234,8 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
              * IBAN-Regel 5 auf S. 14); alle anderen BLZs der Commerzbank
              * bekommen COBADEFFXXX.
              */
-         if(blz[3]=='4' && strcasecmp(lut_name(blz,0,NULL),"comdirect bank"))*bicp="COBADEFFXXX";
+//         if(blz[3]=='4' && strcasecmp(lut_name(blz,0,NULL),"comdirect bank"))*bicp="COBADEFFXXX";
+         if(blz[3]=='4' && blz[4]!='1')*bicp="COBADEFFXXX"; /* comdirect Bank */
 
             /* BLZs ohne Pr�fzifferberechnung */
          if(pz_methode==9)return OK_NO_CHK;
@@ -5961,9 +5977,9 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
          return OK_BLZ_REPLACED;
 
 
-         /* Iban-Regel 0020.01 +���3 */
+         /* Iban-Regel 0020.02 +���3 */
          /* Deutsche Bank AG
-          * Neuimplementierung nach der Regel-Version 1.5 der Deutschen Bank vom 30.8.2013
+          * Neuimplementierung nach der Regel-Version 1.51 der Deutschen Bank vom 19.9.2013
           */
       case 20:
 
@@ -8058,21 +8074,29 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
          *bicp="VONEDE33XXX";
          return OK_BLZ_REPLACED;
 
-         /* Iban-Regel 0049.00 +���3 */
-           /* WGZ Bank */
+         /* Iban-Regel 0049.01 +���3 */
+           /* DZ Bank */
       case 49:
 
-            /* Sonderkonten */
-         if(k1==0)switch(k2){
-            case 36:   strcpy(kto,"0002310113"); RETURN_OK_KTO_REPLACED;
-            case 936:  strcpy(kto,"0002310113"); RETURN_OK_KTO_REPLACED;
-            case 999:  strcpy(kto,"0001310113"); RETURN_OK_KTO_REPLACED;
-            case 6060: strcpy(kto,"0000160602"); RETURN_OK_KTO_REPLACED;
-            default: break;
-         }
+            /* Bei der Ermittlung von IBAN und BIC aus Kontonummer und BLZ sind in Abwei-
+             * chung zu der Standard IBAN-Regel folgende Besonderheiten zu beachten:
+             *
+             * 1. F�r die Bankleitzahlen 300 600 10, 400 600 00 und 570 600 00 der DZ BANK ist die
+             * IBAN-Ermittlung f�r Kontonummern mit der 1.-2. Stelle ungleich '92-99' (standardm��ig
+             * links mit Nullen auf 10 Stellen aufgef�llt) mit der Standard-IBAN-Regel m�glich.
+             *
+             * 2. Kontonummern mit einer '92-99' an der 1.-2. Stelle haben keine Pr�fziffer, die daher
+             * nicht gepr�ft werden darf. Auch f�r diese Konten kann die IBAN nach der Standard-
+             * IBAN-Regel ermittelt werden.
+             *
+             * [etwas vereinfacht ausgedr�ckt, k�nnen Konten einfach nach der Standard-Regel konvertiert werden :-) ]
+             */
 
-            /* F�r Kontonummern mit einer '9' an der 5. Stelle muss die Kontonummer, auf deren Ba-
-             * sis die IBAN ermittelt wird, abweichend berechnet werden. Die ersten 4 Stellen (inkl.
+            /* (der folgende Teil wurde nicht gel�scht, da er auch aus realen Kontodaten stammt;
+             * die ehemaligen Sonderkonten tauchen nicht mehr auf und wurden entfernt)
+             *
+             * 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.
              *
@@ -8279,7 +8303,6 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
    }
 }
 
-#line 8842 "konto_check.lxx"
 /* Funktion lut_multiple() +���2 */
 /* ###########################################################################
  * # lut_multiple(): Universalfunktion, um zu einer gegebenen Bankleitzahl   #
@@ -8296,7 +8319,7 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
  * # mit den Indizes der Hauptstellen wird in der letzten Variable zur�ck-   #
  * # gegeben (start_idx).                                                    #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -8507,7 +8530,7 @@ static int lut_multiple_int(int idx,int *cnt,int **p_blz,char  ***p_name,char **
  * # Die Funktion lut_cleanup() gibt allen belegten Speicher frei und setzt  #
  * # die entsprechenden Variablen auf NULL.                                  #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -8547,7 +8570,6 @@ DLL_EXPORT int lut_cleanup(void)
    FREE(sort_pz_f);
    FREE(sort_plz);
    FREE(sort_iban_regel);
-#line 9104 "konto_check.lxx"
    if(name_raw && name_data!=name_raw)
       FREE(name_raw);
    else
@@ -8624,7 +8646,6 @@ DLL_EXPORT int lut_cleanup(void)
       lut_cleanup(); /* neuer Versuch, aufzur�umen */
       RETURN(INIT_FATAL_ERROR);
    }
-#line 9186 "konto_check.lxx"
    init_status&=1;
    init_in_progress=0;
    return OK;
@@ -8648,7 +8669,7 @@ DLL_EXPORT int lut_cleanup(void)
  * #      Pr�fziffermethoden; das Problem wird mit dem neuen Dateiformat     #
  * #      noch einmal angegangen.                                            #
  * #                                                                         #
- * # Copyright (C) 2002-2005 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2002-2005 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -8670,7 +8691,7 @@ DLL_EXPORT int generate_lut(char *inputname,char *outputname,char *user_info,int
  * #                                                                         #
  * # Bugs: f�r eine BLZ wird nur eine Pr�fziffermethode unterst�tzt (s.o.).  #
  * #                                                                         #
- * # Copyright (C) 2002-2005 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2002-2005 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -8788,7 +8809,7 @@ static int read_lut(char *filename,int *cnt_blz)
  * # zur�ckf�hren, was wesentlich schneller ist, als die sonst n�tigen acht  #
  * # Multiplikationen mit dem jeweiligen Stellenwert.                        #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -8797,8 +8818,8 @@ static void init_atoi_table(void)
    int i,ziffer;
    unsigned long l;
 
-      /* �nderungen zum 03.12.2018 aktivieren */
-   if(time(NULL)>1543791600 ||0)pz_aenderungen_aktivieren_2018_12=1;
+      /* �nderungen zum 09.12.2019 aktivieren */
+   if(time(NULL)>1575846000 ||0)pz_aenderungen_aktivieren_2019_12=1;
 
    /* ung�ltige Ziffern; Blanks und Tabs werden ebenfalls als ung�ltig
     * angesehen(!), da die Stellenzuordnung sonst nicht mehr stimmt. Ausnahme:
@@ -8932,6 +8953,8 @@ static void init_atoi_table(void)
    lut2_feld_namen[LUT2_2_SCL_NAME]="LUT2_2_SCL_NAME";
    lut2_feld_namen[LUT2_SCL_FLAGS]="LUT2_SCL_FLAGS";
    lut2_feld_namen[LUT2_2_SCL_FLAGS]="LUT2_2_SCL_FLAGS";
+   lut2_feld_namen[LUT2_SCL_FLAGS_ORIG]="LUT2_SCL_FLAGS_ORIG";
+   lut2_feld_namen[LUT2_2_SCL_FLAGS_ORIG]="LUT2_2_SCL_FLAGS_ORIG";
 
    lut_block_idx[1]=0;
    lut_block_idx[2]=0;
@@ -8964,6 +8987,7 @@ static void init_atoi_table(void)
    lut_block_idx[29]=-1;
    lut_block_idx[30]=-1;
    lut_block_idx[31]=-1;
+   lut_block_idx[32]=-1;
 
    lut_block_name1[1]="BLZ";
    lut_block_name1[2]="FILIALEN";
@@ -8996,6 +9020,7 @@ static void init_atoi_table(void)
    lut_block_name1[29]="SCL_BIC";
    lut_block_name1[30]="SCL_NAME";
    lut_block_name1[31]="SCL_FLAGS";
+   lut_block_name1[32]="SCL_FLAGS_ORIG";
    lut_block_name1[101]="BLZ (2)";
    lut_block_name1[102]="FILIALEN (2)";
    lut_block_name1[103]="NAME (2)";
@@ -9027,6 +9052,7 @@ static void init_atoi_table(void)
    lut_block_name1[129]="SCL_BIC (2)";
    lut_block_name1[130]="SCL_NAME (2)";
    lut_block_name1[131]="SCL_FLAGS (2)";
+   lut_block_name1[132]="SCL_FLAGS_ORIG (2)";
 
    lut_block_name2[1]="1. BLZ";
    lut_block_name2[2]="1. Anzahl Fil.";
@@ -9059,6 +9085,7 @@ static void init_atoi_table(void)
    lut_block_name2[29]="1. SCL BIC";
    lut_block_name2[30]="1. SCL Banknamen";
    lut_block_name2[31]="1. SCL Flags";
+   lut_block_name2[32]="1. SCL Flags orig";
    lut_block_name2[101]="2. BLZ";
    lut_block_name2[102]="2. Anzahl Fil.";
    lut_block_name2[103]="2. Name";
@@ -9090,8 +9117,8 @@ static void init_atoi_table(void)
    lut_block_name2[129]="2. SCL BIC";
    lut_block_name2[130]="2. SCL Banknamen";
    lut_block_name2[131]="2. SCL Flags";
-   lut_blocklen_max=521;
-#line 9426 "konto_check.lxx"
+   lut_block_name2[132]="2. SCL Flags orig";
+   lut_blocklen_max=544;
    init_status|=1;
 }
 
@@ -9115,7 +9142,7 @@ static void init_atoi_table(void)
  * #    retvals:      Struktur, um Pr�fziffermethode und Pr�fziffer in einer #
  * #                  threadfesten Version zur�ckzugeben                     #
  * #                                                                         #
- * # Copyright (C) 2002-2009 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2002-2009 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -9151,7 +9178,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
 
    switch(pz_methode){
 
-#line 9489 "konto_check.lxx"
 /* Berechnungsmethoden 00 bis 09 +���3
    Berechnung nach der Methode 00 +���4 */
 /*
@@ -10988,6 +11014,10 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # Stellennr.:    1 2 3 4 5 6 7 8 9 10                                #
  * # Kontonr.:      x x x x x x x x x P                                 #
  * # Gewichtung:    0 0 0 0 A 5 8 4 2    (A = 10)                       #
+ * #                                                                    #
+ * # Es gibt noch einen Sonderfall, der in der IBAN-Regel 49 angegeben  #
+ * # ist: Konten mit 9 an der ersten oder 5. Stelle enthalten keine     #
+ * # Pr�fziffer. sondern sind ohne Pr�fung als richtig anzusehen.       #
  * ######################################################################
  */
       case 44:
@@ -11486,7 +11516,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * ######################################################################
  */
 
-#line 11500 "konto_check.lxx"
       case 51:
          if(*(kto+2)=='9'){   /* Ausnahme */
 
@@ -11748,8 +11777,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          else
             return FALSE;
 
-#line 11714 "konto_check.lxx"
-#line 11716 "konto_check.lxx"
 /*  Berechnung nach der Methode 53 +���4 */
 /*
  * ######################################################################
@@ -12048,7 +12075,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # bewerten.                                                          #
  * ######################################################################
  */
-#line 11985 "konto_check.lxx"
       case 57:
 #if DEBUG>0
          if(retvals){
@@ -12694,7 +12720,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * # Pr�fzifferberechnung)                                              #
  * ######################################################################
  */
-#line 12565 "konto_check.lxx"
       case 66:
 #if DEBUG>0
       case 2066:
@@ -20103,7 +20128,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
          return NOT_IMPLEMENTED;
    }
 }
-#line 18777 "konto_check.lxx"
 
 /*
  * ######################################################################
@@ -20129,7 +20153,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
  * #    blz:        Bankleitzahl (immer 8-stellig)                           #
  * #    kto:        Kontonummer                                              #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20194,14 +20218,13 @@ DLL_EXPORT int kto_check_blz(char *blz,char *kto)
  * #    retvals:    Struktur, in der die benutzte Pr�fziffermethode und die  #
  * #                berechnete Pr�fziffer zur�ckgegeben werden               #
  * #                                                                         #
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
 #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)
 {
-#line 18875 "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,i;
@@ -20250,7 +20273,6 @@ DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,con
    }
    else  /* BLZ und Kto gleich */
       return ret;
-#line 18924 "konto_check.lxx"
 }
 
 #else   /* !DEBUG */
@@ -20303,7 +20325,7 @@ DLL_EXPORT int kto_check_regel(char *blz,char *kto)
  * #    kto:        Kontonummer                                              #
  * #    blz:        Bankleitzahl (immer 8-stellig)                           #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20345,7 +20367,7 @@ DLL_EXPORT int kto_check_pz(char *pz,char *kto,char *blz)
  * #    retvals:    Struktur, in der die benutzte Pr�fziffermethode und die  #
  * #                berechnete Pr�fziffer zur�ckgegeben werden               #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20398,10 +20420,9 @@ DLL_EXPORT int kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)
  * #    retvals:    Struktur, in der die benutzte Pr�fziffermethode und die  #
  * #                berechnete Pr�fziffer zur�ckgegeben werden               #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
-#line 19075 "konto_check.lxx"
 DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals)
 {
    int untermethode,pz_methode;
@@ -20437,7 +20458,7 @@ DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals){re
  * # statt eines numerischen Wertes. Die Funktion wurde zun�chst f�r die     #
  * # Perl-Variante eingef�hrt.                                               #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20489,7 +20510,7 @@ DLL_EXPORT const char *kto_check_str(char *x_blz,char *kto,char *lut_name)
  * #    kto:        Kontonummer                                              #
  * #    lut_name:   Name der Lookup-Datei oder NULL (f�r DEFAULT_LUT_NAME)   #
  * #                                                                         #
- * # Copyright (C) 2002-2007 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2002-2007 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -20571,7 +20592,7 @@ DLL_EXPORT int kto_check(char *pz_or_blz,char *kto,char *lut_name)
  * # die Anzahl der Banken die zu dem BIC geh�ren, in der Variablen cnt      #
  * # zur�ckgegeben (optional).                                               #
  * #                                                                         #
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20637,7 +20658,6 @@ DLL_EXPORT int get_lut_info2_b(char *lutname,int *version,char **prolog_p,char *
    }
    else
       **user_info_p=0;
-#line 19296 "konto_check.lxx"
    FREE(prolog);
    return OK;
 }
@@ -20663,7 +20683,7 @@ DLL_EXPORT int get_lut_info2_b(char *lutname,int *version,char **prolog_p,char *
  * #    INVALID_LUT_FILE   Fehler in der LUT-Datei (Format, CRC...)     #
  * #    OK                 Erfolg                                       #
  * #                                                                    #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>          #
  * ######################################################################
  */
 
@@ -20702,7 +20722,7 @@ DLL_EXPORT int get_lut_info(char **info,char *lut_name)
  * # keinen Speicher freigeben kann, der von C aus allokiert wurde.     #
  * # Auch in C# ist die Speicherverwaltung nicht einfach m�glich.       #
  * #                                                                    #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>          #
  * ######################################################################
  */
 
@@ -20728,7 +20748,7 @@ DLL_EXPORT void *kc_alloc(int size,int *retval)
  * # Diese Funktion ist Teil des alten Interfaces und wurde als Wrapper      #
  * # zu den neuen Routinen umgestellt.                                       #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20747,7 +20767,7 @@ DLL_EXPORT int cleanup_kto(void)
  * #  Diese Funktion gibt die Version und das Datum der Kompilierung der     #
  * #  konto_check library als String zur�ck.                                .#
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20772,20 +20792,20 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
       case 3:
          return __DATE__ ", " __TIME__;    /* Compilierdatum und -zeit */
       case 4:                              /* Datum der Pr�fziffermethode */
-         if(pz_aenderungen_aktivieren_2018_12)
-            return "03.12.2018";
+         if(pz_aenderungen_aktivieren_2019_12)
+            return "09.12.2019";
          else
-            return "03.12.2018 (Aenderungen vom 03.12.2018 enthalten aber noch nicht aktiviert)";
+            return "09.09.2019 (Aenderungen vom 09.12.2019 enthalten aber noch nicht aktiviert)";
       case 5:
-        return "04.03.2019";
+        return "09.09.2019";
       case 6:
-        return "4. M�rz 2019";            /* Klartext-Datum der Bibliotheksversion */
+        return "13. April 2023";            /* Klartext-Datum der Bibliotheksversion */
       case 7:
         return "final";              /* Versions-Typ der Bibliotheksversion (development, beta, final) */
       case 8:
         return "6";             /* Hauptversionszahl */
       case 9:
-        return "08";             /* Unterversionszahl */
+        return "15";             /* Unterversionszahl */
    }
 }
 
@@ -20800,7 +20820,7 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
  * # Variante vor allem f�r Perl gedacht ist; in der Umgebung ist es         #
  * # etwas komplizierter, ein Array zu �bergeben.                            #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20831,7 +20851,7 @@ DLL_EXPORT int dump_lutfile_p(char *outputname,UINT4 felder)
  * # dem Array required spezifiziert. Es werden nur Felder der Deutschen     #
  * # Bundesbank ber�cksichtigt; andere Felder werden ignoriert.              #
  * #                                                                         #
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -20931,7 +20951,6 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
       default:
          break;
    }
-#line 19529 "konto_check.lxx"
    fputc('\n',out);
    while(--i)fputc('=',out);
    fputc('\n',out);
@@ -21027,7 +21046,7 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
  * #                                                                         #
  * # Update 2014: die IBAN-Regeln werden jetzt auch ausgegeben.              #
  * #                                                                         #
- * # Copyright (C) 2007,2009 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2007,2009 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -21138,7 +21157,7 @@ DLL_EXPORT int rebuild_blzfile(char *inputname,char *outputname,UINT4 set)
  * #                                                                         #
  * # R�ckgabe:      der zu der �bergebenen IBAN geh�rende BIC                #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -21241,7 +21260,7 @@ DLL_EXPORT const char *iban2bic(char *iban,int *retval,char *blz,char *kto)
  * # die Parameter blz und kto wird allerdings Speicher allokiert und per    #
  * # Handle wieder zur�ckgegeben.                                            #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -21256,7 +21275,6 @@ DLL_EXPORT const char *iban2bic_id(char *iban,int *retval,int *blz,int *kto)
    return iban2bic(iban,retval,b,k);
 }
 
-#line 19854 "konto_check.lxx"
 /* Funktion iban_gen(), iban_bic_gen() und iban_bic_gen1 +���1 */
 /* ###########################################################################
  * # Die Funktion iban_gen generiert aus Bankleitzahl und Kontonummer eine   #
@@ -21328,7 +21346,7 @@ DLL_EXPORT const char *iban2bic_id(char *iban,int *retval,int *blz,int *kto)
  * #                fehlschl�gt, wird der entsprechende Fehlercode in die    #
  * #                Variable retval geschrieben und NULL zur�ckgegeben.      #
  * #                                                                         #
- * # Copyright (C) 2008,2013 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2008,2013 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
 
@@ -21580,7 +21598,7 @@ DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,c
  * # Parameter:                                                              #
  * #    ci:         Creditor Identifiers der getestet werden soll            #
  * #                                                                         #
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -21666,7 +21684,7 @@ DLL_EXPORT int ci_check(char *ci)
  * #    retval:     NULL oder Adresse einer Variablen, in die der R�ckgabe-  #
  * #                wert der Kontopr�fung geschrieben wird                   #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -21937,7 +21955,7 @@ DLL_EXPORT int iban_check(char *iban,int *retval)
  * #                zeichen nach jeweils 5 Zeichen) geschrieben wird, oder   #
  * #                NULL (falls nicht ben�tigt)                              #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -22003,7 +22021,7 @@ DLL_EXPORT int ipi_gen(char *zweck,char *dst,char *papier)
  * # kc_id2ptr() kann das Handle in einen String umgewandelt werden, sowie   #
  * # mittels der Funktion kc_id_free() wieder freigegeben werden.            #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -22032,7 +22050,7 @@ DLL_EXPORT int ipi_gen_id(char *zweck,int *dst,int *papier)
  * # Parameter:                                                              #
  * #    zweck: der Strukturierte Verwendungszweck, der getestet werden soll  #
  * #                                                                         #
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -22086,10 +22104,9 @@ DLL_EXPORT int ipi_check(char *zweck)
  * # Felder der LUT-Datei, z.B. Banken in einem bestimmten Ort oder mit      #
  * # einem bestimmten Namen etc.                                             #
  * #                                                                         #
- * # Copyright (C) 2009,2011 Michael Plugge <m.plugge@hs-mannheim.de>        #
+ * # Copyright (C) 2009,2011 Michael Plugge <konto_check@yahoo.com>          #
  * ###########################################################################
  */
-#line 20687 "konto_check.lxx"
 
 /* Funktion volltext_zeichen() +���2 */
 /* Diese Funktion gibt f�r Zeichen die bei der Volltextsuche g�ltig sind
@@ -22936,7 +22953,6 @@ static int qcmp_bic_h(const void *ap,const void *bp)
       return a-b;
 }
 
-#line 21534 "konto_check.lxx"
 
 /* Funktion qcmp_bic() +���3 */
 static int qcmp_bic(const void *ap,const void *bp)
@@ -23041,7 +23057,6 @@ static int qcmp_iban_regel(const void *ap,const void *bp)
    else 
       return a-b;
 }
-#line 21549 "konto_check.lxx"
 
 /* Funktion init_blzf() +���2
  * Diese Funktion initialisiert das Array mit den Bankleitzahlen f�r alle
@@ -23109,7 +23124,6 @@ DLL_EXPORT int konto_check_idx2blz(int idx,int *zweigstelle,int *retval)
 }
 
 /* Funktion suche_int1() +���2 */
-#line 21617 "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)
 {
@@ -23160,7 +23174,6 @@ static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstell
 }
 
 /* Funktion suche_int2() +���2 */
-#line 21668 "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)
 {
@@ -23775,7 +23788,6 @@ 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 22284 "konto_check.lxx"
 
    if(idx_op)*idx_op=NULL;
    if(cnt_op)*cnt_op=NULL;
@@ -23857,7 +23869,6 @@ DLL_EXPORT int lut_suche_sort2(int anzahl,int *blz,int *zweigstellen,int *anzahl
    return OK;
 }
 
-#line 22367 "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)
@@ -23987,7 +23998,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 22517 "konto_check.lxx"
+#line 22564 "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)
@@ -24041,7 +24052,6 @@ 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;
@@ -24055,7 +24065,6 @@ 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;
@@ -24068,7 +24077,6 @@ 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;
@@ -24078,7 +24086,6 @@ 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 22550 "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,
@@ -24170,7 +24177,7 @@ DLL_EXPORT int bic_info(char *bic1,int mode,int *anzahl,int *start_idx)
 /* ###############################################################################
  * # Diese Funktionen bestimmen das �nderungsflag zu einem BIC bzw. einer IBAN   #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24193,7 +24200,7 @@ DLL_EXPORT int iban_aenderung(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen das L�schflag zu einem BIC bzw. einer IBAN       #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24216,7 +24223,7 @@ DLL_EXPORT int iban_loeschung(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen die IBAN-Regel zu einem BIC bzw. einer IBAN      #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24239,7 +24246,7 @@ DLL_EXPORT int iban_iban_regel(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen die Nachfolge-BLZ zu einem BIC bzw. einer IBAN   #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24262,7 +24269,7 @@ DLL_EXPORT int iban_nachfolge_blz(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen die Laufende Nr. zu einem BIC bzw. einer IBAN    #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24285,7 +24292,7 @@ DLL_EXPORT int iban_nr(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen den PAN zu einem BIC bzw. einer IBAN             #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24308,7 +24315,7 @@ DLL_EXPORT int iban_pan(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen die PLZ der Bank zu einem BIC bzw. einer IBAN    #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24331,7 +24338,7 @@ DLL_EXPORT int iban_plz(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen die Pr�fziffer zu einem BIC bzw. einer IBAN      #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24354,7 +24361,7 @@ DLL_EXPORT int iban_pz(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen den BIC zu einem BIC bzw. einer IBAN             #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24377,7 +24384,7 @@ DLL_EXPORT const char *iban_bic(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen den BIC der Hauptstelle zu einem BIC bzw. einer IBAN#
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24400,7 +24407,7 @@ DLL_EXPORT const char *iban_bic_h(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen den Name der Bank zu einem BIC bzw. einer IBAN   #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24423,7 +24430,7 @@ DLL_EXPORT const char *iban_name(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen den Kurzname der Bank zu einem BIC bzw. einer IBAN#
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24446,7 +24453,7 @@ DLL_EXPORT const char *iban_name_kurz(char *iban,int filiale,int*retval)
 /* ###############################################################################
  * # Diese Funktionen bestimmen den Ort einer Bank zu einem BIC bzw. einer IBAN  #
  * #                                                                             #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>                 #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>                   #
  * ###############################################################################
  */
 
@@ -24464,7 +24471,6 @@ DLL_EXPORT const char *iban_ort(char *iban,int filiale,int*retval)
 {
    return iban_fkt_s(iban,filiale,retval,lut_ort);
 }
-#line 22639 "konto_check.lxx"
 
 static int bic_fkt_c(char *bic1,int mode,int filiale,int *retval,char *base,int error)
 {
@@ -24773,7 +24779,7 @@ static const char *iban_fkt_s(char *iban,int filiale,int *retval,const char*(*fk
  * #    val:        Daten                                                    #
  * #    size:   Gr��e des Datenblocks (nur bei set_default_bin() )           #
  * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -24829,7 +24835,7 @@ DLL_EXPORT int kto_check_set_default_bin(char *key,char *val,int size)
  * # Diese Funktion initialisiert die Variablen f�r den Default-Block und    #
  * # l�scht evl. vorhandene Werte.                                           #
  * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -24865,7 +24871,7 @@ static int kto_check_clear_default(void)
  * #    lut_name:   Name der LUT-Datei                                       #
  * #    block_id:   ID in der LUT-Datei f�r den Block                        #
  * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -24944,7 +24950,7 @@ DLL_EXPORT int kto_check_init_default(char *lut_name,int block_id)
  * #    val:        Wert (R�ckgabe per Referenz)                             #
  * #    size:       Gr��e des Datenblocks (per Referenz)                     #
  * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -24976,7 +24982,7 @@ DLL_EXPORT int kto_check_get_default(char *key,char **val,int *size)
  * #    keys:       Array mit den Schl�sseln (R�ckgabe per Referenz)         #
  * #    cnt:        Anzahl (R�ckgabe per Referenz)                           #
  * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -25004,7 +25010,7 @@ DLL_EXPORT int kto_check_default_keys(char ***keys,int *cnt)
  * #    lutfile:    LUT-Datei in die der Block geschrieben werden soll       #
  * #    block_id:   ID in der LUT-Datei f�r den Block                        #
  * #                                                                         #
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -25049,7 +25055,7 @@ DLL_EXPORT int kto_check_write_default(char *lutfile,int block_id)
  * # Funktion mit dem Parameter 0 aufgerufen wird, wird nur die aktuelle     #
  * # Kodierung zur�ckgegeben.                                                #
  * #                                                                         #
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -25200,7 +25206,7 @@ DLL_EXPORT int kto_check_encoding(int mode)
  * # Diese Funktion entspricht der Funktion kto_check_encoding(); allerdings #
  * # ist der R�ckgabewert nicht numerisch, sondern ein String.               #
  * #                                                                         #
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -25258,7 +25264,7 @@ DLL_EXPORT const char *kto_check_encoding_str(int mode)
  * #    0: Flag abfragen, nicht ver�ndern                                    #
  * #   -1: Flag l�schen, Speicher der raw-Daten freigeben                    #
  * #                                                                         #
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -25295,7 +25301,7 @@ DLL_EXPORT int keep_raw_data(int mode)
  * # Diese Funktion konvertiert einen gelesenen LUT-Block in die gew�nschte  #
  * # Kodierung. Der urspr�nglich allokierte Speicher wird wieder freigegeben.#
  * #                                                                         #
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -25753,7 +25759,6 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
       default:   return "???";
    }
 }
-#line 23594 "konto_check.lxx"
 
 /* Funktion lut_keine_iban_berechnung() +���1 */
 /*
@@ -25868,7 +25873,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_2018_12 abzufragen bzw. zu setzen. Falls die Variable #
+ * # pz_aenderungen_aktivieren_2019_12 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.             #
@@ -25878,14 +25883,14 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
  * #                anderer Wert: nur Abfrage des Status                     #
  * # R�ckgabe:      aktueller Status des Flags                               #                                                               #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
 DLL_EXPORT int pz_aenderungen_enable(int set)
 {
-   if(set==0 || set==1)pz_aenderungen_aktivieren_2018_12=set;
-   return pz_aenderungen_aktivieren_2018_12;
+   if(set==0 || set==1)pz_aenderungen_aktivieren_2019_12=set;
+   return pz_aenderungen_aktivieren_2019_12;
 }
 
 #if DEBUG>0
@@ -25902,7 +25907,7 @@ DLL_EXPORT int pz_aenderungen_enable(int set)
  * #    txt:        Textvariable                                             #
  * #    i:          Integervariable (4 Byte)                                 #
  * #                                                                         #
- * # Copyright (C) 2006 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2006 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -25917,7 +25922,6 @@ DLL_EXPORT char *kto_check_test_vars(char *txt,UINT4 i)
 #endif
 
 
-#line 23758 "konto_check.lxx"
 /* Funktionen *_id() +���1 */
 /* ###########################################################################
  * # Die folgenden Funktionen sind die id-Varianten von Funktionen, die      #
@@ -25931,7 +25935,7 @@ DLL_EXPORT char *kto_check_test_vars(char *txt,UINT4 i)
  * # Da der Aufruf f�r jede Funktionsgruppe gleich ist, wird er per Makro    #
  * # gemacht.                                                                #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
    /* numerische R�ckgabewerte in eine id umwandeln */
@@ -26074,7 +26078,7 @@ DLL_EXPORT int current_lutfile_name_id(int *set,int *level,int *retval)
  * # den etwas eigenwilligen (Schleich-)Weg �ber IntPtr nehmen, damit der    #
  * # Speicher wieder freigegeben werden kann...                              #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -26092,7 +26096,7 @@ DLL_EXPORT int current_lutfile_name_id(int *set,int *level,int *retval)
  * # von kc_id_free() wird es auch nicht gel�scht, der Funktionsaufruf gibt  #
  * # nur OK zur�ck, ohne etwas zu tun.                                       #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -26136,7 +26140,7 @@ static int kc_ptr2id(char *ptr,int *handle,int release_mem)
  * # Diese Funktion gibt den Pointer zu einem Handle zur�ck. Dieser Wert     #
  * # kann dann als String-Pointer in den DLL-Routinen verwendet werden.      #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -26157,7 +26161,7 @@ DLL_EXPORT char *kc_id2ptr(int handle,int *retval)
  * # Diese Funktion gibt den Speicher, der zu einem Handle geh�rt, wieder    #
  * # frei und setzt den entsprechenden Slot-Eintrag auf NULL.                #
  * #                                                                         #
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 
@@ -26181,7 +26185,7 @@ DLL_EXPORT int kc_id_free(int handle)
  * # cmp_bic() ist die Vergleichsfunktion f�r bic_binsearch() und            #
  * # lut_write_scl_blocks() (zum Sortieren der BICs).                        #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 static int cmp_bic(const void *ap,const void *bp)
@@ -26201,7 +26205,7 @@ static int cmp_bic(const void *ap,const void *bp)
  * # Die Funktion bic_binsearch() implementiert eine bin�re Suche im         #
  * # BIC-Array (rekursiv)                                                    #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 static int bic_binsearch(int links,int rechts,char *bic)
@@ -26226,10 +26230,18 @@ static int bic_binsearch(int links,int rechts,char *bic)
  * # letzten Stellen existiert (Extension BIC); falls dieser auch nicht      #
  * # existiert, wird als Letztes ein 8-stelliger BIC gesucht (Wildcard-BIC). #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Der zus�tzliche Parameter raw wurde eingef�hrt, da bei den Flags        #
+ * # �fters bei 11-stelligen BICs nicht die richtigen Flags angegeben sind   #
+ * # (bei den zugeh�rigen Wildcard-BICs (8-stellig) sind mehr Optionen       #
+ * # gesetzt), wie z.B. bei WELADEDLLEV oder DEUTDEDBPAL. Falls als erstes   #
+ * # Zeichen der BIC ein ! �bergeben wird, werden die originalen Flags       #
+ * # zur�ckgegeben, andernfalls die "richtigen". So ist die R�ckgabe von     #
+ * # DEUTDEDBPAL z.B. 11011, von !DEUTDEDBPAL jedoch 10000.                  #
+ * #                                                                         #
+ * # Copyright (C) 2018, 2023 Michael Plugge <konto_check@yahoo.com>         #
  * ###########################################################################
  */
-static int scl_idx(const char *bic,int *retval)
+static int scl_idx(const char *bic,int *retval,int *raw)
 {
    char such_bic[12];
    int i,idx;
@@ -26238,41 +26250,75 @@ static int scl_idx(const char *bic,int *retval)
       if(retval)*retval=NO_SCL_BLOCKS_LOADED;
       return -1;
    }
-   strcpy(such_bic,bic);
+   if(*bic=='!'){
+      *raw=1;
+      strcpy(such_bic,bic+1);
+   }
+   else{
+      *raw=0;
+      strcpy(such_bic,bic);
+   }
    for(i=0;i<11 && such_bic[i];i++)such_bic[i]=toupper(such_bic[i]);
 
-      /* zun�chst den BIC suchen wie angegeben */
-   idx=bic_binsearch(0,scl_cnt,such_bic);
+   /*
+    * Auszug aus dem SCL Directory Notice (Seite 13):
+    *
+    * The SCL Directory contains 11-character and 8-character BICs. The following convention
+    * applies.
+    *
+    * - An 8-character BIC is a wild card and represents the reachability of any 11-character
+    *   BIC with the same first eight characters, as well as the reachability of the 8-character
+    *   BIC itself.
+    *
+    * - An 11-character BIC with the branch code extension "XXX" represents itself as well
+    *   as the reachability of the corresponding 8-character BIC. But it is not a wild card.
+    *
+    * - All other 11-character BICs represent the reachability of the respective individual
+    *   11-character BIC only.
+    *
+    * https://www.bundesbank.de/resource/blob/626738/8f82d10dd08993a1941e8441cf5a9fd4/mL/scl-directory-notice-ab-nov2018-data.pdf
+    *
+    * Punkt 2 hat eine h�here Priorit�t als Punkt 1, denn eine 8-stellige BIC ist mit selbiger
+    * um 'XXX' erweiterten BIC identisch.
+    *
+    * (Update April 23: das gilt wohl doch nicht so ganz, zumindest nicht bei den Flags...
+    * - die Flags werden jetzt vom Eintrag und dem Wildcard kombiniert)
+    *
+    */
+
+   if(such_bic[8]==0){  /* Such-BIC 8-stellig angegeben; BIC zuerst mit XXX extension suchen */
+      such_bic[8]=such_bic[9]=such_bic[10]='X';
+      such_bic[11]=0;
+      idx=bic_binsearch(0,scl_cnt-1,such_bic);
+      if(idx>=0){
+         if(retval)*retval=OK_SCL_EXTENSION_BIC_USED;
+         return idx;
+      }
+      else
+         such_bic[8]=0; /* wieder zur�cksetzen */
+   }
+
+      /* nun den BIC suchen wie angegeben */
+   idx=bic_binsearch(0,scl_cnt-1,such_bic);
    if(idx>=0){
       if(retval)*retval=OK;
       return idx;
    }
+   else if(such_bic[8]==0){
+      if(retval)*retval=SCL_BIC_NOT_FOUND;
+      return -1;
+   }
    else{
-      if(such_bic[8]==0){  /* Such-BIC 8-stellig angegeben; BIC mit XXX extension testen */
-         such_bic[8]=such_bic[9]=such_bic[10]='X';
-         such_bic[11]=0;
-         idx=bic_binsearch(0,scl_cnt,such_bic);
-         if(idx>=0){
-            if(retval)*retval=OK_SCL_EXTENSION_BIC_USED;
-            return idx;
-         }
-         else{
-            if(retval)*retval=SCL_BIC_NOT_FOUND;
-            return -1;
-         }
+         /* Wildcard-BIC suchen, nur noch bei 11-stelligen BICs */
+      such_bic[8]=0;
+      idx=bic_binsearch(0,scl_cnt-1,such_bic);
+      if(idx>=0){
+         if(retval)*retval=OK_SCL_WILDCARD_BIC_USED;
+         return idx;
       }
       else{
-            /* Wildcard-BIC suchen */
-         such_bic[8]=0;
-         idx=bic_binsearch(0,scl_cnt,such_bic);
-         if(idx>=0){
-            if(retval)*retval=OK_SCL_WILDCARD_BIC_USED;
-            return idx;
-         }
-         else{
-            if(retval)*retval=SCL_BIC_NOT_FOUND;
-            return -1;
-         }
+         if(retval)*retval=SCL_BIC_NOT_FOUND;
+         return -1;
       }
    }
 }
@@ -26289,21 +26335,22 @@ static int scl_idx(const char *bic,int *retval)
  * # direkter Download-Link:                                                 #
  * #    https://www.bundesbank.de/Redaktion/DE/Downloads/Aufgaben/Unbarer_Zahlungsverkehr/SEPA/verzeichnis_der_erreichbaren_zahlungsdienstleister.csv?__blob=publicationFile
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
 {
-   char c,*ptr,buffer[512],*scl_name_block_s,*scl_bic_block_s,*scl_flags_block_s,*ptr1,*ptr2,*ptr3;
+   char c,*ptr,buffer[512],buffer2[128],*scl_name_block_s,*scl_bic_block_s,
+        *scl_flags_block_s,*scl_flags_block_o,*ptr1,*ptr2,*ptr3,*ptr4,*base_ptr="";
    char scl_gueltigkeit[16],scl_gueltigkeit_iso[16];
-   int cnt,i,rv,j,*iptr,jahr,monat,tag;
+   int cnt,i,j,rv,*iptr,jahr,monat,tag,f1,f2,f3,f4,f5;
    FILE *in,*lut;
    struct stat stat_buffer;
    struct tm z;
    time_t ts;
 
    if(!(in=fopen(inputfile,"r")))RETURN(FILE_READ_ERROR);
-   fgets(buffer,512,in);
+   if(!fgets(buffer,512,in))RETURN(SCL_INPUT_FORMAT_ERROR);
    if(strncmp(buffer,"Gueltig ab / valid from ",24))return SCL_INPUT_FORMAT_ERROR;
    for(ptr=buffer;!isdigit(*ptr);ptr++);
    strncpy(scl_gueltigkeit,ptr,16);
@@ -26317,26 +26364,31 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
    z.tm_mon=monat;
    z.tm_year=jahr-1900;
    ts=mktime(&z);
-   snprintf(scl_gueltigkeit_iso,16,"%4d-%02d-%02d",jahr,monat,tag);
-   fgets(buffer,512,in);
-   if(strncmp(buffer,"BIC;Name;Service SCT;Service SDD;Service COR1;Service B2B;Service SCC",69))RETURN(SCL_INPUT_FORMAT_ERROR);
-
+   snprintf(scl_gueltigkeit_iso,16,"%4d-%02d-%02d",jahr%10000,monat%100,tag%100);
+   if(!fgets(buffer,512,in))RETURN(SCL_INPUT_FORMAT_ERROR);
+      /* Leerzeichen aus dem �berschrift-String entfernen */
+   for(ptr=buffer,ptr2=buffer2;*ptr;ptr++)if(!isspace(*ptr))*ptr2++=*ptr;
+   if(strncmp(buffer2,"BIC;Name;SERVICESCT;SERVICECOR;SERVICECOR1;SERVICEB2B;SERVICESCC",64))RETURN(SCL_INPUT_FORMAT_ERROR);
    stat(inputfile,&stat_buffer);
-   cnt=stat_buffer.st_size/163+100;    /* etwas gro�z�gig die Anzahl rechnen */
+
+   cnt=stat_buffer.st_size/163+300;    /* etwas gro�z�gig die Anzahl rechnen; jede Zeile hat 163 Bytes und ist am Ende mit Leerzeichen aufgef�llt */
 
    scl_bic_array=(char **)calloc(sizeof(char*),cnt);
    scl_name_array=(char **)calloc(sizeof(char*),cnt);
    scl_flags_array=(char **)calloc(sizeof(char*),cnt);
+   scl_flags_array_o=(char **)calloc(sizeof(char*),cnt);
 
    scl_bic_block=ptr1=(char *)calloc(12,cnt);
    scl_name_block=ptr2=(char *)calloc(150,cnt);
    scl_flags_block=ptr3=(char *)calloc(6,cnt);
+   scl_flags_block_orig=ptr4=(char *)calloc(6,cnt);
 
    /* SCL-Datei einlesen */
    for(cnt=0;fgets(buffer,512,in);){
       scl_bic_array[cnt]=ptr1;
       scl_name_array[cnt]=ptr2;
       scl_flags_array[cnt]=ptr3;
+      scl_flags_array_o[cnt]=ptr4;
       cnt++;
       for(ptr=buffer;*ptr!=';' && !isspace(*ptr);*ptr1++=*ptr++);
       c=*ptr;
@@ -26351,12 +26403,12 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
       ptr2++;
 
       /* ptr steht nun auf den Flags */
-      *ptr3++=*ptr;
-      *ptr3++=*(ptr+2);
-      *ptr3++=*(ptr+4);
-      *ptr3++=*(ptr+6);
-      *ptr3++=*(ptr+8);
-      *ptr3++=0;
+      *ptr4++=*ptr3++=*ptr;
+      *ptr4++=*ptr3++=*(ptr+2);
+      *ptr4++=*ptr3++=*(ptr+4);
+      *ptr4++=*ptr3++=*(ptr+6);
+      *ptr4++=*ptr3++=*(ptr+8);
+      *ptr4++=*ptr3++=0;
    }
    fclose(in);
 
@@ -26367,34 +26419,89 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
    /* vor dem Abspeichern der Blocks nach BICs sortieren */
    qsort(iptr,cnt,sizeof(int),cmp_bic);
 
+      /* Auszug aus dem SCL-Merkblatt:
+       * Das SCL-Directory enth�lt elfstellige und achtstellige BICs. Dabei gilt:
+       *
+       * - Ein achtstelliger BIC ist eine sog. Wildcard und repr�sentiert die Erreichbarkeit eines
+       *   jeden elfstelligen BICs mit identischen ersten acht Stellen sowie die Erreichbarkeit
+       *   des achtstelligen BICs selbst.
+       *
+       * - Ein elfstelliger BIC mit der Branch Code Extension XXX repr�sentiert sich selbst
+       *   sowie die Erreichbarkeit des zugeh�rigen achtstelligen BICs. Er stellt jedoch keine
+       *   Wildcard dar.
+       *
+       * - Alle �brigen elfstelligen BICs repr�sentieren ausschlie�lich die Erreichbarkeit des
+       *   jeweiligen einzelnen elfstelligen BICs.
+       *
+       * Ein Zahlungsdienstleister, der mit einer Wildcard im SCL-Directory ausgewiesen wird, muss
+       * Zahlungen f�r alle denkbaren elfstelligen BICs, die durch die Wildcard repr�sentiert werden,
+       * aufnehmen.
+       *
+       * D.h., bei 11-stelligen BICs, zu denen eine 8-stellige Wildcard-BIC existiert, sind die Flags
+       * aus beiden Varianten zu kombinieren. Beispiel:
+       *
+       * WELADEDL;SPARKASSE LEVERKUSEN;1;1;0;1;1                                                                                                                                                                 
+       * WELADEDLLEV;SPARKASSE LEVERKUSEN;1;0;0;0;0                                                                                                                                                              
+       *
+       * Die resultierenden Flags f�r WELADEDLLEV werden aus den beiden BICs zusammengesetzt zu 1;1;0;1;1
+       *
+       * Um das Verhalten auch f�r �ltere Installationen von konto_check zu implementieren, wird in die LUT-Datei
+       * ein Block mit den resultierenden Flags als SCL Flags (ID 31) geschrieben; die Original-Version findet sich
+       * als ID 32 mit der Bezeichnung SCL Flags orig, und wird von �teren Installationen ignoriert.
+       *
+       * Von der Problematik betroffen sind in der aktuellen Datei (Stand April 2023) 68 BICs, davon 8 deutsche.
+       */
+
+   f1=f2=f3=f4=f5=0;
    ptr1=scl_bic_block_s=(char *)calloc(1,ptr1-scl_bic_block+16);
    ptr2=scl_name_block_s=(char *)calloc(1,ptr2-scl_name_block+16);
    ptr3=scl_flags_block_s=(char *)calloc(1,ptr3-scl_flags_block+16);
+   ptr4=scl_flags_block_o=(char *)calloc(1,ptr4-scl_flags_block_orig+16);
    for(i=0;i<cnt;i++){
       j=iptr[i];
       for(ptr=scl_bic_array[j];(*ptr1++=*ptr++););
       for(ptr=scl_name_array[j];(*ptr2++=*ptr++););
       for(ptr=scl_flags_array[j];(*ptr3++=*ptr++););
+      if(strlen(scl_bic_array[j])==8){
+         base_ptr=scl_bic_array[j];   /* 8-stelliger BIC, Flags merken */
+         f1=*(scl_flags_array[j]+0)-'0';
+         f2=*(scl_flags_array[j]+1)-'0';
+         f3=*(scl_flags_array[j]+2)-'0';
+         f4=*(scl_flags_array[j]+3)-'0';
+         f5=*(scl_flags_array[j]+4)-'0';
+      }
+      if(!strncmp(scl_bic_array[j],base_ptr,8)){
+         ptr=scl_flags_array_o[j];
+         if(*ptr++=='1' || f1)*ptr4++='1'; else *ptr4++='0';
+         if(*ptr++=='1' || f2)*ptr4++='1'; else *ptr4++='0';
+         if(*ptr++=='1' || f3)*ptr4++='1'; else *ptr4++='0';
+         if(*ptr++=='1' || f4)*ptr4++='1'; else *ptr4++='0';
+         if(*ptr++=='1' || f5)*ptr4++='1'; else *ptr4++='0';
+         *ptr4++=0;
+      }
+      else
+         for(ptr=scl_flags_array_o[j];(*ptr4++=*ptr++););
    }
    free(iptr);
 
    if(!(lut=fopen(lutfile,"rb+")))RETURN(FILE_WRITE_ERROR);
 
       /* zun�chst mal testen ob es auch eine LUT2 Datei ist */
-   if(!(ptr=fgets(buffer,SLOT_BUFFER,lut)))RETURN(FILE_READ_ERROR);
+   if(!(ptr=fgets(buffer,512,lut)))RETURN(FILE_READ_ERROR);
    while(*ptr && *ptr!='\n')ptr++;
    *--ptr=0;
    if(!strcmp(buffer,"BLZ Lookup Table/Format 1."))RETURN(LUT1_FILE_USED); /* alte LUT-Datei */
    if(strcmp(buffer,"BLZ Lookup Table/Format 2."))RETURN(INVALID_LUT_FILE); /* keine LUT-Datei */
 
       /* nun die Blocks schreiben */
-   rewind(lut);
-   sprintf(buffer,"cnt: %d, TS: %ld, Gueltigkeit: %s %s",cnt,(long)ts,scl_gueltigkeit,scl_gueltigkeit_iso);
+   rewind(lut);   /* Info schreiben da� korrigierte Flags */
+   sprintf(buffer,"cnt: %d, TS: %ld, Gueltigkeit: %s %s korrigiert",cnt,(long)ts,scl_gueltigkeit,scl_gueltigkeit_iso);
    if((rv=write_lut_block_int(lut,LUT2_SCL_INFO,strlen(buffer)+1,buffer))!=OK){
       fclose(lut);
       FREE(scl_bic_block_s);
       FREE(scl_name_block_s);
       FREE(scl_flags_block_s);
+      FREE(scl_flags_block_o);
       RETURN(rv);
    }
    if((rv=write_lut_block_int(lut,LUT2_SCL_BIC,(UINT4)(ptr1-scl_bic_block_s+1),scl_bic_block_s))!=OK){
@@ -26402,6 +26509,7 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
       FREE(scl_bic_block_s);
       FREE(scl_name_block_s);
       FREE(scl_flags_block_s);
+      FREE(scl_flags_block_o);
       RETURN(rv);
    }
    if((rv=write_lut_block_int(lut,LUT2_SCL_NAME,(UINT4)(ptr2-scl_name_block_s+1),scl_name_block_s))!=OK){
@@ -26409,13 +26517,23 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
       FREE(scl_bic_block_s);
       FREE(scl_name_block_s);
       FREE(scl_flags_block_s);
+      FREE(scl_flags_block_o);
+      RETURN(rv);
+   }
+   if((rv=write_lut_block_int(lut,LUT2_SCL_FLAGS,(UINT4)(ptr4-scl_flags_block_o+1),scl_flags_block_o))!=OK){
+      fclose(lut);
+      FREE(scl_bic_block_s);
+      FREE(scl_name_block_s);
+      FREE(scl_flags_block_s);
+      FREE(scl_flags_block_o);
       RETURN(rv);
    }
-   if((rv=write_lut_block_int(lut,LUT2_SCL_FLAGS,(UINT4)(ptr3-scl_flags_block_s+1),scl_flags_block_s))!=OK){
+   if((rv=write_lut_block_int(lut,LUT2_SCL_FLAGS_ORIG,(UINT4)(ptr3-scl_flags_block_s+1),scl_flags_block_s))!=OK){
       fclose(lut);
       FREE(scl_bic_block_s);
       FREE(scl_name_block_s);
       FREE(scl_flags_block_s);
+      FREE(scl_flags_block_o);
       RETURN(rv);
    }
 
@@ -26423,26 +26541,26 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
    FREE(scl_bic_block_s);
    FREE(scl_name_block_s);
    FREE(scl_flags_block_s);
+   FREE(scl_flags_block_o);
    RETURN(OK);
 }
 
-#line 24267 "konto_check.lxx"
 /* Funktion lut_scl_init() +���3 */
 /* ###########################################################################
  * # Die Funktion lut_scl_init() liest die SCL-Blocks aus einer LUT-Datei    #
  * # und initialisiert die zugeh�rigen internen Datenstrukturen.             #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_init(char *lut_name)
 {
    char *ptr,*end;
    int i,cnt,rv;
-   static UINT4 block_size_0,block_size_1,block_size_2,block_size_3;
+   static UINT4 block_size_0,block_size_1,block_size_2,block_size_3,block_size_4;
    FILE *lut;
 
-   if(scl_bic_array && scl_name_array && scl_flags_array)return OK;  /* schon initialisiert */
+   if(scl_bic_array && scl_name_array && scl_flags_array && scl_flags_array_o)return OK;  /* schon initialisiert */
 
    if(!(lut=fopen(lut_name,"rb")))RETURN(FILE_READ_ERROR);
    if((rv=read_lut_block_int(lut,0,LUT2_SCL_INFO,&block_size_0,&scl_info_block))<0){
@@ -26473,6 +26591,15 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
       else
          return rv;
    }
+   if((rv=read_lut_block_int(lut,0,LUT2_SCL_FLAGS_ORIG,&block_size_4,&scl_flags_block_orig))<0){
+         /* hier retval<0 ignorieren, denn bei alten LUT_Dateien ist der Block nicht enthalten.
+          * In dem Fall kann der Block durch den Block LUT2_SCL_FLAGS ersetzt werden. Die BIC Flags
+          * sind in dem Fall dann nicht korrigiert. Lohnt sich nicht, das hier zu machen, da die
+          * LUT-Dateien die mit dieser Version erzeugt werden, den Block enthalten.
+          */
+      scl_flags_block_orig=scl_flags_block;
+      block_size_4=block_size_3;
+   }
    fclose(lut);
    if((i=sscanf(scl_info_block,"cnt: %d, TS: %ld, Gueltigkeit: %15s %15s",
                &cnt,&scl_ts,(char *)&scl_gueltigkeit,(char *)&scl_gueltigkeit_iso))!=4)RETURN(INVALID_SCL_INFO_BLOCK);
@@ -26480,6 +26607,7 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
    scl_bic_array=(char **)calloc(sizeof(char*),cnt);
    scl_name_array=(char **)calloc(sizeof(char*),cnt);
    scl_flags_array=(char **)calloc(sizeof(char*),cnt);
+   scl_flags_array_o=(char **)calloc(sizeof(char*),cnt);
 
    for(i=0,ptr=scl_bic_block,end=scl_bic_block+block_size_1;i<cnt && ptr<end;i++){
       scl_bic_array[i]=ptr;
@@ -26495,6 +26623,11 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
       scl_flags_array[i++]=ptr;
       while(*ptr++ && ptr<end);
    }
+
+   for(i=0,ptr=scl_flags_block_orig,end=scl_flags_block_orig+block_size_4;i<cnt && ptr<end;){
+      scl_flags_array_o[i++]=ptr;
+      while(*ptr++ && ptr<end);
+   }
    scl_cnt=cnt;
    RETURN(OK);
 }
@@ -26504,7 +26637,7 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
  * # Die Funktion lut_scl_info() gibt Infos �ber die Anzahl der Eintr�ge im  #
  * # SCL-Verzeichnis sowie das Datum, ab wann die Datei g�ltig ist.          #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_info(char *lutfile,int *cnt,const char **gueltigkeit,const char **gueltigkeit_iso)
@@ -26540,16 +26673,16 @@ DLL_EXPORT int lut_scl_info(char *lutfile,int *cnt,const char **gueltigkeit,cons
  * # Die Funktion lut_scl_multi() gibt alle Eintr�ge des SCL-Verzeichnisses  #
  * # zu einem gegebenen BIC zur�ck.                                          #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_multi(char *bic,const char **scl_flags,const char **used_bic,const char **scl_name)
 {
-   int i,rv;
+   int i,rv,raw;
 
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0)return rv;
-   if(scl_flags)*scl_flags=scl_flags_array[i];
+   if(scl_flags)*scl_flags=raw?scl_flags_array_o[i]:scl_flags_array[i];
    if(used_bic)*used_bic=scl_bic_array[i];
    if(scl_name)*scl_name=scl_name_array[i];
    return rv;
@@ -26562,15 +26695,15 @@ DLL_EXPORT int lut_scl_multi(char *bic,const char **scl_flags,const char **used_
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_sct(char *bic,int *retval)
 {
    char *flags;
-   int i,rv;
+   int i,rv,raw;
 
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26588,15 +26721,15 @@ DLL_EXPORT int lut_scl_sct(char *bic,int *retval)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_sdd(char *bic,int *retval)
 {
    char *flags;
-   int i,rv;
+   int i,rv,raw;
 
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26615,15 +26748,15 @@ DLL_EXPORT int lut_scl_sdd(char *bic,int *retval)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_cor1(char *bic,int *retval)
 {
    char *flags;
-   int i,rv;
+   int i,rv,raw;
 
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26641,15 +26774,15 @@ DLL_EXPORT int lut_scl_cor1(char *bic,int *retval)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_b2b(char *bic,int *retval)
 {
    char *flags;
-   int i,rv;
+   int i,rv,raw;
 
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26667,15 +26800,15 @@ DLL_EXPORT int lut_scl_b2b(char *bic,int *retval)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_scc(char *bic,int *retval)
 {
    char *flags;
-   int i,rv;
+   int i,rv,raw;
 
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26693,17 +26826,17 @@ DLL_EXPORT int lut_scl_scc(char *bic,int *retval)
  * # einen BIC umgewandelt werden mu�, m�ssen auch die Blocks BLZ und BIC    #
  * # der LUT-Datei initialisiert sein, sonst wird ein Fehler zur�ckgegeben.  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_multi_blz(char *blz,const char **scl_flags,const char **used_bic,const char **scl_name)
 {
    const char *bic;
-   int i,rv;
+   int i,rv,raw;
 
    bic=lut_bic(blz,0,&rv);
    if(rv<0)return rv;
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0)return rv;
    if(scl_flags)*scl_flags=scl_flags_array[i];
    if(used_bic)*used_bic=scl_bic_array[i];
@@ -26718,14 +26851,14 @@ DLL_EXPORT int lut_scl_multi_blz(char *blz,const char **scl_flags,const char **u
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_sct_blz(char *blz,int *retval,const char **used_bic)
 {
    char *flags;
    const char *bic;
-   int i,rv;
+   int i,rv,raw;
 
    bic=lut_bic(blz,0,&rv);
    if(rv<0){
@@ -26734,7 +26867,7 @@ DLL_EXPORT int lut_scl_sct_blz(char *blz,int *retval,const char **used_bic)
    }
    else
       if(retval)*retval=OK;
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26753,14 +26886,14 @@ DLL_EXPORT int lut_scl_sct_blz(char *blz,int *retval,const char **used_bic)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_sdd_blz(char *blz,int *retval,const char **used_bic)
 {
    char *flags;
    const char *bic;
-   int i,rv;
+   int i,rv,raw;
 
    bic=lut_bic(blz,0,&rv);
    if(rv<0){
@@ -26769,7 +26902,7 @@ DLL_EXPORT int lut_scl_sdd_blz(char *blz,int *retval,const char **used_bic)
    }
    else
       if(retval)*retval=OK;
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26789,14 +26922,14 @@ DLL_EXPORT int lut_scl_sdd_blz(char *blz,int *retval,const char **used_bic)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_cor1_blz(char *blz,int *retval,const char **used_bic)
 {
    char *flags;
    const char *bic;
-   int i,rv;
+   int i,rv,raw;
 
    bic=lut_bic(blz,0,&rv);
    if(rv<0){
@@ -26805,7 +26938,7 @@ DLL_EXPORT int lut_scl_cor1_blz(char *blz,int *retval,const char **used_bic)
    }
    else
       if(retval)*retval=OK;
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26824,14 +26957,14 @@ DLL_EXPORT int lut_scl_cor1_blz(char *blz,int *retval,const char **used_bic)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_b2b_blz(char *blz,int *retval,const char **used_bic)
 {
    char *flags;
    const char *bic;
-   int i,rv;
+   int i,rv,raw;
 
    bic=lut_bic(blz,0,&rv);
    if(rv<0){
@@ -26840,7 +26973,7 @@ DLL_EXPORT int lut_scl_b2b_blz(char *blz,int *retval,const char **used_bic)
    }
    else
       if(retval)*retval=OK;
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26859,14 +26992,14 @@ DLL_EXPORT int lut_scl_b2b_blz(char *blz,int *retval,const char **used_bic)
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den     #
  * # entsprechende Fehlercode (<0) gesetzt.                                  #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_scc_blz(char *blz,int *retval,const char **used_bic)
 {
    char *flags;
    const char *bic;
-   int i,rv;
+   int i,rv,raw;
 
    bic=lut_bic(blz,0,&rv);
    if(rv<0){
@@ -26875,7 +27008,7 @@ DLL_EXPORT int lut_scl_scc_blz(char *blz,int *retval,const char **used_bic)
    }
    else
       if(retval)*retval=OK;
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0){
       if(retval)*retval=rv;
       return -1;
@@ -26892,17 +27025,17 @@ DLL_EXPORT int lut_scl_scc_blz(char *blz,int *retval,const char **used_bic)
  * # Diese Funktion entspricht der Funktion lut_scl_multi_blz(), nur wird    #
  * # die BLZ als Integer-Wert statt als String �bergeben.                    #
  * #                                                                         #
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de>             #
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com>               #
  * ###########################################################################
  */
 DLL_EXPORT int lut_scl_multi_blz_i(int blz,const char **scl_flags,const char **used_bic,const char **scl_name)
 {
    const char *bic;
-   int i,rv;
+   int i,rv,raw;
 
    bic=lut_bic_i(blz,0,&rv);
    if(rv<0)return rv;
-   i=scl_idx(bic,&rv);
+   i=scl_idx(bic,&rv,&raw);
    if(rv<0)return rv;
    if(scl_flags)*scl_flags=scl_flags_array[i];
    if(used_bic)*used_bic=scl_bic_array[i];
@@ -26960,6 +27093,7 @@ XI lut_info(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)EXC
 XI lut_info_b(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)EXCLUDED
 XI lut_info_id(char *lut_name,int *info1,int *info2,int *valid1,int *valid2)EXCLUDED
 XI lut_valid(void)EXCLUDED
+XI lut_valid_date(char *lut_name,int *v11,int *v12,int *v21,int *v22)EXCLUDED
 XI lut_multiple(char *b,int *cnt,int **p_blz,char  ***p_name,char ***p_name_kurz,int **p_plz,char ***p_ort,
       int **p_pan,char ***p_bic,int *p_pz,int **p_nr,char **p_aenderung,char **p_loeschung,int **p_nachfolge_blz,
       int *id,int *cnt_all,int **start_idx)EXCLUDED