RubyGems - konto_check - Versions diffs - 6.13.0 → 6.15.0 - Mend

konto_check 6.13.0 → 6.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

checksums.yaml +4 -4
data/README.textile +1 -1
data/ext/konto_check_raw/konto_check.c +302 -188
data/ext/konto_check_raw/konto_check.h +6 -6
data/ext/konto_check_raw/konto_check_raw_ruby.c +1 -1
data/ext/konto_check_raw/retvals.h +7 -7
metadata +7 -7

data/ext/konto_check_raw/konto_check.c CHANGED Viewed

@@ -13,7 +13,7 @@
  * #  wurden aus der aktuellen BLZ-Datei der Deutschen Bundesbank           #
  * #  �bernommen.                                                           #
  * #                                                                        #
- * #  Copyright (C) 2002-2020 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   #
@@ -48,11 +48,11 @@
 /* Definitionen und Includes  */
 #ifndef VERSION
-#define VERSION "6.13 (final)"
+#define VERSION "6.15 (final)"
 #define VERSION_MAJOR 6
-#define VERSION_MINOR 13
+#define VERSION_MINOR 15
 #endif
-#define VERSION_DATE "2020-12-16"
+#define VERSION_DATE "2023-04-13"
 #ifndef INCLUDE_KONTO_CHECK_DE
 #define INCLUDE_KONTO_CHECK_DE 1
@@ -92,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
@@ -206,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;
@@ -216,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) */
@@ -808,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>               #
  * ###########################################################################
  */
@@ -835,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>               #
  * ###########################################################################
  */
@@ -888,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>               #
  * ###########################################################################
  */
@@ -909,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>               #
  * ###########################################################################
  */
@@ -946,7 +948,7 @@ 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>               #
  * ###########################################################################
  */
@@ -983,7 +985,7 @@ 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>                 #
  * #############################################################################
  */
@@ -1118,7 +1120,7 @@ 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>               #
  * ###########################################################################
  */
@@ -1140,7 +1142,7 @@ 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>               #
  * ###########################################################################
  */
@@ -1161,7 +1163,7 @@ 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>               #
  * ###########################################################################
  */
@@ -1418,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>                 #
  * #############################################################################
  */
@@ -1587,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>               #
  * ###########################################################################
  */
@@ -2159,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>               #
  * ###########################################################################
  */
@@ -2211,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>         #
  * ###########################################################################
  */
@@ -2591,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>          #
  * ###########################################################################
  */
@@ -2701,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)
@@ -2773,7 +2775,7 @@ DLL_EXPORT int lut_valid_date(char *lut_name,int *v11,int *v12,int *v21,int *v22
  * # 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>               #
  * ###########################################################################
  */
@@ -2806,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>               #
  * ###########################################################################
  */
@@ -2874,7 +2876,7 @@ 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>               #
  * ###########################################################################
  */
@@ -3089,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>               #
  * ###########################################################################
  */
@@ -3200,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>               #
  * ###########################################################################
  */
@@ -3247,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>               #
  * ###########################################################################
  */
@@ -3265,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>               #
  * ###########################################################################
  */
@@ -3305,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>               #
  * ###########################################################################
  */
@@ -3327,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>               #
  * ###########################################################################
  */
@@ -3425,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>               #
  * ###########################################################################
  */
@@ -3456,7 +3458,7 @@ 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>               #
  * ###########################################################################
  */
 DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,int incremental)
@@ -4269,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)
@@ -4343,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)
@@ -4374,7 +4376,7 @@ 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>               #
  * ###########################################################################
  */
@@ -4396,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>               #
  * ###########################################################################
  */
@@ -4445,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>               #
  * ###########################################################################
  */
@@ -4514,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>               #
  * ###########################################################################
  */
@@ -4525,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>               #
  * ###########################################################################
  */
@@ -4556,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>               #
  * ###########################################################################
  */
@@ -4584,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>               #
  * ###########################################################################
  */
@@ -4619,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>               #
  * ###########################################################################
  */
@@ -4647,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>               #
  * ###########################################################################
  */
@@ -4675,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>               #
  * ###########################################################################
  */
@@ -4715,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>               #
  * ###########################################################################
  */
@@ -4771,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>          #
  * ###########################################################################
  */
@@ -4883,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>               #
  * ###########################################################################
  */
@@ -4912,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>               #
  * ###########################################################################
  */
@@ -4945,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>               #
  * ###########################################################################
  */
@@ -4985,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>               #
  * ###########################################################################
  */
@@ -5018,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>               #
  * ###########################################################################
  */
@@ -5052,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>               #
  * ###########################################################################
  */
@@ -5087,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>               #
  * ###########################################################################
  */
@@ -5128,7 +5130,7 @@ 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>               #
  * ###########################################################################
  */
@@ -5232,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;
@@ -8316,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>               #
  * ###########################################################################
  */
@@ -8527,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>               #
  * ###########################################################################
  */
@@ -8666,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>          #
  * ###########################################################################
  */
@@ -8688,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>          #
  * ###########################################################################
  */
@@ -8806,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>               #
  * ###########################################################################
  */
@@ -8950,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;
@@ -8982,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";
@@ -9014,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)";
@@ -9045,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.";
@@ -9077,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";
@@ -9108,7 +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;
+   lut_block_name2[132]="2. SCL Flags orig";
+   lut_blocklen_max=544;
    init_status|=1;
 }
@@ -9132,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>          #
  * ###########################################################################
  */
@@ -20143,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>               #
  * ###########################################################################
  */
@@ -20208,7 +20218,7 @@ 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>               #
  * ###########################################################################
  */
@@ -20315,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>               #
  * ###########################################################################
  */
@@ -20357,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>               #
  * ###########################################################################
  */
@@ -20410,7 +20420,7 @@ 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>               #
  * ###########################################################################
  */
 DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals)
@@ -20448,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>               #
  * ###########################################################################
  */
@@ -20500,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>          #
  * ###########################################################################
  */
@@ -20582,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>               #
  * ###########################################################################
  */
@@ -20673,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>          #
  * ######################################################################
  */
@@ -20712,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>          #
  * ######################################################################
  */
@@ -20738,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>               #
  * ###########################################################################
  */
@@ -20757,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>               #
  * ###########################################################################
  */
@@ -20789,13 +20799,13 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
       case 5:
         return "09.09.2019";
       case 6:
-        return "16. Dezember 2020";            /* 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 "13";             /* Unterversionszahl */
+        return "15";             /* Unterversionszahl */
    }
 }
@@ -20810,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>               #
  * ###########################################################################
  */
@@ -20841,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>               #
  * ###########################################################################
  */
@@ -21036,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>          #
  * ###########################################################################
  */
@@ -21147,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>               #
  * ###########################################################################
  */
@@ -21250,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>               #
  * ###########################################################################
  */
@@ -21336,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>          #
  * ###########################################################################
  */
@@ -21588,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>               #
  * ###########################################################################
  */
@@ -21674,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>               #
  * ###########################################################################
  */
@@ -21945,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>               #
  * ###########################################################################
  */
@@ -22011,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>               #
  * ###########################################################################
  */
@@ -22040,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>               #
  * ###########################################################################
  */
@@ -22094,7 +22104,7 @@ 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>          #
  * ###########################################################################
  */
@@ -23988,6 +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 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;
@@ -24169,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>                   #
  * ###############################################################################
  */
@@ -24192,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>                   #
  * ###############################################################################
  */
@@ -24215,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>                   #
  * ###############################################################################
  */
@@ -24238,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>                   #
  * ###############################################################################
  */
@@ -24261,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>                   #
  * ###############################################################################
  */
@@ -24284,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>                   #
  * ###############################################################################
  */
@@ -24307,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>                   #
  * ###############################################################################
  */
@@ -24330,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>                   #
  * ###############################################################################
  */
@@ -24353,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>                   #
  * ###############################################################################
  */
@@ -24376,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>                   #
  * ###############################################################################
  */
@@ -24399,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>                   #
  * ###############################################################################
  */
@@ -24422,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>                   #
  * ###############################################################################
  */
@@ -24445,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>                   #
  * ###############################################################################
  */
@@ -24771,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>               #
  * ###########################################################################
  */
@@ -24827,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>               #
  * ###########################################################################
  */
@@ -24863,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>               #
  * ###########################################################################
  */
@@ -24942,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>               #
  * ###########################################################################
  */
@@ -24974,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>               #
  * ###########################################################################
  */
@@ -25002,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>               #
  * ###########################################################################
  */
@@ -25047,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>               #
  * ###########################################################################
  */
@@ -25198,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>               #
  * ###########################################################################
  */
@@ -25256,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>               #
  * ###########################################################################
  */
@@ -25293,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>               #
  * ###########################################################################
  */
@@ -25875,7 +25883,7 @@ 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>               #
  * ###########################################################################
  */
@@ -25899,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>               #
  * ###########################################################################
  */
@@ -25927,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 */
@@ -26070,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>               #
  * ###########################################################################
  */
@@ -26088,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>               #
  * ###########################################################################
  */
@@ -26132,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>               #
  * ###########################################################################
  */
@@ -26153,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>               #
  * ###########################################################################
  */
@@ -26177,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)
@@ -26197,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)
@@ -26222,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;
@@ -26234,7 +26250,14 @@ 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]);
    /*
@@ -26258,6 +26281,9 @@ static int scl_idx(const char *bic,int *retval)
     * 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 */
@@ -26309,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);
@@ -26337,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;
@@ -26371,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);
@@ -26387,14 +26419,68 @@ 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);
@@ -26408,13 +26494,14 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
    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){
@@ -26422,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){
@@ -26429,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);
    }
@@ -26443,6 +26541,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(OK);
 }
@@ -26451,17 +26550,17 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
  * # 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){
@@ -26492,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);
@@ -26499,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;
@@ -26514,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);
 }
@@ -26523,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)
@@ -26559,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;
@@ -26581,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;
@@ -26607,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;
@@ -26634,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;
@@ -26660,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;
@@ -26686,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;
@@ -26712,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];
@@ -26737,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){
@@ -26753,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;
@@ -26772,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){
@@ -26788,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;
@@ -26808,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){
@@ -26824,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;
@@ -26843,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){
@@ -26859,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;
@@ -26878,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){
@@ -26894,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;
@@ -26911,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];